@runlith/tagma 0.0.0-stage → 0.2.3

package/types/node/async_hooks.d.ts

@@ -0,0 +1,113 @@
+declare module "node:async_hooks" {
+    function executionAsyncId(): number;
+    function executionAsyncResource(): object;
+    function triggerAsyncId(): number;
+    interface HookCallbacks {
+        init?(asyncId: number, type: string, triggerAsyncId: number, resource: object): void;
+        before?(asyncId: number): void;
+        after?(asyncId: number): void;
+        promiseResolve?(asyncId: number): void;
+        destroy?(asyncId: number): void;
+        trackPromises?: boolean | undefined;
+    }
+    interface AsyncHook {
+        enable(): this;
+        disable(): this;
+    }
+    function createHook(options: HookCallbacks): AsyncHook;
+    interface AsyncResourceOptions {
+        triggerAsyncId?: number | undefined;
+        requireManualDestroy?: boolean | undefined;
+    }
+    class AsyncResource {
+        constructor(type: string, triggerAsyncId?: number | AsyncResourceOptions);
+        static bind<Func extends (this: ThisArg, ...args: any[]) => any, ThisArg>(fn: Func, type?: string, thisArg?: ThisArg): Func;
+        bind<Func extends (...args: any[]) => any>(fn: Func): Func;
+        runInAsyncScope<This, Result>(fn: (this: This, ...args: any[]) => Result, thisArg?: This, ...args: any[]): Result;
+        emitDestroy(): this;
+        asyncId(): number;
+        triggerAsyncId(): number;
+    }
+    interface AsyncLocalStorageOptions {
+        defaultValue?: any;
+        name?: string | undefined;
+    }
+    class AsyncLocalStorage<T> {
+        constructor(options?: AsyncLocalStorageOptions);
+        static bind<Func extends (...args: any[]) => any>(fn: Func): Func;
+        static snapshot(): <R, TArgs extends any[]>(fn: (...args: TArgs) => R, ...args: TArgs) => R;
+        disable(): void;
+        getStore(): T | undefined;
+        readonly name: string;
+        run<R>(store: T, callback: () => R): R;
+        run<R, TArgs extends any[]>(store: T, callback: (...args: TArgs) => R, ...args: TArgs): R;
+        exit<R, TArgs extends any[]>(callback: (...args: TArgs) => R, ...args: TArgs): R;
+        withScope(store: T): RunScope;
+        enterWith(store: T): void;
+    }
+    interface RunScope extends Disposable {
+        dispose(): void;
+    }
+    namespace asyncWrapProviders {
+        const NONE: number;
+        const DIRHANDLE: number;
+        const DNSCHANNEL: number;
+        const ELDHISTOGRAM: number;
+        const FILEHANDLE: number;
+        const FILEHANDLECLOSEREQ: number;
+        const FIXEDSIZEBLOBCOPY: number;
+        const FSEVENTWRAP: number;
+        const FSREQCALLBACK: number;
+        const FSREQPROMISE: number;
+        const GETADDRINFOREQWRAP: number;
+        const GETNAMEINFOREQWRAP: number;
+        const HEAPSNAPSHOT: number;
+        const HTTP2SESSION: number;
+        const HTTP2STREAM: number;
+        const HTTP2PING: number;
+        const HTTP2SETTINGS: number;
+        const HTTPINCOMINGMESSAGE: number;
+        const HTTPCLIENTREQUEST: number;
+        const JSSTREAM: number;
+        const JSUDPWRAP: number;
+        const MESSAGEPORT: number;
+        const PIPECONNECTWRAP: number;
+        const PIPESERVERWRAP: number;
+        const PIPEWRAP: number;
+        const PROCESSWRAP: number;
+        const PROMISE: number;
+        const QUERYWRAP: number;
+        const SHUTDOWNWRAP: number;
+        const SIGNALWRAP: number;
+        const STATWATCHER: number;
+        const STREAMPIPE: number;
+        const TCPCONNECTWRAP: number;
+        const TCPSERVERWRAP: number;
+        const TCPWRAP: number;
+        const TTYWRAP: number;
+        const UDPSENDWRAP: number;
+        const UDPWRAP: number;
+        const SIGINTWATCHDOG: number;
+        const WORKER: number;
+        const WORKERHEAPSNAPSHOT: number;
+        const WRITEWRAP: number;
+        const ZLIB: number;
+        const CHECKPRIMEREQUEST: number;
+        const PBKDF2REQUEST: number;
+        const KEYPAIRGENREQUEST: number;
+        const KEYGENREQUEST: number;
+        const KEYEXPORTREQUEST: number;
+        const CIPHERREQUEST: number;
+        const DERIVEBITSREQUEST: number;
+        const HASHREQUEST: number;
+        const RANDOMBYTESREQUEST: number;
+        const RANDOMPRIMEREQUEST: number;
+        const SCRYPTREQUEST: number;
+        const SIGNREQUEST: number;
+        const TLSWRAP: number;
+        const VERIFYREQUEST: number;
+    }
+}
+declare module "async_hooks" {
+    export * from "node:async_hooks";
+}

