@types/node 14.18.62 → 14.18.63

node v14.18/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v14.
 
 ### Additional Details
- * Last updated: Wed, 20 Sep 2023 03:06:41 GMT
+ * Last updated: Sat, 23 Sep 2023 20:38:33 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
 

node v14.18/assert.d.ts

@@ -1,4 +1,4 @@
-declare module 'assert' {
+declare module "assert" {
     /** An alias of `assert.ok()`. */
     function assert(value: any, message?: string | Error): asserts value;
     namespace assert {
@@ -7,7 +7,7 @@ declare module 'assert' {
             expected: any;
             operator: string;
             generatedMessage: boolean;
-            code: 'ERR_ASSERTION';
+            code: "ERR_ASSERTION";
 
             constructor(options?: {
                 /** If provided, the error message is set to this value. */
@@ -42,7 +42,7 @@ declare module 'assert' {
             stack: object;
         }
 
-        type AssertPredicate = RegExp | (new () => object) | ((thrown: any) => boolean) | object | Error;
+        type AssertPredicate = RegExp | (new() => object) | ((thrown: any) => boolean) | object | Error;
 
         function fail(message?: string | Error): never;
         /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
@@ -91,38 +91,40 @@ declare module 'assert' {
         function match(value: string, regExp: RegExp, message?: string | Error): void;
         function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
 
-        const strict: Omit<
-            typeof assert,
-            | 'equal'
-            | 'notEqual'
-            | 'deepEqual'
-            | 'notDeepEqual'
-            | 'ok'
-            | 'strictEqual'
-            | 'deepStrictEqual'
-            | 'ifError'
-            | 'strict'
-        > & {
-            (value: any, message?: string | Error): asserts value;
-            equal: typeof strictEqual;
-            notEqual: typeof notStrictEqual;
-            deepEqual: typeof deepStrictEqual;
-            notDeepEqual: typeof notDeepStrictEqual;
+        const strict:
+            & Omit<
+                typeof assert,
+                | "equal"
+                | "notEqual"
+                | "deepEqual"
+                | "notDeepEqual"
+                | "ok"
+                | "strictEqual"
+                | "deepStrictEqual"
+                | "ifError"
+                | "strict"
+            >
+            & {
+                (value: any, message?: string | Error): asserts value;
+                equal: typeof strictEqual;
+                notEqual: typeof notStrictEqual;
+                deepEqual: typeof deepStrictEqual;
+                notDeepEqual: typeof notDeepStrictEqual;
 
-            // Mapped types and assertion functions are incompatible?
-            // TS2775: Assertions require every name in the call target
-            // to be declared with an explicit type annotation.
-            ok: typeof ok;
-            strictEqual: typeof strictEqual;
-            deepStrictEqual: typeof deepStrictEqual;
-            ifError: typeof ifError;
-            strict: typeof strict;
-        };
+                // Mapped types and assertion functions are incompatible?
+                // TS2775: Assertions require every name in the call target
+                // to be declared with an explicit type annotation.
+                ok: typeof ok;
+                strictEqual: typeof strictEqual;
+                deepStrictEqual: typeof deepStrictEqual;
+                ifError: typeof ifError;
+                strict: typeof strict;
+            };
     }
 
     export = assert;
 }
-declare module 'node:assert' {
-    import assert = require('assert');
+declare module "node:assert" {
+    import assert = require("assert");
     export = assert;
 }

node v14.18/async_hooks.d.ts

@@ -1,7 +1,7 @@
 /**
  * Async Hooks module: https://nodejs.org/api/async_hooks.html
  */
-declare module 'async_hooks' {
+declare module "async_hooks" {
     /**
      * Returns the asyncId of the current execution context.
      */
@@ -83,20 +83,20 @@ declare module 'async_hooks' {
     function createHook(options: HookCallbacks): AsyncHook;
 
     interface AsyncResourceOptions {
-      /**
-       * The ID of the execution context that created this async event.
-       * @default executionAsyncId()
-       */
-      triggerAsyncId?: number | undefined;
-
-      /**
-       * Disables automatic `emitDestroy` when the object is garbage collected.
-       * This usually does not need to be set (even if `emitDestroy` is called
-       * manually), unless the resource's `asyncId` is retrieved and the
-       * sensitive API's `emitDestroy` is called with it.
-       * @default false
-       */
-      requireManualDestroy?: boolean | undefined;
+        /**
+         * The ID of the execution context that created this async event.
+         * @default executionAsyncId()
+         */
+        triggerAsyncId?: number | undefined;
+
+        /**
+         * Disables automatic `emitDestroy` when the object is garbage collected.
+         * This usually does not need to be set (even if `emitDestroy` is called
+         * manually), unless the resource's `asyncId` is retrieved and the
+         * sensitive API's `emitDestroy` is called with it.
+         * @default false
+         */
+        requireManualDestroy?: boolean | undefined;
     }
 
     /**
@@ -113,14 +113,17 @@ declare module 'async_hooks' {
          *   this async event (default: `executionAsyncId()`), or an
          *   AsyncResourceOptions object (since v9.3.0)
          */
-        constructor(type: string, triggerAsyncId?: number|AsyncResourceOptions);
+        constructor(type: string, triggerAsyncId?: number | AsyncResourceOptions);
 
         /**
          * Binds the given function to the current execution context.
          * @param fn The function to bind to the current execution context.
          * @param type An optional name to associate with the underlying `AsyncResource`.
          */
-        static bind<Func extends (...args: any[]) => any>(fn: Func, type?: string): Func & { asyncResource: AsyncResource };
+        static bind<Func extends (...args: any[]) => any>(
+            fn: Func,
+            type?: string,
+        ): Func & { asyncResource: AsyncResource };
 
         /**
          * Binds the given function to execute to this `AsyncResource`'s scope.
@@ -139,7 +142,11 @@ declare module 'async_hooks' {
          * @param thisArg The receiver to be used for the function call.
          * @param args Optional arguments to pass to the function.
          */
-        runInAsyncScope<This, Result>(fn: (this: This, ...args: any[]) => Result, thisArg?: This, ...args: any[]): Result;
+        runInAsyncScope<This, Result>(
+            fn: (this: This, ...args: any[]) => Result,
+            thisArg?: This,
+            ...args: any[]
+        ): Result;
 
         /**
          * Call AsyncHooks destroy callbacks.
@@ -225,6 +232,6 @@ declare module 'async_hooks' {
         enterWith(store: T): void;
     }
 }
-declare module 'node:async_hooks' {
-    export * from 'async_hooks';
+declare module "node:async_hooks" {
+    export * from "async_hooks";
 }

node v14.18/buffer.d.ts

@@ -1,5 +1,5 @@
-declare module 'buffer' {
-    import { BinaryLike } from 'node:crypto';
+declare module "buffer" {
+    import { BinaryLike } from "node:crypto";
     export const INSPECT_MAX_BYTES: number;
     export const kMaxLength: number;
     export const kStringMaxLength: number;
@@ -84,6 +84,6 @@ declare module 'buffer' {
 
     export { BuffType as Buffer };
 }
-declare module 'node:buffer' {
-    export * from 'buffer';
+declare module "node:buffer" {
+    export * from "buffer";
 }

node v14.18/child_process.d.ts

@@ -1,8 +1,8 @@
-declare module 'child_process' {
-    import { BaseEncodingOptions } from 'fs';
-    import * as events from 'events';
-    import * as net from 'net';
-    import { Writable, Readable, Stream, Pipe } from 'stream';
+declare module "child_process" {
+    import { BaseEncodingOptions } from "fs";
+    import * as events from "events";
+    import * as net from "net";
+    import { Pipe, Readable, Stream, Writable } from "stream";
 
     type Serializable = string | object | number | boolean;
     type SendHandle = net.Socket | net.Server;
@@ -17,7 +17,7 @@ declare module 'child_process' {
             Readable | null, // stdout
             Readable | null, // stderr
             Readable | Writable | null | undefined, // extra
-            Readable | Writable | null | undefined // extra
+            Readable | Writable | null | undefined, // extra
         ];
         readonly killed: boolean;
         readonly pid: number;
@@ -29,7 +29,12 @@ declare module 'child_process' {
         kill(signal?: NodeJS.Signals | number): boolean;
         send(message: Serializable, callback?: (error: Error | null) => void): boolean;
         send(message: Serializable, sendHandle?: SendHandle, callback?: (error: Error | null) => void): boolean;
-        send(message: Serializable, sendHandle?: SendHandle, options?: MessageOptions, callback?: (error: Error | null) => void): boolean;
+        send(
+            message: Serializable,
+            sendHandle?: SendHandle,
+            options?: MessageOptions,
+            callback?: (error: Error | null) => void,
+        ): boolean;
         disconnect(): void;
         unref(): void;
         ref(): void;
@@ -79,10 +84,16 @@ declare module 'child_process' {
         prependListener(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
 
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+        prependOnceListener(
+            event: "close",
+            listener: (code: number | null, signal: NodeJS.Signals | null) => void,
+        ): this;
         prependOnceListener(event: "disconnect", listener: () => void): this;
         prependOnceListener(event: "error", listener: (err: Error) => void): this;
-        prependOnceListener(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+        prependOnceListener(
+            event: "exit",
+            listener: (code: number | null, signal: NodeJS.Signals | null) => void,
+        ): this;
         prependOnceListener(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
     }
 
@@ -96,7 +107,7 @@ declare module 'child_process' {
             Readable, // stdout
             Readable, // stderr
             Readable | Writable | null | undefined, // extra, no modification
-            Readable | Writable | null | undefined // extra, no modification
+            Readable | Writable | null | undefined, // extra, no modification
         ];
     }
 
@@ -114,7 +125,7 @@ declare module 'child_process' {
             O,
             E,
             Readable | Writable | null | undefined, // extra, no modification
-            Readable | Writable | null | undefined // extra, no modification
+            Readable | Writable | null | undefined, // extra, no modification
         ];
     }
 
@@ -122,9 +133,13 @@ declare module 'child_process' {
         keepOpen?: boolean | undefined;
     }
 
-    type StdioOptions = "pipe" | "ignore" | "inherit" | Array<("pipe" | "ipc" | "ignore" | "inherit" | Stream | number | null | undefined)>;
+    type StdioOptions =
+        | "pipe"
+        | "ignore"
+        | "inherit"
+        | Array<("pipe" | "ipc" | "ignore" | "inherit" | Stream | number | null | undefined)>;
 
-    type SerializationType = 'json' | 'advanced';
+    type SerializationType = "json" | "advanced";
 
     interface MessagingOptions {
         /**
@@ -173,11 +188,11 @@ declare module 'child_process' {
     }
 
     interface SpawnOptionsWithoutStdio extends SpawnOptions {
-        stdio?: 'pipe' | Array<null | undefined | 'pipe'> | undefined;
+        stdio?: "pipe" | Array<null | undefined | "pipe"> | undefined;
     }
 
-    type StdioNull = 'inherit' | 'ignore' | Stream;
-    type StdioPipe = undefined | null | 'pipe';
+    type StdioNull = "inherit" | "ignore" | Stream;
+    type StdioPipe = undefined | null | "pipe";
 
     interface SpawnOptionsWithStdioTuple<
         Stdin extends StdioNull | StdioPipe,
@@ -226,7 +241,11 @@ declare module 'child_process' {
     function spawn(command: string, options: SpawnOptions): ChildProcess;
 
     // overloads of spawn with 'args'
-    function spawn(command: string, args?: ReadonlyArray<string>, options?: SpawnOptionsWithoutStdio): ChildProcessWithoutNullStreams;
+    function spawn(
+        command: string,
+        args?: ReadonlyArray<string>,
+        options?: SpawnOptionsWithoutStdio,
+    ): ChildProcessWithoutNullStreams;
 
     function spawn(
         command: string,
@@ -293,13 +312,24 @@ declare module 'child_process' {
     }
 
     // no `options` definitely means stdout/stderr are `string`.
-    function exec(command: string, callback?: (error: ExecException | null, stdout: string, stderr: string) => void): ChildProcess;
+    function exec(
+        command: string,
+        callback?: (error: ExecException | null, stdout: string, stderr: string) => void,
+    ): ChildProcess;
 
     // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`.
-    function exec(command: string, options: { encoding: "buffer" | null } & ExecOptions, callback?: (error: ExecException | null, stdout: Buffer, stderr: Buffer) => void): ChildProcess;
+    function exec(
+        command: string,
+        options: { encoding: "buffer" | null } & ExecOptions,
+        callback?: (error: ExecException | null, stdout: Buffer, stderr: Buffer) => void,
+    ): ChildProcess;
 
     // `options` with well known `encoding` means stdout/stderr are definitely `string`.
-    function exec(command: string, options: { encoding: BufferEncoding } & ExecOptions, callback?: (error: ExecException | null, stdout: string, stderr: string) => void): ChildProcess;
+    function exec(
+        command: string,
+        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`.
@@ -310,7 +340,11 @@ declare module 'child_process' {
     ): 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;
+    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(
@@ -325,11 +359,23 @@ declare module 'child_process' {
 
     // NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.
     namespace exec {
-        function __promisify__(command: string): PromiseWithChild<{ stdout: string, stderr: string }>;
-        function __promisify__(command: string, options: { encoding: "buffer" | null } & ExecOptions): PromiseWithChild<{ stdout: Buffer, stderr: Buffer }>;
-        function __promisify__(command: string, options: { encoding: BufferEncoding } & ExecOptions): PromiseWithChild<{ stdout: string, stderr: string }>;
-        function __promisify__(command: string, options: ExecOptions): PromiseWithChild<{ stdout: string, stderr: string }>;
-        function __promisify__(command: string, options?: (BaseEncodingOptions & ExecOptions) | null): PromiseWithChild<{ stdout: string | Buffer, stderr: string | Buffer }>;
+        function __promisify__(command: string): PromiseWithChild<{ stdout: string; stderr: string }>;
+        function __promisify__(
+            command: string,
+            options: { encoding: "buffer" | null } & ExecOptions,
+        ): PromiseWithChild<{ stdout: Buffer; stderr: Buffer }>;
+        function __promisify__(
+            command: string,
+            options: { encoding: BufferEncoding } & ExecOptions,
+        ): PromiseWithChild<{ stdout: string; stderr: string }>;
+        function __promisify__(
+            command: string,
+            options: ExecOptions,
+        ): PromiseWithChild<{ stdout: string; stderr: string }>;
+        function __promisify__(
+            command: string,
+            options?: (BaseEncodingOptions & ExecOptions) | null,
+        ): PromiseWithChild<{ stdout: string | Buffer; stderr: string | Buffer }>;
     }
 
     interface ExecFileOptions extends CommonOptions {
@@ -342,27 +388,42 @@ declare module 'child_process' {
         encoding: BufferEncoding;
     }
     interface ExecFileOptionsWithBufferEncoding extends ExecFileOptions {
-        encoding: 'buffer' | null;
+        encoding: "buffer" | null;
     }
     interface ExecFileOptionsWithOtherEncoding extends ExecFileOptions {
         encoding: BufferEncoding;
     }
     type ExecFileException =
-        & Omit<ExecException, 'code'>
-        & Omit<NodeJS.ErrnoException, 'code'>
+        & Omit<ExecException, "code">
+        & Omit<NodeJS.ErrnoException, "code">
         & { code?: string | number | undefined | null };
 
     function execFile(file: string): ChildProcess;
     function execFile(file: string, options: (BaseEncodingOptions & ExecFileOptions) | undefined | null): ChildProcess;
     function execFile(file: string, args?: ReadonlyArray<string> | null): ChildProcess;
-    function execFile(file: string, args: ReadonlyArray<string> | undefined | null, options: (BaseEncodingOptions & ExecFileOptions) | undefined | null): ChildProcess;
+    function execFile(
+        file: string,
+        args: ReadonlyArray<string> | undefined | null,
+        options: (BaseEncodingOptions & 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): ChildProcess;
-    function execFile(file: string, args: ReadonlyArray<string> | undefined | null, callback: (error: ExecFileException | null, stdout: string, stderr: string) => void): ChildProcess;
+    function execFile(
+        file: string,
+        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+    ): ChildProcess;
+    function execFile(
+        file: string,
+        args: ReadonlyArray<string> | undefined | null,
+        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: Buffer, stderr: Buffer) => void): ChildProcess;
+    function execFile(
+        file: string,
+        options: ExecFileOptionsWithBufferEncoding,
+        callback: (error: ExecFileException | null, stdout: Buffer, stderr: Buffer) => void,
+    ): ChildProcess;
     function execFile(
         file: string,
         args: ReadonlyArray<string> | undefined | null,
@@ -371,7 +432,11 @@ declare module 'child_process' {
     ): ChildProcess;
 
     // `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): ChildProcess;
+    function execFile(
+        file: string,
+        options: ExecFileOptionsWithStringEncoding,
+        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+    ): ChildProcess;
     function execFile(
         file: string,
         args: ReadonlyArray<string> | undefined | null,
@@ -394,49 +459,89 @@ declare module 'child_process' {
     ): 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,
+        options: ExecFileOptions,
+        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+    ): ChildProcess;
     function execFile(
         file: string,
         args: ReadonlyArray<string> | undefined | null,
         options: ExecFileOptions,
-        callback: (error: ExecFileException | null, stdout: string, stderr: string) => void
+        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: (BaseEncodingOptions & ExecFileOptions) | undefined | null,
-        callback: ((error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void) | undefined | null,
+        callback:
+            | ((error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void)
+            | undefined
+            | null,
     ): ChildProcess;
     function execFile(
         file: string,
         args: ReadonlyArray<string> | undefined | null,
         options: (BaseEncodingOptions & ExecFileOptions) | undefined | null,
-        callback: ((error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void) | undefined | null,
+        callback:
+            | ((error: ExecFileException | null, stdout: string | Buffer, stderr: string | Buffer) => void)
+            | undefined
+            | null,
     ): ChildProcess;
 
     // NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.
     namespace execFile {
-        function __promisify__(file: string): PromiseWithChild<{ stdout: string, stderr: string }>;
-        function __promisify__(file: string, args: ReadonlyArray<string> | undefined | null): PromiseWithChild<{ stdout: string, stderr: string }>;
-        function __promisify__(file: string, options: ExecFileOptionsWithBufferEncoding): PromiseWithChild<{ stdout: Buffer, stderr: Buffer }>;
-        function __promisify__(file: string, args: ReadonlyArray<string> | undefined | null, options: ExecFileOptionsWithBufferEncoding): PromiseWithChild<{ stdout: Buffer, stderr: Buffer }>;
-        function __promisify__(file: string, options: ExecFileOptionsWithStringEncoding): PromiseWithChild<{ stdout: string, stderr: string }>;
-        function __promisify__(file: string, args: ReadonlyArray<string> | undefined | null, options: ExecFileOptionsWithStringEncoding): PromiseWithChild<{ stdout: string, stderr: string }>;
-        function __promisify__(file: string, options: ExecFileOptionsWithOtherEncoding): PromiseWithChild<{ stdout: string | Buffer, stderr: string | Buffer }>;
+        function __promisify__(file: string): PromiseWithChild<{ stdout: string; stderr: string }>;
+        function __promisify__(
+            file: string,
+            args: ReadonlyArray<string> | undefined | null,
+        ): PromiseWithChild<{ stdout: string; stderr: string }>;
+        function __promisify__(
+            file: string,
+            options: ExecFileOptionsWithBufferEncoding,
+        ): PromiseWithChild<{ stdout: Buffer; stderr: Buffer }>;
+        function __promisify__(
+            file: string,
+            args: ReadonlyArray<string> | undefined | null,
+            options: ExecFileOptionsWithBufferEncoding,
+        ): PromiseWithChild<{ stdout: Buffer; stderr: Buffer }>;
+        function __promisify__(
+            file: string,
+            options: ExecFileOptionsWithStringEncoding,
+        ): PromiseWithChild<{ stdout: string; stderr: string }>;
+        function __promisify__(
+            file: string,
+            args: ReadonlyArray<string> | undefined | null,
+            options: ExecFileOptionsWithStringEncoding,
+        ): PromiseWithChild<{ stdout: string; stderr: string }>;
+        function __promisify__(
+            file: string,
+            options: ExecFileOptionsWithOtherEncoding,
+        ): PromiseWithChild<{ stdout: string | Buffer; stderr: string | Buffer }>;
         function __promisify__(
             file: string,
             args: ReadonlyArray<string> | undefined | null,
             options: ExecFileOptionsWithOtherEncoding,
-        ): PromiseWithChild<{ stdout: string | Buffer, stderr: string | Buffer }>;
-        function __promisify__(file: string, options: ExecFileOptions): PromiseWithChild<{ stdout: string, stderr: string }>;
-        function __promisify__(file: string, args: ReadonlyArray<string> | undefined | null, options: ExecFileOptions): PromiseWithChild<{ stdout: string, stderr: string }>;
-        function __promisify__(file: string, options: (BaseEncodingOptions & ExecFileOptions) | undefined | null): PromiseWithChild<{ stdout: string | Buffer, stderr: string | Buffer }>;
+        ): PromiseWithChild<{ stdout: string | Buffer; stderr: string | Buffer }>;
+        function __promisify__(
+            file: string,
+            options: ExecFileOptions,
+        ): PromiseWithChild<{ stdout: string; stderr: string }>;
         function __promisify__(
             file: string,
             args: ReadonlyArray<string> | undefined | null,
+            options: ExecFileOptions,
+        ): PromiseWithChild<{ stdout: string; stderr: string }>;
+        function __promisify__(
+            file: string,
             options: (BaseEncodingOptions & ExecFileOptions) | undefined | null,
-        ): PromiseWithChild<{ stdout: string | Buffer, stderr: string | Buffer }>;
+        ): PromiseWithChild<{ stdout: string | Buffer; stderr: string | Buffer }>;
+        function __promisify__(
+            file: string,
+            args: ReadonlyArray<string> | undefined | null,
+            options: (BaseEncodingOptions & ExecFileOptions) | undefined | null,
+        ): PromiseWithChild<{ stdout: string | Buffer; stderr: string | Buffer }>;
     }
 
     interface ForkOptions extends ProcessEnvOptions, MessagingOptions {
@@ -463,13 +568,13 @@ declare module 'child_process' {
         input?: string | NodeJS.ArrayBufferView | undefined;
         killSignal?: NodeJS.Signals | number | undefined;
         maxBuffer?: number | undefined;
-        encoding?: BufferEncoding | 'buffer' | null | undefined;
+        encoding?: BufferEncoding | "buffer" | null | undefined;
     }
     interface SpawnSyncOptionsWithStringEncoding extends SpawnSyncOptions {
         encoding: BufferEncoding;
     }
     interface SpawnSyncOptionsWithBufferEncoding extends SpawnSyncOptions {
-        encoding?: 'buffer' | null | undefined;
+        encoding?: "buffer" | null | undefined;
     }
     interface SpawnSyncReturns<T> {
         pid: number;
@@ -484,9 +589,21 @@ declare module 'child_process' {
     function spawnSync(command: string, options?: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
     function spawnSync(command: string, options?: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
     function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
-    function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
-    function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
-    function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<string | Buffer>;
+    function spawnSync(
+        command: string,
+        args?: ReadonlyArray<string>,
+        options?: SpawnSyncOptionsWithStringEncoding,
+    ): SpawnSyncReturns<string>;
+    function spawnSync(
+        command: string,
+        args?: ReadonlyArray<string>,
+        options?: SpawnSyncOptionsWithBufferEncoding,
+    ): SpawnSyncReturns<Buffer>;
+    function spawnSync(
+        command: string,
+        args?: ReadonlyArray<string>,
+        options?: SpawnSyncOptions,
+    ): SpawnSyncReturns<string | Buffer>;
 
     interface ExecSyncOptions extends CommonOptions {
         input?: string | Uint8Array | undefined;
@@ -503,13 +620,13 @@ declare module 'child_process' {
         shell?: string | undefined;
         killSignal?: NodeJS.Signals | number | undefined;
         maxBuffer?: number | undefined;
-        encoding?: BufferEncoding | 'buffer' | null | undefined;
+        encoding?: BufferEncoding | "buffer" | null | undefined;
     }
     interface ExecSyncOptionsWithStringEncoding extends ExecSyncOptions {
         encoding: BufferEncoding;
     }
     interface ExecSyncOptionsWithBufferEncoding extends ExecSyncOptions {
-        encoding?: 'buffer' | null | undefined;
+        encoding?: "buffer" | null | undefined;
     }
     function execSync(command: string): Buffer;
     function execSync(command: string, options: ExecSyncOptionsWithStringEncoding): string;
@@ -544,10 +661,22 @@ declare module 'child_process' {
     function execFileSync(command: string, options: ExecFileSyncOptionsWithBufferEncoding): Buffer;
     function execFileSync(command: string, options?: ExecFileSyncOptions): string | Buffer;
     function execFileSync(command: string, args: ReadonlyArray<string>): Buffer;
-    function execFileSync(command: string, args: ReadonlyArray<string>, options: ExecFileSyncOptionsWithStringEncoding): string;
-    function execFileSync(command: string, args: ReadonlyArray<string>, options: ExecFileSyncOptionsWithBufferEncoding): Buffer;
-    function execFileSync(command: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptions): string | Buffer;
+    function execFileSync(
+        command: string,
+        args: ReadonlyArray<string>,
+        options: ExecFileSyncOptionsWithStringEncoding,
+    ): string;
+    function execFileSync(
+        command: string,
+        args: ReadonlyArray<string>,
+        options: ExecFileSyncOptionsWithBufferEncoding,
+    ): Buffer;
+    function execFileSync(
+        command: string,
+        args?: ReadonlyArray<string>,
+        options?: ExecFileSyncOptions,
+    ): string | Buffer;
 }
-declare module 'node:child_process' {
-    export * from 'child_process';
+declare module "node:child_process" {
+    export * from "child_process";
 }