@venos-inc/venos 0.1.14 → 0.1.15

package/etc/mcp-server/node_modules/@types/node/child_process.d.ts

@@ -4,7 +4,7 @@
  * is primarily provided by the {@link spawn} function:
  *
  * ```js
- * import { spawn } from 'node:child_process';
+ * const { spawn } = require('node:child_process');
  * const ls = spawn('ls', ['-lh', '/usr']);
  *
  * ls.stdout.on('data', (data) => {
@@ -24,7 +24,7 @@
  * the parent Node.js process and the spawned subprocess. These pipes have
  * limited (and platform-specific) capacity. If the subprocess writes to
  * stdout in excess of that limit without the output being captured, the
- * subprocess blocks, waiting for the pipe buffer to accept more data. This is
+ * subprocess blocks waiting for the pipe buffer to accept more data. This is
  * identical to the behavior of pipes in the shell. Use the `{ stdio: 'ignore' }` option if the output will not be consumed.
  *
  * The command lookup is performed using the `options.env.PATH` environment
@@ -63,14 +63,14 @@
  * For certain use cases, such as automating shell scripts, the `synchronous counterparts` may be more convenient. In many cases, however,
  * the synchronous methods can have significant impact on performance due to
  * stalling the event loop while spawned processes complete.
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/child_process.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/child_process.js)
  */
 declare module "child_process" {
-    import { NonSharedBuffer } from "node:buffer";
+    import { ObjectEncodingOptions } from "node:fs";
     import { Abortable, EventEmitter } from "node:events";
     import * as dgram from "node:dgram";
     import * as net from "node:net";
-    import { Readable, Stream, Writable } from "node:stream";
+    import { Pipe, Readable, Stream, Writable } from "node:stream";
     import { URL } from "node:url";
     type Serializable = string | object | number | boolean | bigint;
     type SendHandle = net.Socket | net.Server | dgram.Socket | undefined;
@@ -109,7 +109,7 @@ declare module "child_process" {
          * refer to the same value.
          *
          * ```js
-         * import { spawn } from 'node:child_process';
+         * const { spawn } = require('node:child_process');
          *
          * const subprocess = spawn('ls');
          *