package/types/node/buffer.buffer.d.ts

@@ -0,0 +1,29 @@
+declare module "node:buffer" {
+    type ImplicitArrayBuffer<T extends WithImplicitCoercion<ArrayBufferLike>> = T extends {
+        valueOf(): infer V extends ArrayBufferLike;
+    } ? V : T;
+    global {
+        interface BufferConstructor {
+            new (str: string, encoding?: BufferEncoding): Buffer<ArrayBuffer>;
+            new (size: number): Buffer<ArrayBuffer>;
+            new (array: ArrayLike<number>): Buffer<ArrayBuffer>;
+            new <TArrayBuffer extends ArrayBufferLike = ArrayBuffer>(arrayBuffer: TArrayBuffer): Buffer<TArrayBuffer>;
+            from(array: WithImplicitCoercion<ArrayLike<number>>): Buffer<ArrayBuffer>;
+            from<TArrayBuffer extends WithImplicitCoercion<ArrayBufferLike>>(arrayBuffer: TArrayBuffer, byteOffset?: number, length?: number): Buffer<ImplicitArrayBuffer<TArrayBuffer>>;
+            from(string: WithImplicitCoercion<string>, encoding?: BufferEncoding): Buffer<ArrayBuffer>;
+            from(arrayOrString: WithImplicitCoercion<ArrayLike<number> | string>): Buffer<ArrayBuffer>;
+            of(...items: number[]): Buffer<ArrayBuffer>;
+            concat(list: readonly Uint8Array[], totalLength?: number): Buffer<ArrayBuffer>;
+            copyBytesFrom(view: NodeJS.TypedArray, offset?: number, length?: number): Buffer<ArrayBuffer>;
+            alloc(size: number, fill?: string | Uint8Array | number, encoding?: BufferEncoding): Buffer<ArrayBuffer>;
+            allocUnsafe(size: number): Buffer<ArrayBuffer>;
+            allocUnsafeSlow(size: number): Buffer<ArrayBuffer>;
+        }
+        interface Buffer<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends Uint8Array<TArrayBuffer> {
+            slice(start?: number, end?: number): Buffer<ArrayBuffer>;
+            subarray(start?: number, end?: number): Buffer<TArrayBuffer>;
+        }
+        type NonSharedBuffer = Buffer<ArrayBuffer>;
+        type AllowSharedBuffer = Buffer<ArrayBufferLike>;
+    }
+}

package/types/node/buffer.d.ts

@@ -0,0 +1,162 @@
+declare module "node:buffer" {
+    import { ReadableStream } from "node:stream/web";
+    export function isUtf8(input: ArrayBuffer | NodeJS.TypedArray): boolean;
+    export function isAscii(input: ArrayBuffer | NodeJS.TypedArray): boolean;
+    export let INSPECT_MAX_BYTES: number;
+    export const kMaxLength: number;
+    export const kStringMaxLength: number;
+    export const constants: {
+        MAX_LENGTH: number;
+        MAX_STRING_LENGTH: number;
+    };
+    export type TranscodeEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "utf-16le" | "ucs2" | "ucs-2" | "latin1" | "binary";
+    export function transcode(source: Uint8Array, fromEnc: TranscodeEncoding, toEnc: TranscodeEncoding): NonSharedBuffer;
+    export function resolveObjectURL(id: string): Blob | undefined;
+    export { type AllowSharedBuffer, Buffer, type NonSharedBuffer };
+    export interface BlobOptions extends BlobPropertyBag {
+    }
+    export interface FileOptions extends FilePropertyBag {
+    }
+    export type WithImplicitCoercion<T> = T | {
+        valueOf(): T;
+    } | (T extends string ? {
+        [Symbol.toPrimitive](hint: "string"): T;
+    } : never);
+    global {
+        namespace NodeJS {
+            export { BufferEncoding };
+        }
+        type BufferEncoding = "ascii" | "utf8" | "utf-8" | "utf16le" | "utf-16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+        interface BufferConstructor {
+            isBuffer(obj: any): obj is Buffer;
+            isEncoding(encoding: string): encoding is BufferEncoding;
+            byteLength(string: string | NodeJS.ArrayBufferView | ArrayBufferLike, encoding?: BufferEncoding): number;
+            compare(buf1: Uint8Array, buf2: Uint8Array): -1 | 0 | 1;
+            poolSize: number;
+        }
+        interface Buffer {
+            write(string: string, encoding?: BufferEncoding): number;
+            write(string: string, offset: number, encoding?: BufferEncoding): number;
+            write(string: string, offset: number, length: number, encoding?: BufferEncoding): number;
+            toString(encoding?: BufferEncoding, start?: number, end?: number): string;
+            toJSON(): {
+                type: "Buffer";
+                data: number[];
+            };
+            equals(otherBuffer: Uint8Array): boolean;
+            compare(target: Uint8Array, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): -1 | 0 | 1;
+            copy(target: Uint8Array, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
+            writeBigInt64BE(value: bigint, offset?: number): number;
+            writeBigInt64LE(value: bigint, offset?: number): number;
+            writeBigUInt64BE(value: bigint, offset?: number): number;
+            writeBigUint64BE(value: bigint, offset?: number): number;
+            writeBigUInt64LE(value: bigint, offset?: number): number;
+            writeBigUint64LE(value: bigint, offset?: number): number;
+            writeUIntLE(value: number, offset: number, byteLength: number): number;
+            writeUintLE(value: number, offset: number, byteLength: number): number;
+            writeUIntBE(value: number, offset: number, byteLength: number): number;
+            writeUintBE(value: number, offset: number, byteLength: number): number;
+            writeIntLE(value: number, offset: number, byteLength: number): number;
+            writeIntBE(value: number, offset: number, byteLength: number): number;
+            readBigUInt64BE(offset?: number): bigint;
+            readBigUint64BE(offset?: number): bigint;
+            readBigUInt64LE(offset?: number): bigint;
+            readBigUint64LE(offset?: number): bigint;
+            readBigInt64BE(offset?: number): bigint;
+            readBigInt64LE(offset?: number): bigint;
+            readUIntLE(offset: number, byteLength: number): number;
+            readUintLE(offset: number, byteLength: number): number;
+            readUIntBE(offset: number, byteLength: number): number;
+            readUintBE(offset: number, byteLength: number): number;
+            readIntLE(offset: number, byteLength: number): number;
+            readIntBE(offset: number, byteLength: number): number;
+            readUInt8(offset?: number): number;
+            readUint8(offset?: number): number;
+            readUInt16LE(offset?: number): number;
+            readUint16LE(offset?: number): number;
+            readUInt16BE(offset?: number): number;
+            readUint16BE(offset?: number): number;
+            readUInt32LE(offset?: number): number;
+            readUint32LE(offset?: number): number;
+            readUInt32BE(offset?: number): number;
+            readUint32BE(offset?: number): number;
+            readInt8(offset?: number): number;
+            readInt16LE(offset?: number): number;
+            readInt16BE(offset?: number): number;
+            readInt32LE(offset?: number): number;
+            readInt32BE(offset?: number): number;
+            readFloatLE(offset?: number): number;
+            readFloatBE(offset?: number): number;
+            readDoubleLE(offset?: number): number;
+            readDoubleBE(offset?: number): number;
+            reverse(): this;
+            swap16(): this;
+            swap32(): this;
+            swap64(): this;
+            writeUInt8(value: number, offset?: number): number;
+            writeUint8(value: number, offset?: number): number;
+            writeUInt16LE(value: number, offset?: number): number;
+            writeUint16LE(value: number, offset?: number): number;
+            writeUInt16BE(value: number, offset?: number): number;
+            writeUint16BE(value: number, offset?: number): number;
+            writeUInt32LE(value: number, offset?: number): number;
+            writeUint32LE(value: number, offset?: number): number;
+            writeUInt32BE(value: number, offset?: number): number;
+            writeUint32BE(value: number, offset?: number): number;
+            writeInt8(value: number, offset?: number): number;
+            writeInt16LE(value: number, offset?: number): number;
+            writeInt16BE(value: number, offset?: number): number;
+            writeInt32LE(value: number, offset?: number): number;
+            writeInt32BE(value: number, offset?: number): number;
+            writeFloatLE(value: number, offset?: number): number;
+            writeFloatBE(value: number, offset?: number): number;
+            writeDoubleLE(value: number, offset?: number): number;
+            writeDoubleBE(value: number, offset?: number): number;
+            fill(value: string | Uint8Array | number, offset?: number, end?: number, encoding?: BufferEncoding): this;
+            fill(value: string | Uint8Array | number, offset: number, encoding: BufferEncoding): this;
+            fill(value: string | Uint8Array | number, encoding: BufferEncoding): this;
+            indexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
+            indexOf(value: string | number | Uint8Array, encoding: BufferEncoding): number;
+            lastIndexOf(value: string | number | Uint8Array, byteOffset?: number, encoding?: BufferEncoding): number;
+            lastIndexOf(value: string | number | Uint8Array, encoding: BufferEncoding): number;
+            includes(value: string | number | Buffer, byteOffset?: number, encoding?: BufferEncoding): boolean;
+            includes(value: string | number | Buffer, encoding: BufferEncoding): boolean;
+        }
+        var Buffer: BufferConstructor;
+    }
+    export type BlobPart = NodeJS.BufferSource | Blob | string;
+    export interface BlobPropertyBag {
+        endings?: "native" | "transparent";
+        type?: string;
+    }
+    export interface FilePropertyBag extends BlobPropertyBag {
+        lastModified?: number;
+    }
+    export interface Blob {
+        readonly size: number;
+        readonly type: string;
+        arrayBuffer(): Promise<ArrayBuffer>;
+        bytes(): Promise<NodeJS.NonSharedUint8Array>;
+        slice(start?: number, end?: number, contentType?: string): Blob;
+        stream(): ReadableStream<NodeJS.NonSharedUint8Array>;
+        text(): Promise<string>;
+    }
+    export var Blob: {
+        prototype: Blob;
+        new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+    };
+    export interface File extends Blob {
+        readonly lastModified: number;
+        readonly name: string;
+        readonly webkitRelativePath: string;
+    }
+    export var File: {
+        prototype: File;
+        new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+    };
+    export import atob = globalThis.atob;
+    export import btoa = globalThis.btoa;
+}
+declare module "buffer" {
+    export * from "node:buffer";
+}