@@ -140,7 +140,7 @@ declare module "child_process" {
          * no IPC channel exists, this property is `undefined`.
          * @since v7.1.0
          */
-        readonly channel?: Control | null;
+        readonly channel?: Pipe | null | undefined;
         /**
          * A sparse array of pipes to the child process, corresponding with positions in
          * the `stdio` option passed to {@link spawn} that have been set
@@ -152,9 +152,9 @@ declare module "child_process" {
          * in the array are `null`.
          *
          * ```js
-         * import assert from 'node:assert';
-         * import fs from 'node:fs';
-         * import child_process from 'node:child_process';
+         * const assert = require('node:assert');
+         * const fs = require('node:fs');
+         * const child_process = require('node:child_process');
          *
          * const subprocess = child_process.spawn('ls', {
          *   stdio: [
@@ -202,7 +202,7 @@ declare module "child_process" {
          * emitted.
          *
          * ```js
-         * import { spawn } from 'node:child_process';
+         * const { spawn } = require('node:child_process');
          * const grep = spawn('grep', ['ssh']);
          *
          * console.log(`Spawned child pid: ${grep.pid}`);
@@ -249,7 +249,7 @@ declare module "child_process" {
          * returns `true` if [`kill(2)`](http://man7.org/linux/man-pages/man2/kill.2.html) succeeds, and `false` otherwise.
          *
          * ```js
-         * import { spawn } from 'node:child_process';
+         * const { spawn } = require('node:child_process');
          * const grep = spawn('grep', ['ssh']);
          *
          * grep.on('close', (code, signal) => {
@@ -282,7 +282,7 @@ declare module "child_process" {
          *
          * ```js
          * 'use strict';
-         * import { spawn } from 'node:child_process';
+         * const { spawn } = require('node:child_process');
          *
          * const subprocess = spawn(
          *   'sh',
@@ -320,7 +320,7 @@ declare module "child_process" {
          * For example, in the parent script:
          *
          * ```js
-         * import cp from 'node:child_process';
+         * const cp = require('node:child_process');
          * const n = cp.fork(`${__dirname}/sub.js`);
          *
          * n.on('message', (m) => {
@@ -374,12 +374,10 @@ declare module "child_process" {
          * a TCP server object to the child process as illustrated in the example below:
          *
          * ```js
-         * import { createServer } from 'node:net';
-         * import { fork } from 'node:child_process';
-         * const subprocess = fork('subprocess.js');
+         * const subprocess = require('node:child_process').fork('subprocess.js');
          *
          * // Open up the server object and send the handle.
-         * const server = createServer();
+         * const server = require('node:net').createServer();
          * server.on('connection', (socket) => {
          *   socket.end('handled by parent');
          * });
@@ -414,14 +412,13 @@ declare module "child_process" {
          * handle connections with "normal" or "special" priority:
          *
          * ```js
-         * import { createServer } from 'node:net';
-         * import { fork } from 'node:child_process';
+         * const { fork } = require('node:child_process');
          * const normal = fork('subprocess.js', ['normal']);
          * const special = fork('subprocess.js', ['special']);
          *
          * // Open up the server and send sockets to child. Use pauseOnConnect to prevent
          * // the sockets from being read before they are sent to the child process.
-         * const server = createServer({ pauseOnConnect: true });
+         * const server = require('node:net').createServer({ pauseOnConnect: true });
          * server.on('connection', (socket) => {
          *
          *   // If this is special priority...
@@ -458,7 +455,7 @@ declare module "child_process" {
          * as the connection may have been closed during the time it takes to send the
          * connection to the child.
          * @since v0.5.9
-         * @param sendHandle `undefined`, or a [`net.Socket`](https://nodejs.org/docs/latest-v22.x/api/net.html#class-netsocket), [`net.Server`](https://nodejs.org/docs/latest-v22.x/api/net.html#class-netserver), or [`dgram.Socket`](https://nodejs.org/docs/latest-v22.x/api/dgram.html#class-dgramsocket) object.
+         * @param sendHandle `undefined`, or a [`net.Socket`](https://nodejs.org/docs/latest-v20.x/api/net.html#class-netsocket), [`net.Server`](https://nodejs.org/docs/latest-v20.x/api/net.html#class-netserver), or [`dgram.Socket`](https://nodejs.org/docs/latest-v20.x/api/dgram.html#class-dgramsocket) object.
          * @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles. `options` supports the following properties:
          */
         send(message: Serializable, callback?: (error: Error | null) => void): boolean;
@@ -493,7 +490,7 @@ declare module "child_process" {
          * the child and the parent.
          *
          * ```js
-         * import { spawn } from 'node:child_process';
+         * const { spawn } = require('node:child_process');
          *
          * const subprocess = spawn(process.argv[0], ['child_program.js'], {
          *   detached: true,
@@ -511,7 +508,7 @@ declare module "child_process" {
          * to wait for the child to exit before exiting itself.
          *
          * ```js
-         * import { spawn } from 'node:child_process';
+         * const { spawn } = require('node:child_process');
          *
          * const subprocess = spawn(process.argv[0], ['child_program.js'], {
          *   detached: true,
@@ -613,10 +610,6 @@ declare module "child_process" {
             Readable | Writable | null | undefined, // extra, no modification
         ];
     }
-    interface Control extends EventEmitter {
-        ref(): void;
-        unref(): void;
-    }
     interface MessageOptions {
         keepOpen?: boolean | undefined;
     }
@@ -718,7 +711,7 @@ declare module "child_process" {
      * exit code:
      *
      * ```js
-     * import { spawn } from 'node:child_process';
+     * const { spawn } = require('node:child_process');
      * const ls = spawn('ls', ['-lh', '/usr']);
      *
      * ls.stdout.on('data', (data) => {
@@ -737,7 +730,7 @@ declare module "child_process" {
      * Example: A very elaborate way to run `ps ax | grep ssh`
      *
      * ```js
-     * import { spawn } from 'node:child_process';
+     * const { spawn } = require('node:child_process');
      * const ps = spawn('ps', ['ax']);
      * const grep = spawn('grep', ['ssh']);
      *
@@ -774,7 +767,7 @@ declare module "child_process" {
      * Example of checking for failed `spawn`:
      *
      * ```js
-     * import { spawn } from 'node:child_process';
+     * const { spawn } = require('node:child_process');
      * const subprocess = spawn('bad_command');
      *
      * subprocess.on('error', (err) => {
@@ -792,7 +785,7 @@ declare module "child_process" {
      * the error passed to the callback will be an `AbortError`:
      *
      * ```js
-     * import { spawn } from 'node:child_process';
+     * const { spawn } = require('node:child_process');
      * const controller = new AbortController();
      * const { signal } = controller;
      * const grep = spawn('grep', ['ssh'], { signal });
@@ -891,20 +884,18 @@ declare module "child_process" {
         signal?: AbortSignal | undefined;
         maxBuffer?: number | undefined;
         killSignal?: NodeJS.Signals | number | undefined;
-        encoding?: string | null | undefined;
     }
     interface ExecOptionsWithStringEncoding extends ExecOptions {
-        encoding?: BufferEncoding | undefined;
+        encoding: BufferEncoding;
     }
     interface ExecOptionsWithBufferEncoding extends ExecOptions {
-        encoding: "buffer" | null; // specify `null`.
+        encoding: BufferEncoding | null; // specify `null`.
     }
-    // TODO: Just Plain Wrong™ (see also nodejs/node#57392)
     interface ExecException extends Error {
-        cmd?: string;
-        killed?: boolean;
-        code?: number;
-        signal?: NodeJS.Signals;
+        cmd?: string | undefined;
+        killed?: boolean | undefined;
+        code?: number | undefined;
+        signal?: NodeJS.Signals | undefined;
         stdout?: string;
         stderr?: string;
     }
@@ -915,7 +906,7 @@ declare module "child_process" {
      * need to be dealt with accordingly:
      *
      * ```js
-     * import { exec } from 'node:child_process';
+     * const { exec } = require('node:child_process');
      *
      * exec('"/path/to/test file/test.sh" arg1 arg2');
      * // Double quotes are used so that the space in the path is not interpreted as
@@ -941,7 +932,7 @@ declare module "child_process" {
      * encoding, `Buffer` objects will be passed to the callback instead.
      *
      * ```js
-     * import { exec } from 'node:child_process';
+     * const { exec } = require('node:child_process');
      * exec('cat *.js missing_file | wc -l', (error, stdout, stderr) => {
      *   if (error) {
      *     console.error(`exec error: ${error}`);
@@ -966,9 +957,8 @@ declare module "child_process" {
      * callback, but with two additional properties `stdout` and `stderr`.
      *
      * ```js
-     * import util from 'node:util';
-     * import child_process from 'node:child_process';
-     * const exec = util.promisify(child_process.exec);
+     * const util = require('node:util');
+     * const exec = util.promisify(require('node:child_process').exec);
      *
      * async function lsExample() {
      *   const { stdout, stderr } = await exec('ls');
@@ -982,7 +972,7 @@ declare module "child_process" {
      * the error passed to the callback will be an `AbortError`:
      *
      * ```js
-     * import { exec } from 'node:child_process';
+     * const { exec } = require('node:child_process');
      * const controller = new AbortController();
      * const { signal } = controller;
      * const child = exec('grep ssh', { signal }, (error) => {
@@ -1001,24 +991,39 @@ declare module "child_process" {
     // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`.
     function exec(
         command: string,
-        options: ExecOptionsWithBufferEncoding,
-        callback?: (error: ExecException | null, stdout: NonSharedBuffer, stderr: NonSharedBuffer) => void,
+        options: {
+            encoding: "buffer" | null;
+        } & ExecOptions,
+        callback?: (error: ExecException | null, stdout: Buffer, stderr: Buffer) => void,
     ): ChildProcess;
-    // `options` with well-known or absent `encoding` means stdout/stderr are definitely `string`.
+    // `options` with well known `encoding` means stdout/stderr are definitely `string`.
     function exec(
         command: string,
-        options: ExecOptionsWithStringEncoding,
+        options: {
+            encoding: BufferEncoding;
+        } & ExecOptions,
+        callback?: (error: ExecException | null, stdout: string, stderr: string) => void,
+    ): ChildProcess;
+    // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`.
+    // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`.
+    function exec(
+        command: string,
+        options: {
+            encoding: BufferEncoding;
+        } & ExecOptions,
+        callback?: (error: ExecException | null, stdout: string | Buffer, stderr: string | Buffer) => void,
+    ): ChildProcess;
+    // `options` without an `encoding` means stdout/stderr are definitely `string`.
+    function exec(
+        command: string,
+        options: ExecOptions,
         callback?: (error: ExecException | null, stdout: string, stderr: string) => void,
     ): ChildProcess;
     // fallback if nothing else matches. Worst case is always `string | Buffer`.
     function exec(
         command: string,
-        options: ExecOptions | undefined | null,
-        callback?: (
-            error: ExecException | null,
-            stdout: string | NonSharedBuffer,
-            stderr: string | NonSharedBuffer,
-        ) => void,
+        options: (ObjectEncodingOptions & ExecOptions) | undefined | null,
+        callback?: (error: ExecException | null, stdout: string | Buffer, stderr: string | Buffer) => void,
     ): ChildProcess;
     interface PromiseWithChild<T> extends Promise<T> {
         child: ChildProcess;
@@ -1030,24 +1035,35 @@ declare module "child_process" {
         }>;
         function __promisify__(
             command: string,
-            options: ExecOptionsWithBufferEncoding,
+            options: {
+                encoding: "buffer" | null;
+            } & ExecOptions,
+        ): PromiseWithChild<{
+            stdout: Buffer;
+            stderr: Buffer;
+        }>;
+        function __promisify__(
+            command: string,
+            options: {
+                encoding: BufferEncoding;
+            } & ExecOptions,
         ): PromiseWithChild<{
-            stdout: NonSharedBuffer;
-            stderr: NonSharedBuffer;
+            stdout: string;
+            stderr: string;
         }>;
         function __promisify__(
             command: string,
-            options: ExecOptionsWithStringEncoding,
+            options: ExecOptions,
         ): PromiseWithChild<{
             stdout: string;
             stderr: string;
         }>;
         function __promisify__(
             command: string,
-            options: ExecOptions | undefined | null,
+            options?: (ObjectEncodingOptions & ExecOptions) | null,
         ): PromiseWithChild<{
-            stdout: string | NonSharedBuffer;
-            stderr: string | NonSharedBuffer;
+            stdout: string | Buffer;
+            stderr: string | Buffer;
         }>;
     }
     interface ExecFileOptions extends CommonOptions, Abortable {
@@ -1056,21 +1072,20 @@ declare module "child_process" {
         windowsVerbatimArguments?: boolean | undefined;
         shell?: boolean | string | undefined;
         signal?: AbortSignal | undefined;
-        encoding?: string | null | undefined;
     }
     interface ExecFileOptionsWithStringEncoding extends ExecFileOptions {
-        encoding?: BufferEncoding | undefined;
+        encoding: BufferEncoding;
     }
     interface ExecFileOptionsWithBufferEncoding extends ExecFileOptions {
         encoding: "buffer" | null;
     }
-    /** @deprecated Use `ExecFileOptions` instead. */
-    interface ExecFileOptionsWithOtherEncoding extends ExecFileOptions {}
-    // TODO: execFile exceptions can take many forms... this accurately describes none of them
+    interface ExecFileOptionsWithOtherEncoding extends ExecFileOptions {
+        encoding: BufferEncoding;
+    }
     type ExecFileException =
         & Omit<ExecException, "code">
         & Omit<NodeJS.ErrnoException, "code">
-        & { code?: string | number | null };
+        & { code?: string | number | undefined | null };
     /**
      * The `child_process.execFile()` function is similar to {@link exec} except that it does not spawn a shell by default. Rather, the specified
      * executable `file` is spawned directly as a new process making it slightly more
@@ -1081,7 +1096,7 @@ declare module "child_process" {
      * supported.
      *
      * ```js
-     * import { execFile } from 'node:child_process';
+     * const { execFile } = require('node:child_process');
      * const child = execFile('node', ['--version'], (error, stdout, stderr) => {
      *   if (error) {
      *     throw error;
@@ -1104,9 +1119,8 @@ declare module "child_process" {
      * callback, but with two additional properties `stdout` and `stderr`.
      *
      * ```js
-     * import util from 'node:util';
-     * import child_process from 'node:child_process';
-     * const execFile = util.promisify(child_process.execFile);
+     * const util = require('node:util');
+     * const execFile = util.promisify(require('node:child_process').execFile);
      * async function getVersion() {
      *   const { stdout } = await execFile('node', ['--version']);
      *   console.log(stdout);
@@ -1122,7 +1136,7 @@ declare module "child_process" {
      * the error passed to the callback will be an `AbortError`:
      *
      * ```js
-     * import { execFile } from 'node:child_process';
+     * const { execFile } = require('node:child_process');
      * const controller = new AbortController();
      * const { signal } = controller;
      * const child = execFile('node', ['--version'], { signal }, (error) => {
@@ -1135,63 +1149,91 @@ declare module "child_process" {
      * @param args List of string arguments.
      * @param callback Called with the output when process terminates.
      */
+    function execFile(file: string): ChildProcess;
+    function execFile(
+        file: string,
+        options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null,
+    ): ChildProcess;
+    function execFile(file: string, args?: readonly string[] | null): ChildProcess;
+    function execFile(
+        file: string,
+        args: readonly string[] | undefined | null,
+        options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null,
+    ): ChildProcess;
     // no `options` definitely means stdout/stderr are `string`.
     function execFile(
         file: string,
-        callback?: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
     ): ChildProcess;
     function execFile(
         file: string,
         args: readonly string[] | undefined | null,
-        callback?: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
     ): ChildProcess;
     // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`.
     function execFile(
         file: string,
         options: ExecFileOptionsWithBufferEncoding,
-        callback?: (error: ExecFileException | null, stdout: NonSharedBuffer, stderr: NonSharedBuffer) => void,
+        callback: (error: ExecFileException | null, stdout: Buffer, stderr: Buffer) => void,
     ): ChildProcess;
     function execFile(
         file: string,
         args: readonly string[] | undefined | null,
         options: ExecFileOptionsWithBufferEncoding,
-        callback?: (error: ExecFileException | null, stdout: NonSharedBuffer, stderr: NonSharedBuffer) => void,
+        callback: (error: ExecFileException | null, stdout: Buffer, stderr: Buffer) => void,
     ): ChildProcess;
-    // `options` with well-known or absent `encoding` means stdout/stderr are definitely `string`.
+    // `options` with well known `encoding` means stdout/stderr are definitely `string`.
     function execFile(
         file: string,
         options: ExecFileOptionsWithStringEncoding,
-        callback?: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
     ): ChildProcess;
     function execFile(
         file: string,
         args: readonly string[] | undefined | null,
         options: ExecFileOptionsWithStringEncoding,
-        callback?: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+    ): ChildProcess;
+    // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`.
+    // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`.
+    function execFile(
+        file: string,
+        options: ExecFileOptionsWithOtherEncoding,
+        callback: (error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void,
+    ): ChildProcess;
+    function execFile(
+        file: string,
+        args: readonly string[] | undefined | null,
+        options: ExecFileOptionsWithOtherEncoding,
+        callback: (error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void,
+    ): ChildProcess;
+    // `options` without an `encoding` means stdout/stderr are definitely `string`.
+    function execFile(
+        file: string,
+        options: ExecFileOptions,
+        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+    ): ChildProcess;
+    function execFile(
+        file: string,
+        args: readonly string[] | undefined | null,
+        options: ExecFileOptions,
+        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
     ): ChildProcess;
     // fallback if nothing else matches. Worst case is always `string | Buffer`.
     function execFile(
         file: string,
-        options: ExecFileOptions | undefined | null,
+        options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null,
         callback:
-            | ((
-                error: ExecFileException | null,
-                stdout: string | NonSharedBuffer,
-                stderr: string | NonSharedBuffer,
-            ) => void)
+            | ((error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void)
             | undefined
             | null,
     ): ChildProcess;
     function execFile(
         file: string,
         args: readonly string[] | undefined | null,
-        options: ExecFileOptions | undefined | null,
+        options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null,
         callback:
-            | ((
-                error: ExecFileException | null,
-                stdout: string | NonSharedBuffer,
-                stderr: string | NonSharedBuffer,
-            ) => void)
+            | ((error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void)
             | undefined
             | null,
     ): ChildProcess;
@@ -1211,16 +1253,16 @@ declare module "child_process" {
             file: string,
             options: ExecFileOptionsWithBufferEncoding,
         ): PromiseWithChild<{
-            stdout: NonSharedBuffer;
-            stderr: NonSharedBuffer;
+            stdout: Buffer;
+            stderr: Buffer;
         }>;
         function __promisify__(
             file: string,
             args: readonly string[] | undefined | null,
             options: ExecFileOptionsWithBufferEncoding,
         ): PromiseWithChild<{
-            stdout: NonSharedBuffer;
-            stderr: NonSharedBuffer;
+            stdout: Buffer;
+            stderr: Buffer;
         }>;
         function __promisify__(
             file: string,
@@ -1239,18 +1281,48 @@ declare module "child_process" {
         }>;
         function __promisify__(
             file: string,
-            options: ExecFileOptions | undefined | null,
+            options: ExecFileOptionsWithOtherEncoding,
         ): PromiseWithChild<{
-            stdout: string | NonSharedBuffer;
-            stderr: string | NonSharedBuffer;
+            stdout: string | Buffer;
+            stderr: string | Buffer;
         }>;
         function __promisify__(
             file: string,
             args: readonly string[] | undefined | null,
-            options: ExecFileOptions | undefined | null,
+            options: ExecFileOptionsWithOtherEncoding,
         ): PromiseWithChild<{
-            stdout: string | NonSharedBuffer;
-            stderr: string | NonSharedBuffer;
+            stdout: string | Buffer;
+            stderr: string | Buffer;
+        }>;
+        function __promisify__(
+            file: string,
+            options: ExecFileOptions,
+        ): PromiseWithChild<{
+            stdout: string;
+            stderr: string;
+        }>;
+        function __promisify__(
+            file: string,
+            args: readonly string[] | undefined | null,
+            options: ExecFileOptions,
+        ): PromiseWithChild<{
+            stdout: string;
+            stderr: string;
+        }>;
+        function __promisify__(
+            file: string,
+            options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null,
+        ): PromiseWithChild<{
+            stdout: string | Buffer;
+            stderr: string | Buffer;
+        }>;
+        function __promisify__(
+            file: string,
+            args: readonly string[] | undefined | null,
+            options: (ObjectEncodingOptions & ExecFileOptions) | undefined | null,
+        ): PromiseWithChild<{
+            stdout: string | Buffer;
+            stderr: string | Buffer;
         }>;
     }
     interface ForkOptions extends ProcessEnvOptions, MessagingOptions, Abortable {
@@ -1305,7 +1377,7 @@ declare module "child_process" {
      *     console.log(`Hello from ${process.argv[2]}!`);
      *   }, 1_000);
      * } else {
-     *   import { fork } from 'node:child_process';
+     *   const { fork } = require('node:child_process');
      *   const controller = new AbortController();
      *   const { signal } = controller;
      *   const child = fork(__filename, ['child'], { signal });
@@ -1339,7 +1411,7 @@ declare module "child_process" {
         stderr: T;
         status: number | null;
         signal: NodeJS.Signals | null;
-        error?: Error;
+        error?: Error | undefined;
     }
     /**
      * The `child_process.spawnSync()` method is generally identical to {@link spawn} with the exception that the function will not return
@@ -1356,11 +1428,11 @@ declare module "child_process" {
      * @param command The command to run.
      * @param args List of string arguments.
      */
-    function spawnSync(command: string): SpawnSyncReturns<NonSharedBuffer>;
+    function spawnSync(command: string): SpawnSyncReturns<Buffer>;
     function spawnSync(command: string, options: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
-    function spawnSync(command: string, options: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<NonSharedBuffer>;
-    function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<string | NonSharedBuffer>;
-    function spawnSync(command: string, args: readonly string[]): SpawnSyncReturns<NonSharedBuffer>;
+    function spawnSync(command: string, options: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
+    function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
+    function spawnSync(command: string, args: readonly string[]): SpawnSyncReturns<Buffer>;
     function spawnSync(
         command: string,
         args: readonly string[],
@@ -1370,12 +1442,12 @@ declare module "child_process" {
         command: string,
         args: readonly string[],
         options: SpawnSyncOptionsWithBufferEncoding,
-    ): SpawnSyncReturns<NonSharedBuffer>;
+    ): SpawnSyncReturns<Buffer>;
     function spawnSync(
         command: string,
         args?: readonly string[],
         options?: SpawnSyncOptions,
-    ): SpawnSyncReturns<string | NonSharedBuffer>;
+    ): SpawnSyncReturns<string | Buffer>;
     interface CommonExecOptions extends CommonOptions {
         input?: string | NodeJS.ArrayBufferView | undefined;
         /**
@@ -1417,10 +1489,10 @@ declare module "child_process" {
      * @param command The command to run.
      * @return The stdout from the command.
      */
-    function execSync(command: string): NonSharedBuffer;
+    function execSync(command: string): Buffer;
     function execSync(command: string, options: ExecSyncOptionsWithStringEncoding): string;
-    function execSync(command: string, options: ExecSyncOptionsWithBufferEncoding): NonSharedBuffer;
-    function execSync(command: string, options?: ExecSyncOptions): string | NonSharedBuffer;
+    function execSync(command: string, options: ExecSyncOptionsWithBufferEncoding): Buffer;
+    function execSync(command: string, options?: ExecSyncOptions): string | Buffer;
     interface ExecFileSyncOptions extends CommonExecOptions {
         shell?: boolean | string | undefined;
     }
@@ -1428,7 +1500,7 @@ declare module "child_process" {
         encoding: BufferEncoding;
     }
     interface ExecFileSyncOptionsWithBufferEncoding extends ExecFileSyncOptions {
-        encoding?: "buffer" | null | undefined; // specify `null`.
+        encoding?: "buffer" | null; // specify `null`.
     }
     /**
      * The `child_process.execFileSync()` method is generally identical to {@link execFile} with the exception that the method will not
@@ -1450,11 +1522,11 @@ declare module "child_process" {
      * @param args List of string arguments.
      * @return The stdout from the command.
      */
-    function execFileSync(file: string): NonSharedBuffer;
+    function execFileSync(file: string): Buffer;
     function execFileSync(file: string, options: ExecFileSyncOptionsWithStringEncoding): string;
-    function execFileSync(file: string, options: ExecFileSyncOptionsWithBufferEncoding): NonSharedBuffer;
-    function execFileSync(file: string, options?: ExecFileSyncOptions): string | NonSharedBuffer;
-    function execFileSync(file: string, args: readonly string[]): NonSharedBuffer;
+    function execFileSync(file: string, options: ExecFileSyncOptionsWithBufferEncoding): Buffer;
+    function execFileSync(file: string, options?: ExecFileSyncOptions): string | Buffer;
+    function execFileSync(file: string, args: readonly string[]): Buffer;
     function execFileSync(
         file: string,
         args: readonly string[],
@@ -1464,12 +1536,8 @@ declare module "child_process" {
         file: string,
         args: readonly string[],
         options: ExecFileSyncOptionsWithBufferEncoding,
-    ): NonSharedBuffer;
-    function execFileSync(
-        file: string,
-        args?: readonly string[],
-        options?: ExecFileSyncOptions,
-    ): string | NonSharedBuffer;
+    ): Buffer;
+    function execFileSync(file: string, args?: readonly string[], options?: ExecFileSyncOptions): string | Buffer;
 }
 declare module "node:child_process" {
     export * from "child_process";