package/types/node/child_process.d.ts

@@ -0,0 +1,337 @@
+declare module "node:child_process" {
+    import { NonSharedBuffer } from "node:buffer";
+    import * as dgram from "node:dgram";
+    import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
+    import * as net from "node:net";
+    import { 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;
+    interface ChildProcessEventMap {
+        "close": [
+            code: number | null,
+            signal: NodeJS.Signals | null
+        ];
+        "disconnect": [
+        ];
+        "error": [
+            err: Error
+        ];
+        "exit": [
+            code: number | null,
+            signal: NodeJS.Signals | null
+        ];
+        "message": [
+            message: Serializable,
+            sendHandle: SendHandle
+        ];
+        "spawn": [
+        ];
+    }
+    class ChildProcess implements EventEmitter {
+        stdin: Writable | null;
+        stdout: Readable | null;
+        stderr: Readable | null;
+        readonly channel?: Control | null;
+        readonly stdio: [
+            Writable | null,
+            Readable | null,
+            Readable | null,
+            Readable | Writable | null | undefined,
+            Readable | Writable | null | undefined
+        ];
+        readonly killed: boolean;
+        readonly pid?: number | undefined;
+        readonly connected: boolean;
+        readonly exitCode: number | null;
+        readonly signalCode: NodeJS.Signals | null;
+        readonly spawnargs: string[];
+        readonly spawnfile: string;
+        kill(signal?: NodeJS.Signals | number): boolean;
+        [Symbol.dispose](): void;
+        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;
+        disconnect(): void;
+        unref(): void;
+        ref(): void;
+    }
+    interface ChildProcess extends InternalEventEmitter<ChildProcessEventMap> {
+    }
+    interface ChildProcessWithoutNullStreams extends ChildProcess {
+        stdin: Writable;
+        stdout: Readable;
+        stderr: Readable;
+        readonly stdio: [
+            Writable,
+            Readable,
+            Readable,
+            Readable | Writable | null | undefined,
+            Readable | Writable | null | undefined
+        ];
+    }
+    interface ChildProcessByStdio<I extends null | Writable, O extends null | Readable, E extends null | Readable> extends ChildProcess {
+        stdin: I;
+        stdout: O;
+        stderr: E;
+        readonly stdio: [
+            I,
+            O,
+            E,
+            Readable | Writable | null | undefined,
+            Readable | Writable | null | undefined
+        ];
+    }
+    interface Control extends EventEmitter {
+        ref(): void;
+        unref(): void;
+    }
+    interface MessageOptions {
+        keepOpen?: boolean | undefined;
+    }
+    type IOType = "overlapped" | "pipe" | "ignore" | "inherit";
+    type StdioOptions = IOType | Array<IOType | "ipc" | Stream | number | null | undefined>;
+    type SerializationType = "json" | "advanced";
+    interface MessagingOptions extends Abortable {
+        serialization?: SerializationType | undefined;
+        killSignal?: NodeJS.Signals | number | undefined;
+        timeout?: number | undefined;
+    }
+    interface ProcessEnvOptions {
+        uid?: number | undefined;
+        gid?: number | undefined;
+        cwd?: string | URL | undefined;
+        env?: NodeJS.ProcessEnv | undefined;
+    }
+    interface CommonOptions extends ProcessEnvOptions {
+        windowsHide?: boolean | undefined;
+        timeout?: number | undefined;
+    }
+    interface CommonSpawnOptions extends CommonOptions, MessagingOptions, Abortable {
+        argv0?: string | undefined;
+        stdio?: StdioOptions | undefined;
+        shell?: boolean | string | undefined;
+        windowsVerbatimArguments?: boolean | undefined;
+    }
+    interface SpawnOptions extends CommonSpawnOptions {
+        detached?: boolean | undefined;
+    }
+    interface SpawnOptionsWithoutStdio extends SpawnOptions {
+        stdio?: StdioPipeNamed | StdioPipe[] | undefined;
+    }
+    type StdioNull = "inherit" | "ignore" | Stream;
+    type StdioPipeNamed = "pipe" | "overlapped";
+    type StdioPipe = undefined | null | StdioPipeNamed;
+    interface SpawnOptionsWithStdioTuple<Stdin extends StdioNull | StdioPipe, Stdout extends StdioNull | StdioPipe, Stderr extends StdioNull | StdioPipe> extends SpawnOptions {
+        stdio: [
+            Stdin,
+            Stdout,
+            Stderr
+        ];
+    }
+    function spawn(command: string, options?: SpawnOptionsWithoutStdio): ChildProcessWithoutNullStreams;
+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): ChildProcessByStdio<Writable, Readable, Readable>;
+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): ChildProcessByStdio<Writable, Readable, null>;
+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): ChildProcessByStdio<Writable, null, Readable>;
+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): ChildProcessByStdio<null, Readable, Readable>;
+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): ChildProcessByStdio<Writable, null, null>;
+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): ChildProcessByStdio<null, Readable, null>;
+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): ChildProcessByStdio<null, null, Readable>;
+    function spawn(command: string, options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): ChildProcessByStdio<null, null, null>;
+    function spawn(command: string, options: SpawnOptions): ChildProcess;
+    function spawn(command: string, args?: readonly string[], options?: SpawnOptionsWithoutStdio): ChildProcessWithoutNullStreams;
+    function spawn(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioPipe>): ChildProcessByStdio<Writable, Readable, Readable>;
+    function spawn(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioPipe, StdioNull>): ChildProcessByStdio<Writable, Readable, null>;
+    function spawn(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioPipe>): ChildProcessByStdio<Writable, null, Readable>;
+    function spawn(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioPipe>): ChildProcessByStdio<null, Readable, Readable>;
+    function spawn(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioPipe, StdioNull, StdioNull>): ChildProcessByStdio<Writable, null, null>;
+    function spawn(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioPipe, StdioNull>): ChildProcessByStdio<null, Readable, null>;
+    function spawn(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioPipe>): ChildProcessByStdio<null, null, Readable>;
+    function spawn(command: string, args: readonly string[], options: SpawnOptionsWithStdioTuple<StdioNull, StdioNull, StdioNull>): ChildProcessByStdio<null, null, null>;
+    function spawn(command: string, args: readonly string[], options: SpawnOptions): ChildProcess;
+    interface ExecOptions extends CommonOptions {
+        shell?: string | undefined;
+        signal?: AbortSignal | undefined;
+        maxBuffer?: number | undefined;
+        killSignal?: NodeJS.Signals | number | undefined;
+        encoding?: string | null | undefined;
+    }
+    interface ExecOptionsWithStringEncoding extends ExecOptions {
+        encoding?: BufferEncoding | undefined;
+    }
+    interface ExecOptionsWithBufferEncoding extends ExecOptions {
+        encoding: "buffer" | null;
+    }
+    interface ExecException extends Error {
+        cmd?: string;
+        killed?: boolean;
+        code?: number;
+        signal?: NodeJS.Signals;
+        stdout?: string;
+        stderr?: string;
+    }
+    function exec(command: string, callback?: (error: ExecException | null, stdout: string, stderr: string) => void): ChildProcess;
+    function exec(command: string, options: ExecOptionsWithBufferEncoding, callback?: (error: ExecException | null, stdout: NonSharedBuffer, stderr: NonSharedBuffer) => void): ChildProcess;
+    function exec(command: string, options: ExecOptionsWithStringEncoding, callback?: (error: ExecException | null, stdout: string, stderr: string) => void): ChildProcess;
+    function exec(command: string, options: ExecOptions | undefined | null, callback?: (error: ExecException | null, stdout: string | NonSharedBuffer, stderr: string | NonSharedBuffer) => void): ChildProcess;
+    interface PromiseWithChild<T> extends Promise<T> {
+        child: ChildProcess;
+    }
+    namespace exec {
+        function __promisify__(command: string): PromiseWithChild<{
+            stdout: string;
+            stderr: string;
+        }>;
+        function __promisify__(command: string, options: ExecOptionsWithBufferEncoding): PromiseWithChild<{
+            stdout: NonSharedBuffer;
+            stderr: NonSharedBuffer;
+        }>;
+        function __promisify__(command: string, options: ExecOptionsWithStringEncoding): PromiseWithChild<{
+            stdout: string;
+            stderr: string;
+        }>;
+        function __promisify__(command: string, options: ExecOptions | undefined | null): PromiseWithChild<{
+            stdout: string | NonSharedBuffer;
+            stderr: string | NonSharedBuffer;
+        }>;
+    }
+    interface ExecFileOptions extends CommonOptions, Abortable {
+        maxBuffer?: number | undefined;
+        killSignal?: NodeJS.Signals | number | undefined;
+        windowsVerbatimArguments?: boolean | undefined;
+        shell?: boolean | string | undefined;
+        signal?: AbortSignal | undefined;
+        encoding?: string | null | undefined;
+    }
+    interface ExecFileOptionsWithStringEncoding extends ExecFileOptions {
+        encoding?: BufferEncoding | undefined;
+    }
+    interface ExecFileOptionsWithBufferEncoding extends ExecFileOptions {
+        encoding: "buffer" | null;
+    }
+    interface ExecFileOptionsWithOtherEncoding extends ExecFileOptions {
+    }
+    type ExecFileException = Omit<ExecException, "code"> & Omit<NodeJS.ErrnoException, "code"> & {
+        code?: string | number | null;
+    };
+    function execFile(file: string, 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): ChildProcess;
+    function execFile(file: string, options: ExecFileOptionsWithBufferEncoding, callback?: (error: ExecFileException | null, stdout: NonSharedBuffer, stderr: NonSharedBuffer) => void): ChildProcess;
+    function execFile(file: string, args: readonly string[] | undefined | null, options: ExecFileOptionsWithBufferEncoding, callback?: (error: ExecFileException | null, stdout: NonSharedBuffer, stderr: NonSharedBuffer) => void): ChildProcess;
+    function execFile(file: string, options: ExecFileOptionsWithStringEncoding, 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): ChildProcess;
+    function execFile(file: string, options: ExecFileOptions | undefined | null, callback: ((error: ExecFileException | null, stdout: string | NonSharedBuffer, stderr: string | NonSharedBuffer) => void) | undefined | null): ChildProcess;
+    function execFile(file: string, args: readonly string[] | undefined | null, options: ExecFileOptions | undefined | null, callback: ((error: ExecFileException | null, stdout: string | NonSharedBuffer, stderr: string | NonSharedBuffer) => void) | undefined | null): ChildProcess;
+    namespace execFile {
+        function __promisify__(file: string): PromiseWithChild<{
+            stdout: string;
+            stderr: string;
+        }>;
+        function __promisify__(file: string, args: readonly string[] | undefined | null): PromiseWithChild<{
+            stdout: string;
+            stderr: string;
+        }>;
+        function __promisify__(file: string, options: ExecFileOptionsWithBufferEncoding): PromiseWithChild<{
+            stdout: NonSharedBuffer;
+            stderr: NonSharedBuffer;
+        }>;
+        function __promisify__(file: string, args: readonly string[] | undefined | null, options: ExecFileOptionsWithBufferEncoding): PromiseWithChild<{
+            stdout: NonSharedBuffer;
+            stderr: NonSharedBuffer;
+        }>;
+        function __promisify__(file: string, options: ExecFileOptionsWithStringEncoding): PromiseWithChild<{
+            stdout: string;
+            stderr: string;
+        }>;
+        function __promisify__(file: string, args: readonly string[] | undefined | null, options: ExecFileOptionsWithStringEncoding): PromiseWithChild<{
+            stdout: string;
+            stderr: string;
+        }>;
+        function __promisify__(file: string, options: ExecFileOptions | undefined | null): PromiseWithChild<{
+            stdout: string | NonSharedBuffer;
+            stderr: string | NonSharedBuffer;
+        }>;
+        function __promisify__(file: string, args: readonly string[] | undefined | null, options: ExecFileOptions | undefined | null): PromiseWithChild<{
+            stdout: string | NonSharedBuffer;
+            stderr: string | NonSharedBuffer;
+        }>;
+    }
+    interface ForkOptions extends ProcessEnvOptions, MessagingOptions, Abortable {
+        execPath?: string | undefined;
+        execArgv?: string[] | undefined;
+        silent?: boolean | undefined;
+        stdio?: StdioOptions | undefined;
+        detached?: boolean | undefined;
+        windowsVerbatimArguments?: boolean | undefined;
+    }
+    function fork(modulePath: string | URL, options?: ForkOptions): ChildProcess;
+    function fork(modulePath: string | URL, args?: readonly string[], options?: ForkOptions): ChildProcess;
+    interface SpawnSyncOptions extends CommonSpawnOptions {
+        input?: string | NodeJS.ArrayBufferView | undefined;
+        maxBuffer?: number | undefined;
+        encoding?: BufferEncoding | "buffer" | null | undefined;
+    }
+    interface SpawnSyncOptionsWithStringEncoding extends SpawnSyncOptions {
+        encoding: BufferEncoding;
+    }
+    interface SpawnSyncOptionsWithBufferEncoding extends SpawnSyncOptions {
+        encoding?: "buffer" | null | undefined;
+    }
+    interface SpawnSyncReturns<T> {
+        pid: number;
+        output: Array<T | null>;
+        stdout: T;
+        stderr: T;
+        status: number | null;
+        signal: NodeJS.Signals | null;
+        error?: Error;
+    }
+    function spawnSync(command: string): SpawnSyncReturns<NonSharedBuffer>;
+    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, args: readonly string[], options: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
+    function spawnSync(command: string, args: readonly string[], options: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<NonSharedBuffer>;
+    function spawnSync(command: string, args?: readonly string[], options?: SpawnSyncOptions): SpawnSyncReturns<string | NonSharedBuffer>;
+    interface CommonExecOptions extends CommonOptions {
+        input?: string | NodeJS.ArrayBufferView | undefined;
+        stdio?: StdioOptions | undefined;
+        killSignal?: NodeJS.Signals | number | undefined;
+        maxBuffer?: number | undefined;
+        encoding?: BufferEncoding | "buffer" | null | undefined;
+    }
+    interface ExecSyncOptions extends CommonExecOptions {
+        shell?: string | undefined;
+    }
+    interface ExecSyncOptionsWithStringEncoding extends ExecSyncOptions {
+        encoding: BufferEncoding;
+    }
+    interface ExecSyncOptionsWithBufferEncoding extends ExecSyncOptions {
+        encoding?: "buffer" | null | undefined;
+    }
+    function execSync(command: string): NonSharedBuffer;
+    function execSync(command: string, options: ExecSyncOptionsWithStringEncoding): string;
+    function execSync(command: string, options: ExecSyncOptionsWithBufferEncoding): NonSharedBuffer;
+    function execSync(command: string, options?: ExecSyncOptions): string | NonSharedBuffer;
+    interface ExecFileSyncOptions extends CommonExecOptions {
+        shell?: boolean | string | undefined;
+    }
+    interface ExecFileSyncOptionsWithStringEncoding extends ExecFileSyncOptions {
+        encoding: BufferEncoding;
+    }
+    interface ExecFileSyncOptionsWithBufferEncoding extends ExecFileSyncOptions {
+        encoding?: "buffer" | null | undefined;
+    }
+    function execFileSync(file: string): NonSharedBuffer;
+    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, args: readonly string[], options: ExecFileSyncOptionsWithStringEncoding): string;
+    function execFileSync(file: string, args: readonly string[], options: ExecFileSyncOptionsWithBufferEncoding): NonSharedBuffer;
+    function execFileSync(file: string, args?: readonly string[], options?: ExecFileSyncOptions): string | NonSharedBuffer;
+}
+declare module "child_process" {
+    export * from "node:child_process";
+}