@serveryyswys/node.operit 0.0.0-stage → 0.1.3

package/dist/index.d.ts

@@ -0,0 +1,2821 @@
+import eventsModule = require('./events');
+import querystringModule = require('./querystring');
+import stringDecoderModule = require('./string_decoder');
+import streamModule = require('./stream');
+import bufferModule = require('./buffer');
+import osModule = require('./os');
+declare const api: {
+    version: string;
+    path: import("./lib/path-types").PathModule;
+    'path/posix': import("./lib/path-types").PathModule;
+    'path/win32': import("./lib/path-types").PathModule;
+    events: typeof eventsModule;
+    querystring: typeof querystringModule;
+    string_decoder: typeof stringDecoderModule;
+    util: {
+        format: (template?: unknown, ...rest: unknown[]) => string;
+        formatWithOptions: (options: import("./lib/util-types").InspectOptions, template?: unknown, ...rest: unknown[]) => string;
+        inspect: (value: unknown, options?: import("./lib/util-types").InspectOptions | boolean | number) => string;
+        inherits: (constructor: Function, superConstructor: Function) => void;
+        promisify: (original: Function) => Function;
+        callbackify: (original: Function) => Function;
+        deprecate: (fn: Function, message: string) => Function;
+        debuglog: (section: string) => Function & {
+            enabled: boolean;
+        };
+        getSystemErrorName: (errno: number) => string;
+        stripVTControlCharacters: (value: string) => string;
+        isDeepStrictEqual: (left: unknown, right: unknown) => boolean;
+        types: {
+            isDate: (value: unknown) => boolean;
+            isRegExp: (value: unknown) => boolean;
+            isArray: (value: unknown) => boolean;
+            isTypedArray: (value: unknown) => boolean;
+            isUint8Array: (value: unknown) => boolean;
+            isArrayBuffer: (value: unknown) => boolean;
+            isPromise: (value: unknown) => boolean;
+            isNativeError: (value: unknown) => boolean;
+            isMap: (value: unknown) => boolean;
+            isSet: (value: unknown) => boolean;
+            isBigInt64Array: (value: unknown) => boolean;
+            isAsyncFunction: (value: unknown) => boolean;
+            isGeneratorFunction: (value: unknown) => boolean;
+        };
+        TextEncoder: {
+            new (): {
+                readonly encoding: "utf-8";
+                encode(input?: string): Uint8Array;
+                encodeInto(source: string, destination: Uint8Array): {
+                    read: number;
+                    written: number;
+                };
+            };
+        };
+        TextDecoder: {
+            new (label?: string, options?: {
+                fatal?: boolean;
+                ignoreBOM?: boolean;
+            }): {
+                readonly encoding: string;
+                readonly fatal: boolean;
+                readonly ignoreBOM: boolean;
+                decode(input?: Uint8Array): string;
+            };
+        };
+    };
+    assert: ((value: unknown, message?: unknown) => void) & Record<string, unknown>;
+    'assert/strict': any;
+    stream: typeof streamModule;
+    'stream/promises': {
+        pipeline: (...streams: unknown[]) => Promise<void>;
+        finished: (stream: unknown) => Promise<void>;
+    };
+    fs: {
+        readFileSync: (target: unknown, options?: unknown) => string | bufferModule.Buffer;
+        writeFileSync: (target: unknown, data: unknown, options?: unknown) => void;
+        appendFileSync: (target: unknown, data: unknown, options?: unknown) => void;
+        existsSync: (target: unknown) => boolean;
+        statSync: (target: unknown, options?: unknown) => {
+            readonly sizeValue: number;
+            readonly modeValue: number;
+            readonly atimeMsValue: number;
+            readonly mtimeMsValue: number;
+            readonly ctimeMsValue: number;
+            readonly birthtimeMsValue: number;
+            readonly fileLike: boolean;
+            readonly directoryLike: boolean;
+            readonly linkLike: boolean;
+            get size(): number;
+            get mode(): number;
+            get atimeMs(): number;
+            get mtimeMs(): number;
+            get ctimeMs(): number;
+            get birthtimeMs(): number;
+            get atime(): Date;
+            get mtime(): Date;
+            get ctime(): Date;
+            get birthtime(): Date;
+            isFile(): boolean;
+            isDirectory(): boolean;
+            isSymbolicLink(): boolean;
+            isBlockDevice(): boolean;
+            isCharacterDevice(): boolean;
+            isFIFO(): boolean;
+            isSocket(): boolean;
+        } | undefined;
+        lstatSync: (target: unknown, options?: unknown) => {
+            readonly sizeValue: number;
+            readonly modeValue: number;
+            readonly atimeMsValue: number;
+            readonly mtimeMsValue: number;
+            readonly ctimeMsValue: number;
+            readonly birthtimeMsValue: number;
+            readonly fileLike: boolean;
+            readonly directoryLike: boolean;
+            readonly linkLike: boolean;
+            get size(): number;
+            get mode(): number;
+            get atimeMs(): number;
+            get mtimeMs(): number;
+            get ctimeMs(): number;
+            get birthtimeMs(): number;
+            get atime(): Date;
+            get mtime(): Date;
+            get ctime(): Date;
+            get birthtime(): Date;
+            isFile(): boolean;
+            isDirectory(): boolean;
+            isSymbolicLink(): boolean;
+            isBlockDevice(): boolean;
+            isCharacterDevice(): boolean;
+            isFIFO(): boolean;
+            isSocket(): boolean;
+        } | undefined;
+        readdirSync: (target: unknown, options?: unknown) => string[] | {
+            readonly name: string;
+            readonly kind: number;
+            isFile(): boolean;
+            isDirectory(): boolean;
+            isSymbolicLink(): boolean;
+            isBlockDevice(): boolean;
+            isCharacterDevice(): boolean;
+            isFIFO(): boolean;
+            isSocket(): boolean;
+        }[];
+        mkdirSync: (target: unknown, options?: unknown) => string | undefined;
+        rmSync: (target: unknown, options?: unknown) => void;
+        unlinkSync: (target: unknown) => void;
+        rmdirSync: (target: unknown, options?: unknown) => void;
+        renameSync: (from: unknown, to: unknown) => void;
+        copyFileSync: (from: unknown, to: unknown) => void;
+        realpathSync: (target: unknown) => string;
+        readlinkSync: (target: unknown) => string;
+        symlinkSync: (target: unknown, linkPath: unknown) => void;
+        chmodSync: (target: unknown, mode: unknown) => void;
+        truncateSync: (target: unknown, length?: unknown) => void;
+        utimesSync: (target: unknown, atime: unknown, mtime: unknown) => void;
+        accessSync: (target: unknown) => void;
+        mkdtempSync: (prefix: unknown) => string;
+        openSync: (target: unknown, flags?: unknown, mode?: unknown) => number;
+        closeSync: (descriptor: unknown) => void;
+        readSync: (descriptor: unknown, buffer: unknown, offset?: unknown, length?: unknown, position?: unknown) => number;
+        writeSync: (descriptor: unknown, data: unknown, a?: unknown, b?: unknown, c?: unknown) => number;
+        fstatSync: (descriptor: unknown, options?: unknown) => {
+            readonly sizeValue: number;
+            readonly modeValue: number;
+            readonly atimeMsValue: number;
+            readonly mtimeMsValue: number;
+            readonly ctimeMsValue: number;
+            readonly birthtimeMsValue: number;
+            readonly fileLike: boolean;
+            readonly directoryLike: boolean;
+            readonly linkLike: boolean;
+            get size(): number;
+            get mode(): number;
+            get atimeMs(): number;
+            get mtimeMs(): number;
+            get ctimeMs(): number;
+            get birthtimeMs(): number;
+            get atime(): Date;
+            get mtime(): Date;
+            get ctime(): Date;
+            get birthtime(): Date;
+            isFile(): boolean;
+            isDirectory(): boolean;
+            isSymbolicLink(): boolean;
+            isBlockDevice(): boolean;
+            isCharacterDevice(): boolean;
+            isFIFO(): boolean;
+            isSocket(): boolean;
+        };
+        ftruncateSync: (descriptor: unknown, length?: unknown) => void;
+        fsyncSync: (descriptor: unknown) => void;
+        fdatasyncSync: (descriptor: unknown) => void;
+        readFile: (...args: unknown[]) => void;
+        writeFile: (...args: unknown[]) => void;
+        appendFile: (...args: unknown[]) => void;
+        stat: (...args: unknown[]) => void;
+        lstat: (...args: unknown[]) => void;
+        readdir: (...args: unknown[]) => void;
+        mkdir: (...args: unknown[]) => void;
+        rm: (...args: unknown[]) => void;
+        unlink: (...args: unknown[]) => void;
+        rmdir: (...args: unknown[]) => void;
+        rename: (...args: unknown[]) => void;
+        copyFile: (...args: unknown[]) => void;
+        realpath: (...args: unknown[]) => void;
+        access: (...args: unknown[]) => void;
+        mkdtemp: (...args: unknown[]) => void;
+        exists: (target: unknown, callback: unknown) => void;
+        open: (...args: unknown[]) => void;
+        close: (...args: unknown[]) => void;
+        read: (...args: unknown[]) => void;
+        write: (...args: unknown[]) => void;
+        fstat: (...args: unknown[]) => void;
+        ftruncate: (...args: unknown[]) => void;
+        fsync: (...args: unknown[]) => void;
+        createReadStream: (target: unknown, options?: import("./lib/fs-types").ReadStreamOptions) => {
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _read(size: number): void;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): /*elided*/ any;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+            destroy(error?: Error | null): /*elided*/ any;
+            on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+        };
+        createWriteStream: (target: unknown, options?: import("./lib/fs-types").WriteStreamOptions) => {
+            writable: boolean;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+        };
+        Stats: {
+            new (raw: import("./lib/fs-driver").FileStat): {
+                readonly sizeValue: number;
+                readonly modeValue: number;
+                readonly atimeMsValue: number;
+                readonly mtimeMsValue: number;
+                readonly ctimeMsValue: number;
+                readonly birthtimeMsValue: number;
+                readonly fileLike: boolean;
+                readonly directoryLike: boolean;
+                readonly linkLike: boolean;
+                get size(): number;
+                get mode(): number;
+                get atimeMs(): number;
+                get mtimeMs(): number;
+                get ctimeMs(): number;
+                get birthtimeMs(): number;
+                get atime(): Date;
+                get mtime(): Date;
+                get ctime(): Date;
+                get birthtime(): Date;
+                isFile(): boolean;
+                isDirectory(): boolean;
+                isSymbolicLink(): boolean;
+                isBlockDevice(): boolean;
+                isCharacterDevice(): boolean;
+                isFIFO(): boolean;
+                isSocket(): boolean;
+            };
+        };
+        Dirent: {
+            new (entry: import("./lib/fs-driver").DirectoryEntry): {
+                readonly name: string;
+                readonly kind: number;
+                isFile(): boolean;
+                isDirectory(): boolean;
+                isSymbolicLink(): boolean;
+                isBlockDevice(): boolean;
+                isCharacterDevice(): boolean;
+                isFIFO(): boolean;
+                isSocket(): boolean;
+            };
+        };
+        constants: {
+            F_OK: number;
+            R_OK: number;
+            W_OK: number;
+            X_OK: number;
+            COPYFILE_EXCL: number;
+            COPYFILE_FICLONE: number;
+            COPYFILE_FICLONE_FORCE: number;
+            UV_FS_COPYFILE_EXCL: number;
+            UV_FS_COPYFILE_FICLONE: number;
+            UV_FS_COPYFILE_FICLONE_FORCE: number;
+            O_RDONLY: number;
+            O_WRONLY: number;
+            O_RDWR: number;
+            O_CREAT: number;
+            O_EXCL: number;
+            O_TRUNC: number;
+            O_APPEND: number;
+            UV_FS_O_FILEMAP: number;
+            UV_FS_SYMLINK_DIR: number;
+            UV_FS_SYMLINK_JUNCTION: number;
+            UV_DIRENT_UNKNOWN: number;
+            UV_DIRENT_FILE: number;
+            UV_DIRENT_DIR: number;
+            UV_DIRENT_LINK: number;
+            UV_DIRENT_FIFO: number;
+            UV_DIRENT_SOCKET: number;
+            UV_DIRENT_CHAR: number;
+            UV_DIRENT_BLOCK: number;
+            S_IFMT: number;
+            S_IFREG: number;
+            S_IFDIR: number;
+            S_IFCHR: number;
+            S_IFIFO: number;
+            S_IFLNK: number;
+            S_IRUSR: number;
+            S_IWUSR: number;
+            S_IXUSR: number;
+            S_IRGRP: number;
+            S_IWGRP: number;
+            S_IXGRP: number;
+            S_IROTH: number;
+            S_IWOTH: number;
+            S_IXOTH: number;
+        };
+        env: typeof import("./lib/fs-env");
+    };
+    'fs/promises': {
+        open: (path: unknown, flags?: unknown, mode?: unknown) => Promise<{
+            readonly fd: number;
+            closed: boolean;
+            ensureOpen(): void;
+            read(buffer: Uint8Array, offset?: number, length?: number, position?: number | null): Promise<{
+                bytesRead: number;
+                buffer: Uint8Array;
+            }>;
+            write(data: unknown, ...rest: unknown[]): Promise<{
+                bytesWritten: number;
+                buffer: unknown;
+            }>;
+            readFile(options?: unknown): Promise<string | Uint8Array>;
+            writeFile(data: unknown, options?: unknown): Promise<void>;
+            appendFile(data: unknown, options?: unknown): Promise<void>;
+            stat(): Promise<unknown>;
+            truncate(length?: number): Promise<void>;
+            sync(): Promise<void>;
+            datasync(): Promise<void>;
+            close(): Promise<void>;
+        }>;
+        readFile: (target: unknown, options?: unknown) => Promise<string | bufferModule.Buffer>;
+        writeFile: (target: unknown, data: unknown, options?: unknown) => Promise<void>;
+        appendFile: (target: unknown, data: unknown, options?: unknown) => Promise<void>;
+        stat: (target: unknown, options?: unknown) => Promise<{
+            readonly sizeValue: number;
+            readonly modeValue: number;
+            readonly atimeMsValue: number;
+            readonly mtimeMsValue: number;
+            readonly ctimeMsValue: number;
+            readonly birthtimeMsValue: number;
+            readonly fileLike: boolean;
+            readonly directoryLike: boolean;
+            readonly linkLike: boolean;
+            get size(): number;
+            get mode(): number;
+            get atimeMs(): number;
+            get mtimeMs(): number;
+            get ctimeMs(): number;
+            get birthtimeMs(): number;
+            get atime(): Date;
+            get mtime(): Date;
+            get ctime(): Date;
+            get birthtime(): Date;
+            isFile(): boolean;
+            isDirectory(): boolean;
+            isSymbolicLink(): boolean;
+            isBlockDevice(): boolean;
+            isCharacterDevice(): boolean;
+            isFIFO(): boolean;
+            isSocket(): boolean;
+        } | undefined>;
+        lstat: (target: unknown, options?: unknown) => Promise<{
+            readonly sizeValue: number;
+            readonly modeValue: number;
+            readonly atimeMsValue: number;
+            readonly mtimeMsValue: number;
+            readonly ctimeMsValue: number;
+            readonly birthtimeMsValue: number;
+            readonly fileLike: boolean;
+            readonly directoryLike: boolean;
+            readonly linkLike: boolean;
+            get size(): number;
+            get mode(): number;
+            get atimeMs(): number;
+            get mtimeMs(): number;
+            get ctimeMs(): number;
+            get birthtimeMs(): number;
+            get atime(): Date;
+            get mtime(): Date;
+            get ctime(): Date;
+            get birthtime(): Date;
+            isFile(): boolean;
+            isDirectory(): boolean;
+            isSymbolicLink(): boolean;
+            isBlockDevice(): boolean;
+            isCharacterDevice(): boolean;
+            isFIFO(): boolean;
+            isSocket(): boolean;
+        } | undefined>;
+        readdir: (target: unknown, options?: unknown) => Promise<string[] | {
+            readonly name: string;
+            readonly kind: number;
+            isFile(): boolean;
+            isDirectory(): boolean;
+            isSymbolicLink(): boolean;
+            isBlockDevice(): boolean;
+            isCharacterDevice(): boolean;
+            isFIFO(): boolean;
+            isSocket(): boolean;
+        }[]>;
+        mkdir: (target: unknown, options?: unknown) => Promise<string | undefined>;
+        rm: (target: unknown, options?: unknown) => Promise<void>;
+        unlink: (target: unknown) => Promise<void>;
+        rmdir: (target: unknown, options?: unknown) => Promise<void>;
+        rename: (from: unknown, to: unknown) => Promise<void>;
+        copyFile: (from: unknown, to: unknown) => Promise<void>;
+        realpath: (target: unknown) => Promise<string>;
+        readlink: (target: unknown) => Promise<string>;
+        symlink: (target: unknown, linkPath: unknown) => Promise<void>;
+        chmod: (target: unknown, mode: unknown) => Promise<void>;
+        truncate: (target: unknown, length?: unknown) => Promise<void>;
+        utimes: (target: unknown, atime: unknown, mtime: unknown) => Promise<void>;
+        access: (target: unknown) => Promise<void>;
+        mkdtemp: (prefix: unknown) => Promise<string>;
+        constants: {
+            F_OK: number;
+            R_OK: number;
+            W_OK: number;
+            X_OK: number;
+            COPYFILE_EXCL: number;
+            COPYFILE_FICLONE: number;
+            COPYFILE_FICLONE_FORCE: number;
+            UV_FS_COPYFILE_EXCL: number;
+            UV_FS_COPYFILE_FICLONE: number;
+            UV_FS_COPYFILE_FICLONE_FORCE: number;
+            O_RDONLY: number;
+            O_WRONLY: number;
+            O_RDWR: number;
+            O_CREAT: number;
+            O_EXCL: number;
+            O_TRUNC: number;
+            O_APPEND: number;
+            UV_FS_O_FILEMAP: number;
+            UV_FS_SYMLINK_DIR: number;
+            UV_FS_SYMLINK_JUNCTION: number;
+            UV_DIRENT_UNKNOWN: number;
+            UV_DIRENT_FILE: number;
+            UV_DIRENT_DIR: number;
+            UV_DIRENT_LINK: number;
+            UV_DIRENT_FIFO: number;
+            UV_DIRENT_SOCKET: number;
+            UV_DIRENT_CHAR: number;
+            UV_DIRENT_BLOCK: number;
+            S_IFMT: number;
+            S_IFREG: number;
+            S_IFDIR: number;
+            S_IFCHR: number;
+            S_IFIFO: number;
+            S_IFLNK: number;
+            S_IRUSR: number;
+            S_IWUSR: number;
+            S_IXUSR: number;
+            S_IRGRP: number;
+            S_IWGRP: number;
+            S_IXGRP: number;
+            S_IROTH: number;
+            S_IWOTH: number;
+            S_IXOTH: number;
+        };
+    };
+    buffer: typeof bufferModule;
+    os: typeof osModule;
+    process: {
+        once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+        prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+        addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+        emit(name: string | symbol, ...args: unknown[]): boolean;
+        removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+        exitCode: number | undefined;
+        title: string;
+        get platform(): string;
+        get arch(): string;
+        get version(): string;
+        readonly versions: {
+            node: string;
+            operit: string;
+            quickjs: string;
+        };
+        readonly argv: string[];
+        readonly execArgv: string[];
+        readonly execPath: "operit";
+        readonly env: Record<string, string | undefined>;
+        readonly stdout: {
+            isTTY: boolean;
+            columns: number;
+            rows: number;
+            write(chunk: string | Uint8Array): boolean;
+        };
+        readonly stderr: {
+            isTTY: boolean;
+            columns: number;
+            rows: number;
+            write(chunk: string | Uint8Array): boolean;
+        };
+        readonly stdin: {
+            isTTY: boolean;
+            read: () => null;
+            on: () => unknown;
+            resume: () => void;
+        };
+        readonly nextTick: (fn: (...args: unknown[]) => void, ...args: unknown[]) => void;
+        readonly hrtime: ((previous?: number[]) => number[]) & {
+            bigint(): bigint;
+        };
+        get pid(): number;
+        cwd(): string;
+        chdir(directory: string): void;
+        uptime(): number;
+        memoryUsage(): {
+            rss: number;
+            heapTotal: number;
+            heapUsed: number;
+            external: number;
+            arrayBuffers: number;
+        };
+        emitWarning(warning: unknown): void;
+        exit(code?: number): never;
+        abort(): never;
+        umask(): number;
+        get maxListeners(): number;
+        set maxListeners(value: number);
+        setMaxListeners(count: number): /*elided*/ any;
+        getMaxListeners(): number;
+        on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+        addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+        prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+        off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+        removeAllListeners(name?: string | symbol): /*elided*/ any;
+        listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+        rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+        listenerCount(name: string | symbol): number;
+        eventNames(): (string | symbol)[];
+    };
+    crypto: {
+        createHash: (algorithm: string, options?: {
+            outputLength?: number;
+        }) => {
+            readonly spec: import("./lib/hashes").HashSpec;
+            chunks: Uint8Array[];
+            total: number;
+            finalized: boolean;
+            update(data: unknown, inputEncoding?: string): /*elided*/ any;
+            digest(encoding?: string): string | bufferModule.Buffer;
+            copy(): /*elided*/ any;
+        };
+        createHmac: (algorithm: string, key: unknown, options?: {
+            encoding?: string;
+        }) => {
+            readonly spec: import("./lib/hashes").HashSpec;
+            readonly key: Uint8Array;
+            chunks: Uint8Array[];
+            total: number;
+            finalized: boolean;
+            update(data: unknown, inputEncoding?: string): /*elided*/ any;
+            digest(encoding?: string): string | bufferModule.Buffer;
+        };
+        randomBytes: (size: number, callback?: (error: Error | null, buffer: bufferModule.Buffer) => void) => bufferModule.Buffer | void;
+        randomFillSync: (buffer: Uint8Array) => Uint8Array;
+        randomUUID: () => string;
+        randomInt: (min: number, max?: number | ((error: Error | null, value: number) => void), callback?: (error: Error | null, value: number) => void) => number | void;
+        timingSafeEqual: (left: unknown, right: unknown) => boolean;
+        pbkdf2Sync: (password: unknown, salt: unknown, iterations: number, keylen: number, digest: string) => bufferModule.Buffer;
+        pbkdf2: (password: unknown, salt: unknown, iterations: number, keylen: number, digest: string, callback: (error: Error | null, derivedKey: bufferModule.Buffer) => void) => void;
+        getHashes: () => string[];
+        getCiphers: () => string[];
+        createCipheriv: () => never;
+        createDecipheriv: () => never;
+        createSign: () => never;
+        createVerify: () => never;
+        generateKeyPairSync: () => never;
+        createDiffieHellman: () => never;
+        constants: {
+            RSA_PKCS1_PADDING: number;
+            RSA_NO_PADDING: number;
+            RSA_PKCS1_OAEP_PADDING: number;
+            RSA_X931_PADDING: number;
+            RSA_PKCS1_PSS_PADDING: number;
+            SSL_OP_ALL: number;
+            SSL_OP_NO_SSLv2: number;
+            SSL_OP_NO_SSLv3: number;
+            SSL_OP_NO_TLSv1: number;
+        };
+        Hash: {
+            new (algorithm: string): {
+                readonly spec: import("./lib/hashes").HashSpec;
+                chunks: Uint8Array[];
+                total: number;
+                finalized: boolean;
+                update(data: unknown, inputEncoding?: string): /*elided*/ any;
+                digest(encoding?: string): string | bufferModule.Buffer;
+                copy(): /*elided*/ any;
+            };
+        };
+        Hmac: {
+            new (algorithm: string, key: unknown, keyEncoding?: string): {
+                readonly spec: import("./lib/hashes").HashSpec;
+                readonly key: Uint8Array;
+                chunks: Uint8Array[];
+                total: number;
+                finalized: boolean;
+                update(data: unknown, inputEncoding?: string): /*elided*/ any;
+                digest(encoding?: string): string | bufferModule.Buffer;
+            };
+        };
+    };
+    zlib: {
+        deflateSync: (input: unknown, options?: import("./lib/zlib-types").DeflateOptions) => bufferModule.Buffer;
+        inflateSync: (input: unknown) => bufferModule.Buffer;
+        deflateRawSync: (input: unknown, options?: import("./lib/zlib-types").DeflateOptions) => bufferModule.Buffer;
+        inflateRawSync: (input: unknown) => bufferModule.Buffer;
+        gzipSync: (input: unknown, options?: import("./lib/zlib-types").DeflateOptions) => bufferModule.Buffer;
+        gunzipSync: (input: unknown) => bufferModule.Buffer;
+        unzipSync: (input: unknown) => bufferModule.Buffer;
+        deflate: (input: unknown, options?: import("./lib/zlib-types").DeflateOptions | ((error: Error | null, result?: bufferModule.Buffer) => void), callback?: (error: Error | null, result?: bufferModule.Buffer) => void) => void;
+        inflate: (input: unknown, options?: (error: Error | null, result?: bufferModule.Buffer) => void, callback?: (error: Error | null, result?: bufferModule.Buffer) => void) => void;
+        deflateRaw: (input: unknown, options?: import("./lib/zlib-types").DeflateOptions | ((error: Error | null, result?: bufferModule.Buffer) => void), callback?: (error: Error | null, result?: bufferModule.Buffer) => void) => void;
+        inflateRaw: (input: unknown, options?: (error: Error | null, result?: bufferModule.Buffer) => void, callback?: (error: Error | null, result?: bufferModule.Buffer) => void) => void;
+        gzip: (input: unknown, options?: import("./lib/zlib-types").DeflateOptions | ((error: Error | null, result?: bufferModule.Buffer) => void), callback?: (error: Error | null, result?: bufferModule.Buffer) => void) => void;
+        gunzip: (input: unknown, options?: (error: Error | null, result?: bufferModule.Buffer) => void, callback?: (error: Error | null, result?: bufferModule.Buffer) => void) => void;
+        createDeflate: (options?: import("./lib/zlib-types").DeflateOptions) => {
+            _transform(chunk: unknown, encoding: string, callback: (error?: Error | null, data?: unknown) => void): void;
+            _read(size: number): void;
+            _flush(callback: (error?: Error | null) => void): void;
+            _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+            _final(callback: (error?: Error | null) => void): void;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): /*elided*/ any;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+            destroy(error?: Error | null): /*elided*/ any;
+            on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+            writable: boolean;
+        };
+        createInflate: () => {
+            _transform(chunk: unknown, encoding: string, callback: (error?: Error | null, data?: unknown) => void): void;
+            _read(size: number): void;
+            _flush(callback: (error?: Error | null) => void): void;
+            _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+            _final(callback: (error?: Error | null) => void): void;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): /*elided*/ any;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+            destroy(error?: Error | null): /*elided*/ any;
+            on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+            writable: boolean;
+        };
+        createDeflateRaw: (options?: import("./lib/zlib-types").DeflateOptions) => {
+            _transform(chunk: unknown, encoding: string, callback: (error?: Error | null, data?: unknown) => void): void;
+            _read(size: number): void;
+            _flush(callback: (error?: Error | null) => void): void;
+            _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+            _final(callback: (error?: Error | null) => void): void;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): /*elided*/ any;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+            destroy(error?: Error | null): /*elided*/ any;
+            on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+            writable: boolean;
+        };
+        createInflateRaw: () => {
+            _transform(chunk: unknown, encoding: string, callback: (error?: Error | null, data?: unknown) => void): void;
+            _read(size: number): void;
+            _flush(callback: (error?: Error | null) => void): void;
+            _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+            _final(callback: (error?: Error | null) => void): void;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            removeAllListeners(name?: string | symbol): any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): any;
+            pause(): any;
+            resume(): any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+            destroy(error?: Error | null): any;
+            on(event: string, listener: (...args: unknown[]) => void): any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+            writable: boolean;
+        };
+        createGzip: (options?: import("./lib/zlib-types").DeflateOptions) => {
+            _transform(chunk: unknown, encoding: string, callback: (error?: Error | null, data?: unknown) => void): void;
+            _read(size: number): void;
+            _flush(callback: (error?: Error | null) => void): void;
+            _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+            _final(callback: (error?: Error | null) => void): void;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): /*elided*/ any;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+            destroy(error?: Error | null): /*elided*/ any;
+            on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+            writable: boolean;
+        };
+        createGunzip: () => {
+            _transform(chunk: unknown, encoding: string, callback: (error?: Error | null, data?: unknown) => void): void;
+            _read(size: number): void;
+            _flush(callback: (error?: Error | null) => void): void;
+            _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+            _final(callback: (error?: Error | null) => void): void;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            removeAllListeners(name?: string | symbol): any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): any;
+            pause(): any;
+            resume(): any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+            destroy(error?: Error | null): any;
+            on(event: string, listener: (...args: unknown[]) => void): any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+            writable: boolean;
+        };
+        createUnzip: () => {
+            _transform(chunk: unknown, encoding: string, callback: (error?: Error | null, data?: unknown) => void): void;
+            _read(size: number): void;
+            _flush(callback: (error?: Error | null) => void): void;
+            _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+            _final(callback: (error?: Error | null) => void): void;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            removeAllListeners(name?: string | symbol): any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): any;
+            pause(): any;
+            resume(): any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+            destroy(error?: Error | null): any;
+            on(event: string, listener: (...args: unknown[]) => void): any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+            writable: boolean;
+        };
+        constants: {
+            DEFLATE: number;
+            INFLATE: number;
+            GZIP: number;
+            GUNZIP: number;
+            DEFLATERAW: number;
+            INFLATERAW: number;
+            UNZIP: number;
+            Z_MIN_CHUNK: number;
+            Z_MAX_CHUNK: number;
+            Z_DEFAULT_CHUNK: number;
+            Z_MIN_MEMLEVEL: number;
+            Z_MAX_MEMLEVEL: number;
+            Z_DEFAULT_MEMLEVEL: number;
+            Z_MIN_LEVEL: number;
+            Z_MAX_LEVEL: number;
+            Z_DEFAULT_LEVEL: number;
+            Z_NO_FLUSH: number;
+            Z_PARTIAL_FLUSH: number;
+            Z_SYNC_FLUSH: number;
+            Z_FULL_FLUSH: number;
+            Z_FINISH: number;
+            Z_BLOCK: number;
+            Z_OK: number;
+            Z_STREAM_END: number;
+            Z_NEED_DICT: number;
+            Z_ERRNO: number;
+            Z_STREAM_ERROR: number;
+            Z_DATA_ERROR: number;
+            Z_MEM_ERROR: number;
+            Z_BUF_ERROR: number;
+            Z_VERSION_ERROR: number;
+            Z_NO_COMPRESSION: number;
+            Z_BEST_SPEED: number;
+            Z_BEST_COMPRESSION: number;
+            Z_DEFAULT_COMPRESSION: number;
+            Z_DEFAULT_STRATEGY: number;
+            Z_FILTERED: number;
+            Z_HUFFMAN_ONLY: number;
+            Z_RLE: number;
+            Z_FIXED: number;
+            Z_MIN_WINDOWBITS: number;
+            Z_MAX_WINDOWBITS: number;
+            Z_DEFAULT_WINDOWBITS: number;
+        };
+    };
+    child_process: {
+        exec: (command: unknown, options?: unknown, callback?: unknown) => {
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            pid: number;
+            exitCode: number | null;
+            signalCode: string | null;
+            killed: boolean;
+            readonly spawnfile: string;
+            readonly spawnargs: string[];
+            readonly stdout: {
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                removeAllListeners(name?: string | symbol): /*elided*/ any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _read(size: number): void;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): /*elided*/ any;
+                pause(): /*elided*/ any;
+                resume(): /*elided*/ any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+                destroy(error?: Error | null): /*elided*/ any;
+                on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): /*elided*/ any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            };
+            readonly stderr: {
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                removeAllListeners(name?: string | symbol): any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _read(size: number): void;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): any;
+                pause(): any;
+                resume(): any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+                destroy(error?: Error | null): any;
+                on(event: string, listener: (...args: unknown[]) => void): any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            };
+            readonly stdin: {
+                writable: boolean;
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): /*elided*/ any;
+                getMaxListeners(): number;
+                on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                removeAllListeners(name?: string | symbol): /*elided*/ any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+            };
+            readonly spawnError?: import("./lib/errors").NodeStyleError;
+            kill(): boolean;
+            ref(): /*elided*/ any;
+            unref(): /*elided*/ any;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+        };
+        execSync: (command: unknown, options?: import("./lib/child-process-types").ExecOptions) => string | bufferModule.Buffer;
+        execFile: (file: unknown, args?: unknown, options?: unknown, callback?: unknown) => {
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            pid: number;
+            exitCode: number | null;
+            signalCode: string | null;
+            killed: boolean;
+            readonly spawnfile: string;
+            readonly spawnargs: string[];
+            readonly stdout: {
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                removeAllListeners(name?: string | symbol): /*elided*/ any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _read(size: number): void;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): /*elided*/ any;
+                pause(): /*elided*/ any;
+                resume(): /*elided*/ any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+                destroy(error?: Error | null): /*elided*/ any;
+                on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): /*elided*/ any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            };
+            readonly stderr: {
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                removeAllListeners(name?: string | symbol): any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _read(size: number): void;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): any;
+                pause(): any;
+                resume(): any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+                destroy(error?: Error | null): any;
+                on(event: string, listener: (...args: unknown[]) => void): any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            };
+            readonly stdin: {
+                writable: boolean;
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): /*elided*/ any;
+                getMaxListeners(): number;
+                on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                removeAllListeners(name?: string | symbol): /*elided*/ any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+            };
+            readonly spawnError?: import("./lib/errors").NodeStyleError;
+            kill(): boolean;
+            ref(): /*elided*/ any;
+            unref(): /*elided*/ any;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+        };
+        execFileSync: (file: unknown, args?: unknown, options?: import("./lib/child-process-types").ExecOptions) => string | bufferModule.Buffer;
+        spawn: (command: unknown, args?: unknown, options?: unknown) => {
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            pid: number;
+            exitCode: number | null;
+            signalCode: string | null;
+            killed: boolean;
+            readonly spawnfile: string;
+            readonly spawnargs: string[];
+            readonly stdout: {
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                removeAllListeners(name?: string | symbol): /*elided*/ any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _read(size: number): void;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): /*elided*/ any;
+                pause(): /*elided*/ any;
+                resume(): /*elided*/ any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+                destroy(error?: Error | null): /*elided*/ any;
+                on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): /*elided*/ any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            };
+            readonly stderr: {
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                removeAllListeners(name?: string | symbol): any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _read(size: number): void;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): any;
+                pause(): any;
+                resume(): any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+                destroy(error?: Error | null): any;
+                on(event: string, listener: (...args: unknown[]) => void): any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            };
+            readonly stdin: {
+                writable: boolean;
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): /*elided*/ any;
+                getMaxListeners(): number;
+                on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                removeAllListeners(name?: string | symbol): /*elided*/ any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+            };
+            readonly spawnError?: import("./lib/errors").NodeStyleError;
+            kill(): boolean;
+            ref(): /*elided*/ any;
+            unref(): /*elided*/ any;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+        };
+        spawnSync: (command: unknown, args?: unknown, options?: unknown) => import("./lib/child-process-types").SpawnSyncResult;
+        fork: () => never;
+        ChildProcess: {
+            new (argv: readonly string[], outcome: import("./lib/child-process-types").RunOutcome): {
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                removeAllListeners(name?: string | symbol): /*elided*/ any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                pid: number;
+                exitCode: number | null;
+                signalCode: string | null;
+                killed: boolean;
+                readonly spawnfile: string;
+                readonly spawnargs: string[];
+                readonly stdout: {
+                    addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                    emit(name: string | symbol, ...args: unknown[]): boolean;
+                    removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    removeAllListeners(name?: string | symbol): /*elided*/ any;
+                    listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                    rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                    listenerCount(name: string | symbol): number;
+                    eventNames(): (string | symbol)[];
+                    readable: boolean;
+                    _read(size: number): void;
+                    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                    push(chunk: unknown, encoding?: string): boolean;
+                    unshift(chunk: unknown): void;
+                    read(size?: number): unknown;
+                    setEncoding(encoding: string): /*elided*/ any;
+                    pause(): /*elided*/ any;
+                    resume(): /*elided*/ any;
+                    isPaused(): boolean;
+                    pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                        end?: boolean;
+                    }): T;
+                    unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+                    destroy(error?: Error | null): /*elided*/ any;
+                    on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    [Symbol.asyncIterator](): {
+                        next(): Promise<{
+                            value: unknown;
+                            done: boolean;
+                        }>;
+                    };
+                    get maxListeners(): number;
+                    set maxListeners(value: number);
+                    setMaxListeners(count: number): /*elided*/ any;
+                    getMaxListeners(): number;
+                    addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                };
+                readonly stderr: {
+                    addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+                    emit(name: string | symbol, ...args: unknown[]): boolean;
+                    removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                    off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                    removeAllListeners(name?: string | symbol): any;
+                    listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                    rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                    listenerCount(name: string | symbol): number;
+                    eventNames(): (string | symbol)[];
+                    readable: boolean;
+                    _read(size: number): void;
+                    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                    push(chunk: unknown, encoding?: string): boolean;
+                    unshift(chunk: unknown): void;
+                    read(size?: number): unknown;
+                    setEncoding(encoding: string): any;
+                    pause(): any;
+                    resume(): any;
+                    isPaused(): boolean;
+                    pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                        end?: boolean;
+                    }): T;
+                    unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+                    destroy(error?: Error | null): any;
+                    on(event: string, listener: (...args: unknown[]) => void): any;
+                    [Symbol.asyncIterator](): {
+                        next(): Promise<{
+                            value: unknown;
+                            done: boolean;
+                        }>;
+                    };
+                    get maxListeners(): number;
+                    set maxListeners(value: number);
+                    setMaxListeners(count: number): any;
+                    getMaxListeners(): number;
+                    addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                    prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                    once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                    prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                };
+                readonly stdin: {
+                    writable: boolean;
+                    get maxListeners(): number;
+                    set maxListeners(value: number);
+                    setMaxListeners(count: number): /*elided*/ any;
+                    getMaxListeners(): number;
+                    on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                    emit(name: string | symbol, ...args: unknown[]): boolean;
+                    removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                    removeAllListeners(name?: string | symbol): /*elided*/ any;
+                    listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                    rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                    listenerCount(name: string | symbol): number;
+                    eventNames(): (string | symbol)[];
+                };
+                readonly spawnError?: import("./lib/errors").NodeStyleError;
+                kill(): boolean;
+                ref(): /*elided*/ any;
+                unref(): /*elided*/ any;
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): /*elided*/ any;
+                getMaxListeners(): number;
+                on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+            };
+            defaultMaxListeners: number;
+            errorMonitor: symbol;
+            EventEmitter: typeof eventsModule;
+            listenerCount(emitter: eventsModule, name: string | symbol): number;
+            getEventListeners(emitter: eventsModule, name: string | symbol): ((...args: unknown[]) => void)[];
+            once(emitter: eventsModule, name: string | symbol): Promise<unknown[]>;
+            on(emitter: eventsModule, name: string | symbol): void;
+        };
+    };
+    url: {
+        URLSearchParams: typeof import("./lib/url-search-params").URLSearchParams;
+        parse: (input: string, parseQueryString?: boolean, slashesDenoteHost?: boolean) => import("./lib/url-types").ParsedUrl;
+        format: (source?: unknown) => string;
+        resolve: (from: unknown, to: unknown) => string;
+        pathToFileURL: (filepath: unknown) => import("./lib/url-whatwg").URL;
+        fileURLToPath: (path: unknown) => string;
+        domainToASCII: (domain: unknown) => string;
+        domainToUnicode: (domain: unknown) => string;
+        URL: typeof import("./lib/url-whatwg").URL;
+        urlToHttpOptions: (url: unknown) => Record<string, unknown>;
+    };
+    timers: {
+        setTimeout: typeof setTimeout;
+        clearTimeout: typeof clearTimeout;
+        setInterval: typeof setInterval;
+        clearInterval: typeof clearInterval;
+        setImmediate: (handler: (...args: unknown[]) => void, ...args: unknown[]) => unknown;
+        clearImmediate: (handle: unknown) => void;
+        promises: {
+            setTimeout: (delayMs?: number, value?: unknown, options?: import("./lib/timers-types").TimerOptions) => Promise<unknown>;
+            setImmediate: (value?: unknown, options?: import("./lib/timers-types").TimerOptions) => Promise<unknown>;
+            setInterval: (delayMs: number, value?: unknown, options?: import("./lib/timers-types").TimerOptions) => AsyncGenerator<unknown>;
+            scheduler: {
+                wait: (delayMs?: number, options?: import("./lib/timers-types").TimerOptions) => Promise<void>;
+                yield: () => Promise<void>;
+            };
+        };
+    };
+    'timers/promises': {
+        setTimeout: (delayMs?: number, value?: unknown, options?: import("./lib/timers-types").TimerOptions) => Promise<unknown>;
+        setImmediate: (value?: unknown, options?: import("./lib/timers-types").TimerOptions) => Promise<unknown>;
+        setInterval: (delayMs: number, value?: unknown, options?: import("./lib/timers-types").TimerOptions) => AsyncGenerator<unknown>;
+        scheduler: {
+            wait: (delayMs?: number, options?: import("./lib/timers-types").TimerOptions) => Promise<void>;
+            yield: () => Promise<void>;
+        };
+    };
+    perf_hooks: {
+        performance: {
+            now: () => number;
+            timeOrigin: number;
+            mark: (name: unknown, options?: {
+                detail?: unknown;
+            }) => import("./lib/perf-hooks-types").PerformanceEntryLike;
+            measure: (name: unknown, startOrOptions?: string | number | import("./lib/perf-hooks-types").MeasureOptions, endMark?: string | number) => import("./lib/perf-hooks-types").PerformanceEntryLike;
+            getEntries: () => import("./lib/perf-hooks-types").PerformanceEntryLike[];
+            getEntriesByName: (name: unknown, type?: unknown) => import("./lib/perf-hooks-types").PerformanceEntryLike[];
+            getEntriesByType: (type: unknown) => import("./lib/perf-hooks-types").PerformanceEntryLike[];
+            clearMarks: (name?: unknown) => void;
+            clearMeasures: (name?: unknown) => void;
+        };
+        constants: Record<string, number>;
+    };
+    constants: Record<string, number>;
+    module: {
+        builtinModules: string[];
+        isBuiltin: (name: unknown) => boolean;
+        createRequire: () => never;
+    };
+    tty: {
+        isatty: () => boolean;
+        ReadStream: () => never;
+        WriteStream: () => never;
+    };
+    http: {
+        request: (input: string | import("./lib/http-types").RequestOptions, options?: import("./lib/http-types").RequestOptions | ((response: {
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            statusCode: number;
+            statusMessage: string;
+            headers: Record<string, string>;
+            rawHeaders: string[];
+            httpVersion: string;
+            httpVersionMajor: number;
+            httpVersionMinor: number;
+            complete: boolean;
+            url: string;
+            method: string | null;
+            aborted: boolean;
+            _read(size: number): void;
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): /*elided*/ any;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+            destroy(error?: Error | null): /*elided*/ any;
+            on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+        }) => void), callback?: (response: {
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            statusCode: number;
+            statusMessage: string;
+            headers: Record<string, string>;
+            rawHeaders: string[];
+            httpVersion: string;
+            httpVersionMajor: number;
+            httpVersionMinor: number;
+            complete: boolean;
+            url: string;
+            method: string | null;
+            aborted: boolean;
+            _read(size: number): void;
+            setMaxListeners(count: number): any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            removeAllListeners(name?: string | symbol): any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): any;
+            pause(): any;
+            resume(): any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+            destroy(error?: Error | null): any;
+            on(event: string, listener: (...args: unknown[]) => void): any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+        }) => void) => {
+            on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            method: string;
+            path: string;
+            protocol: string;
+            host: string;
+            readonly maxHeadersCount: number | null;
+            readonly reusedSocket: false;
+            aborted: boolean;
+            finished: boolean;
+            readonly targetUrl: string;
+            readonly headerMap: Record<string, string>;
+            bodyChunks: Uint8Array[];
+            timer: unknown;
+            setHeader(name: unknown, value: unknown): /*elided*/ any;
+            getHeader(name: unknown): string | undefined;
+            getHeaders(): Record<string, string>;
+            getHeaderNames(): string[];
+            hasHeader(name: unknown): boolean;
+            removeHeader(name: unknown): void;
+            _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+            _final(callback: (error?: Error | null) => void): void;
+            send(): void;
+            clearTimer(): void;
+            setTimeout(milliseconds: number, callback?: () => void): /*elided*/ any;
+            abort(): void;
+            destroy(error?: Error): /*elided*/ any;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            writable: boolean;
+        };
+        get: (input: string | import("./lib/http-types").RequestOptions, options?: import("./lib/http-types").RequestOptions | ((response: {
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            statusCode: number;
+            statusMessage: string;
+            headers: Record<string, string>;
+            rawHeaders: string[];
+            httpVersion: string;
+            httpVersionMajor: number;
+            httpVersionMinor: number;
+            complete: boolean;
+            url: string;
+            method: string | null;
+            aborted: boolean;
+            _read(size: number): void;
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): /*elided*/ any;
+            pause(): /*elided*/ any;
+            resume(): /*elided*/ any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+            destroy(error?: Error | null): /*elided*/ any;
+            on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+        }) => void), callback?: (response: {
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            statusCode: number;
+            statusMessage: string;
+            headers: Record<string, string>;
+            rawHeaders: string[];
+            httpVersion: string;
+            httpVersionMajor: number;
+            httpVersionMinor: number;
+            complete: boolean;
+            url: string;
+            method: string | null;
+            aborted: boolean;
+            _read(size: number): void;
+            setMaxListeners(count: number): any;
+            getMaxListeners(): number;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            removeAllListeners(name?: string | symbol): any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            readable: boolean;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            push(chunk: unknown, encoding?: string): boolean;
+            unshift(chunk: unknown): void;
+            read(size?: number): unknown;
+            setEncoding(encoding: string): any;
+            pause(): any;
+            resume(): any;
+            isPaused(): boolean;
+            pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                end?: boolean;
+            }): T;
+            unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+            destroy(error?: Error | null): any;
+            on(event: string, listener: (...args: unknown[]) => void): any;
+            [Symbol.asyncIterator](): {
+                next(): Promise<{
+                    value: unknown;
+                    done: boolean;
+                }>;
+            };
+        }) => void) => {
+            on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+            emit(name: string | symbol, ...args: unknown[]): boolean;
+            removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            removeAllListeners(name?: string | symbol): /*elided*/ any;
+            listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+            listenerCount(name: string | symbol): number;
+            eventNames(): (string | symbol)[];
+            method: string;
+            path: string;
+            protocol: string;
+            host: string;
+            readonly maxHeadersCount: number | null;
+            readonly reusedSocket: false;
+            aborted: boolean;
+            finished: boolean;
+            readonly targetUrl: string;
+            readonly headerMap: Record<string, string>;
+            bodyChunks: Uint8Array[];
+            timer: unknown;
+            setHeader(name: unknown, value: unknown): /*elided*/ any;
+            getHeader(name: unknown): string | undefined;
+            getHeaders(): Record<string, string>;
+            getHeaderNames(): string[];
+            hasHeader(name: unknown): boolean;
+            removeHeader(name: unknown): void;
+            _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+            _final(callback: (error?: Error | null) => void): void;
+            send(): void;
+            clearTimer(): void;
+            setTimeout(milliseconds: number, callback?: () => void): /*elided*/ any;
+            abort(): void;
+            destroy(error?: Error): /*elided*/ any;
+            get maxListeners(): number;
+            set maxListeners(value: number);
+            setMaxListeners(count: number): /*elided*/ any;
+            getMaxListeners(): number;
+            writable: boolean;
+        };
+        createServer: () => never;
+        ClientRequest: {
+            new (input: string | import("./lib/http-types").RequestOptions, options?: import("./lib/http-types").RequestOptions | ((response: {
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                statusCode: number;
+                statusMessage: string;
+                headers: Record<string, string>;
+                rawHeaders: string[];
+                httpVersion: string;
+                httpVersionMajor: number;
+                httpVersionMinor: number;
+                complete: boolean;
+                url: string;
+                method: string | null;
+                aborted: boolean;
+                _read(size: number): void;
+                setMaxListeners(count: number): /*elided*/ any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                removeAllListeners(name?: string | symbol): /*elided*/ any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): /*elided*/ any;
+                pause(): /*elided*/ any;
+                resume(): /*elided*/ any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+                destroy(error?: Error | null): /*elided*/ any;
+                on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+            }) => void), callback?: (response: {
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                statusCode: number;
+                statusMessage: string;
+                headers: Record<string, string>;
+                rawHeaders: string[];
+                httpVersion: string;
+                httpVersionMajor: number;
+                httpVersionMinor: number;
+                complete: boolean;
+                url: string;
+                method: string | null;
+                aborted: boolean;
+                _read(size: number): void;
+                setMaxListeners(count: number): any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                removeAllListeners(name?: string | symbol): any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): any;
+                pause(): any;
+                resume(): any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+                destroy(error?: Error | null): any;
+                on(event: string, listener: (...args: unknown[]) => void): any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+            }) => void): {
+                on(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                removeAllListeners(name?: string | symbol): /*elided*/ any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                method: string;
+                path: string;
+                protocol: string;
+                host: string;
+                readonly maxHeadersCount: number | null;
+                readonly reusedSocket: false;
+                aborted: boolean;
+                finished: boolean;
+                readonly targetUrl: string;
+                readonly headerMap: Record<string, string>;
+                bodyChunks: Uint8Array[];
+                timer: unknown;
+                setHeader(name: unknown, value: unknown): /*elided*/ any;
+                getHeader(name: unknown): string | undefined;
+                getHeaders(): Record<string, string>;
+                getHeaderNames(): string[];
+                hasHeader(name: unknown): boolean;
+                removeHeader(name: unknown): void;
+                _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+                _final(callback: (error?: Error | null) => void): void;
+                send(): void;
+                clearTimer(): void;
+                setTimeout(milliseconds: number, callback?: () => void): /*elided*/ any;
+                abort(): void;
+                destroy(error?: Error): /*elided*/ any;
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): /*elided*/ any;
+                getMaxListeners(): number;
+                writable: boolean;
+            };
+            defaultMaxListeners: number;
+            errorMonitor: symbol;
+            EventEmitter: typeof eventsModule;
+            listenerCount(emitter: eventsModule, name: string | symbol): number;
+            getEventListeners(emitter: eventsModule, name: string | symbol): ((...args: unknown[]) => void)[];
+            once(emitter: eventsModule, name: string | symbol): Promise<unknown[]>;
+            on(emitter: eventsModule, name: string | symbol): void;
+        };
+        IncomingMessage: {
+            new (response: import("./lib/http-driver").HttpHostResponse): {
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                statusCode: number;
+                statusMessage: string;
+                headers: Record<string, string>;
+                rawHeaders: string[];
+                httpVersion: string;
+                httpVersionMajor: number;
+                httpVersionMinor: number;
+                complete: boolean;
+                url: string;
+                method: string | null;
+                aborted: boolean;
+                _read(size: number): void;
+                setMaxListeners(count: number): /*elided*/ any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                removeAllListeners(name?: string | symbol): /*elided*/ any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): /*elided*/ any;
+                pause(): /*elided*/ any;
+                resume(): /*elided*/ any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+                destroy(error?: Error | null): /*elided*/ any;
+                on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+            };
+            once(emitter: eventsModule, name: string | symbol): Promise<unknown[]>;
+            on(emitter: eventsModule, name: string | symbol): void;
+            defaultMaxListeners: number;
+            errorMonitor: symbol;
+            EventEmitter: typeof eventsModule;
+            listenerCount(emitter: eventsModule, name: string | symbol): number;
+            getEventListeners(emitter: eventsModule, name: string | symbol): ((...args: unknown[]) => void)[];
+            from(iterable: unknown): {
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): /*elided*/ any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                removeAllListeners(name?: string | symbol): /*elided*/ any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _read(size: number): void;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): /*elided*/ any;
+                pause(): /*elided*/ any;
+                resume(): /*elided*/ any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): /*elided*/ any;
+                destroy(error?: Error | null): /*elided*/ any;
+                on(event: string, listener: (...args: unknown[]) => void): /*elided*/ any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): /*elided*/ any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): /*elided*/ any;
+            };
+        };
+        Agent: {
+            new (): {
+                maxSockets: number;
+                maxFreeSockets: number;
+                readonly sockets: Record<string, unknown[]>;
+                readonly freeSockets: Record<string, unknown[]>;
+                readonly requests: Record<string, unknown[]>;
+                readonly options: Record<string, unknown>;
+                readonly maxTotalSockets: number;
+                totalSocketCount: number;
+                destroy(): void;
+            };
+        };
+        globalAgent: {
+            maxSockets: number;
+            maxFreeSockets: number;
+            readonly sockets: Record<string, unknown[]>;
+            readonly freeSockets: Record<string, unknown[]>;
+            readonly requests: Record<string, unknown[]>;
+            readonly options: Record<string, unknown>;
+            readonly maxTotalSockets: number;
+            totalSocketCount: number;
+            destroy(): void;
+        };
+        METHODS: string[];
+        STATUS_CODES: Record<number, string>;
+        maxHeaderSize: number;
+    };
+    https: {
+        request: (input: string | import("./lib/http-types").RequestOptions, options?: unknown, callback?: unknown) => unknown;
+        get: (input: string | import("./lib/http-types").RequestOptions, options?: unknown, callback?: unknown) => unknown;
+        createServer: () => never;
+        Agent: {
+            new (): {
+                maxSockets: number;
+                maxFreeSockets: number;
+                readonly sockets: Record<string, unknown[]>;
+                readonly freeSockets: Record<string, unknown[]>;
+                readonly requests: Record<string, unknown[]>;
+                readonly options: Record<string, unknown>;
+                readonly maxTotalSockets: number;
+                totalSocketCount: number;
+                destroy(): void;
+            };
+        };
+        globalAgent: {
+            maxSockets: number;
+            maxFreeSockets: number;
+            readonly sockets: Record<string, unknown[]>;
+            readonly freeSockets: Record<string, unknown[]>;
+            readonly requests: Record<string, unknown[]>;
+            readonly options: Record<string, unknown>;
+            readonly maxTotalSockets: number;
+            totalSocketCount: number;
+            destroy(): void;
+        };
+        METHODS: string[];
+        STATUS_CODES: Record<number, string>;
+        ClientRequest: {
+            new (input: string | import("./lib/http-types").RequestOptions, options?: import("./lib/http-types").RequestOptions | ((response: {
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                statusCode: number;
+                statusMessage: string;
+                headers: Record<string, string>;
+                rawHeaders: string[];
+                httpVersion: string;
+                httpVersionMajor: number;
+                httpVersionMinor: number;
+                complete: boolean;
+                url: string;
+                method: string | null;
+                aborted: boolean;
+                _read(size: number): void;
+                setMaxListeners(count: number): any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                removeAllListeners(name?: string | symbol): any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): any;
+                pause(): any;
+                resume(): any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+                destroy(error?: Error | null): any;
+                on(event: string, listener: (...args: unknown[]) => void): any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+            }) => void), callback?: (response: {
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                statusCode: number;
+                statusMessage: string;
+                headers: Record<string, string>;
+                rawHeaders: string[];
+                httpVersion: string;
+                httpVersionMajor: number;
+                httpVersionMinor: number;
+                complete: boolean;
+                url: string;
+                method: string | null;
+                aborted: boolean;
+                _read(size: number): void;
+                setMaxListeners(count: number): any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                removeAllListeners(name?: string | symbol): any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): any;
+                pause(): any;
+                resume(): any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+                destroy(error?: Error | null): any;
+                on(event: string, listener: (...args: unknown[]) => void): any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+            }) => void): {
+                on(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                removeAllListeners(name?: string | symbol): any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                method: string;
+                path: string;
+                protocol: string;
+                host: string;
+                readonly maxHeadersCount: number | null;
+                readonly reusedSocket: false;
+                aborted: boolean;
+                finished: boolean;
+                readonly targetUrl: string;
+                readonly headerMap: Record<string, string>;
+                bodyChunks: Uint8Array[];
+                timer: unknown;
+                setHeader(name: unknown, value: unknown): any;
+                getHeader(name: unknown): string | undefined;
+                getHeaders(): Record<string, string>;
+                getHeaderNames(): string[];
+                hasHeader(name: unknown): boolean;
+                removeHeader(name: unknown): void;
+                _write(chunk: unknown, encoding: string, callback: (error?: Error | null) => void): void;
+                _final(callback: (error?: Error | null) => void): void;
+                send(): void;
+                clearTimer(): void;
+                setTimeout(milliseconds: number, callback?: () => void): any;
+                abort(): void;
+                destroy(error?: Error): any;
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): any;
+                getMaxListeners(): number;
+                writable: boolean;
+            };
+            defaultMaxListeners: number;
+            errorMonitor: symbol;
+            EventEmitter: typeof eventsModule;
+            listenerCount(emitter: eventsModule, name: string | symbol): number;
+            getEventListeners(emitter: eventsModule, name: string | symbol): ((...args: unknown[]) => void)[];
+            once(emitter: eventsModule, name: string | symbol): Promise<unknown[]>;
+            on(emitter: eventsModule, name: string | symbol): void;
+        };
+        IncomingMessage: {
+            new (response: import("./lib/http-driver").HttpHostResponse): {
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                statusCode: number;
+                statusMessage: string;
+                headers: Record<string, string>;
+                rawHeaders: string[];
+                httpVersion: string;
+                httpVersionMajor: number;
+                httpVersionMinor: number;
+                complete: boolean;
+                url: string;
+                method: string | null;
+                aborted: boolean;
+                _read(size: number): void;
+                setMaxListeners(count: number): any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                removeAllListeners(name?: string | symbol): any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): any;
+                pause(): any;
+                resume(): any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+                destroy(error?: Error | null): any;
+                on(event: string, listener: (...args: unknown[]) => void): any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+            };
+            once(emitter: eventsModule, name: string | symbol): Promise<unknown[]>;
+            on(emitter: eventsModule, name: string | symbol): void;
+            defaultMaxListeners: number;
+            errorMonitor: symbol;
+            EventEmitter: typeof eventsModule;
+            listenerCount(emitter: eventsModule, name: string | symbol): number;
+            getEventListeners(emitter: eventsModule, name: string | symbol): ((...args: unknown[]) => void)[];
+            from(iterable: unknown): {
+                addEntry(name: string | symbol, listener: (...args: unknown[]) => void, once: boolean, prepend?: boolean): any;
+                emit(name: string | symbol, ...args: unknown[]): boolean;
+                removeListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                off(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                removeAllListeners(name?: string | symbol): any;
+                listeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                rawListeners(name: string | symbol): ((...args: unknown[]) => void)[];
+                listenerCount(name: string | symbol): number;
+                eventNames(): (string | symbol)[];
+                readable: boolean;
+                _read(size: number): void;
+                _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+                push(chunk: unknown, encoding?: string): boolean;
+                unshift(chunk: unknown): void;
+                read(size?: number): unknown;
+                setEncoding(encoding: string): any;
+                pause(): any;
+                resume(): any;
+                isPaused(): boolean;
+                pipe<T extends import("./lib/stream-types").WritableLike>(destination: T, options?: {
+                    end?: boolean;
+                }): T;
+                unpipe(destination?: import("./lib/stream-types").WritableLike): any;
+                destroy(error?: Error | null): any;
+                on(event: string, listener: (...args: unknown[]) => void): any;
+                [Symbol.asyncIterator](): {
+                    next(): Promise<{
+                        value: unknown;
+                        done: boolean;
+                    }>;
+                };
+                get maxListeners(): number;
+                set maxListeners(value: number);
+                setMaxListeners(count: number): any;
+                getMaxListeners(): number;
+                addListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                once(name: string | symbol, listener: (...args: unknown[]) => void): any;
+                prependOnceListener(name: string | symbol, listener: (...args: unknown[]) => void): any;
+            };
+        };
+        maxHeaderSize: number;
+    };
+    dns: {
+        lookup: (hostname: unknown, options?: number | import("./lib/dns-types").LookupOptions | ((...args: unknown[]) => void), callback?: (...args: unknown[]) => void) => void;
+        lookupService: (address: unknown, port: unknown, callback: (...args: unknown[]) => void) => void;
+        resolve: () => never;
+        resolve4: () => never;
+        resolve6: () => never;
+        resolveAny: () => never;
+        resolveCaa: () => never;
+        resolveCname: () => never;
+        resolveMx: () => never;
+        resolveNaptr: () => never;
+        resolveNs: () => never;
+        resolvePtr: () => never;
+        resolveSoa: () => never;
+        resolveSrv: () => never;
+        resolveTlsa: () => never;
+        resolveTxt: () => never;
+        reverse: () => never;
+        getServers: () => string[];
+        setServers: () => never;
+        getDefaultResultOrder: () => string;
+        setDefaultResultOrder: (order: unknown) => void;
+        Resolver: () => never;
+        promises: {
+            lookup: (hostname: unknown, options?: number | import("./lib/dns-types").LookupOptions) => Promise<unknown>;
+            lookupService: (address: unknown, port: unknown) => Promise<{
+                hostname: string;
+                service: string;
+            }>;
+            resolve: () => never;
+            resolve4: () => never;
+            resolve6: () => never;
+            resolveAny: () => never;
+            resolveCaa: () => never;
+            resolveCname: () => never;
+            resolveMx: () => never;
+            resolveNaptr: () => never;
+            resolveNs: () => never;
+            resolvePtr: () => never;
+            resolveSoa: () => never;
+            resolveSrv: () => never;
+            resolveTlsa: () => never;
+            resolveTxt: () => never;
+            reverse: () => never;
+            getServers: () => string[];
+            setServers: () => never;
+            getDefaultResultOrder: () => string;
+            setDefaultResultOrder: (order: unknown) => void;
+        };
+    } & {
+        ADDRCONFIG: number;
+        V4MAPPED: number;
+        ALL: number;
+        NODATA: string;
+        FORMERR: string;
+        SERVFAIL: string;
+        NOTFOUND: string;
+        NOTIMP: string;
+        REFUSED: string;
+        BADQUERY: string;
+        BADNAME: string;
+        BADFAMILY: string;
+        BADRESP: string;
+        CONNREFUSED: string;
+        TIMEOUT: string;
+        EOF: string;
+        FILE: string;
+        NOMEM: string;
+        DESTRUCTION: string;
+        BADSTR: string;
+        BADFLAGS: string;
+        NONAME: string;
+        BADHINTS: string;
+        NOTINITIALIZED: string;
+        LOADIPHLPAPI: string;
+        ADDRGETNETWORKPARAMS: string;
+        CANCELLED: string;
+    };
+    'dns/promises': {
+        lookup: (hostname: unknown, options?: number | import("./lib/dns-types").LookupOptions) => Promise<unknown>;
+        lookupService: (address: unknown, port: unknown) => Promise<{
+            hostname: string;
+            service: string;
+        }>;
+        resolve: () => never;
+        resolve4: () => never;
+        resolve6: () => never;
+        resolveAny: () => never;
+        resolveCaa: () => never;
+        resolveCname: () => never;
+        resolveMx: () => never;
+        resolveNaptr: () => never;
+        resolveNs: () => never;
+        resolvePtr: () => never;
+        resolveSoa: () => never;
+        resolveSrv: () => never;
+        resolveTlsa: () => never;
+        resolveTxt: () => never;
+        reverse: () => never;
+        getServers: () => string[];
+        setServers: () => never;
+        getDefaultResultOrder: () => string;
+        setDefaultResultOrder: (order: unknown) => void;
+    };
+    console: {
+        Console: {
+            new (stdout?: unknown, stderr?: unknown): {
+                readonly stdout: import("./lib/console-types").WriteStreamLike | null;
+                readonly stderr: import("./lib/console-types").WriteStreamLike | null;
+                readonly counts: Map<string, number>;
+                readonly timers: Map<string, number>;
+                indent: string;
+                emit(target: import("./lib/console-types").WriteStreamLike | null, channel: 'log' | 'info' | 'warn' | 'error', text: string): void;
+                line(...args: unknown[]): string;
+                log(...args: unknown[]): void;
+                info(...args: unknown[]): void;
+                debug(...args: unknown[]): void;
+                warn(...args: unknown[]): void;
+                error(...args: unknown[]): void;
+                assert(value: unknown, ...args: unknown[]): void;
+                dir(value: unknown, options?: unknown): void;
+                count(label?: string): void;
+                countReset(label?: string): void;
+                time(label?: string): void;
+                timeEnd(label?: string): void;
+                timeLog(label?: string, ...args: unknown[]): void;
+                trace(...args: unknown[]): void;
+                table(data: unknown, columns?: readonly string[]): void;
+                group(...args: unknown[]): void;
+                groupCollapsed(...args: unknown[]): void;
+                groupEnd(): void;
+                clear(): void;
+                profile(): void;
+                profileEnd(): void;
+                timeStamp(): void;
+            };
+        };
+        log: (...args: unknown[]) => void;
+        info: (...args: unknown[]) => void;
+        debug: (...args: unknown[]) => void;
+        warn: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+        assert: (value: unknown, ...args: unknown[]) => void;
+        dir: (value: unknown, options?: unknown) => void;
+        count: (label?: string) => void;
+        countReset: (label?: string) => void;
+        time: (label?: string) => void;
+        timeEnd: (label?: string) => void;
+        timeLog: (label?: string, ...args: unknown[]) => void;
+        trace: (...args: unknown[]) => void;
+        table: (data: unknown, columns?: readonly string[]) => void;
+        group: (...args: unknown[]) => void;
+        groupCollapsed: (...args: unknown[]) => void;
+        groupEnd: () => void;
+        clear: () => void;
+        profile: () => void;
+        profileEnd: () => void;
+        timeStamp: () => void;
+    };
+    'util/types': {
+        isDate: (value: unknown) => boolean;
+        isRegExp: (value: unknown) => boolean;
+        isArray: (value: unknown) => boolean;
+        isTypedArray: (value: unknown) => boolean;
+        isUint8Array: (value: unknown) => boolean;
+        isArrayBuffer: (value: unknown) => boolean;
+        isPromise: (value: unknown) => boolean;
+        isNativeError: (value: unknown) => boolean;
+        isMap: (value: unknown) => boolean;
+        isSet: (value: unknown) => boolean;
+        isBigInt64Array: (value: unknown) => boolean;
+        isAsyncFunction: (value: unknown) => boolean;
+        isGeneratorFunction: (value: unknown) => boolean;
+    };
+    sys: {
+        format: (template?: unknown, ...rest: unknown[]) => string;
+        formatWithOptions: (options: import("./lib/util-types").InspectOptions, template?: unknown, ...rest: unknown[]) => string;
+        inspect: (value: unknown, options?: import("./lib/util-types").InspectOptions | boolean | number) => string;
+        inherits: (constructor: Function, superConstructor: Function) => void;
+        promisify: (original: Function) => Function;
+        callbackify: (original: Function) => Function;
+        deprecate: (fn: Function, message: string) => Function;
+        debuglog: (section: string) => Function & {
+            enabled: boolean;
+        };
+        getSystemErrorName: (errno: number) => string;
+        stripVTControlCharacters: (value: string) => string;
+        isDeepStrictEqual: (left: unknown, right: unknown) => boolean;
+        types: {
+            isDate: (value: unknown) => boolean;
+            isRegExp: (value: unknown) => boolean;
+            isArray: (value: unknown) => boolean;
+            isTypedArray: (value: unknown) => boolean;
+            isUint8Array: (value: unknown) => boolean;
+            isArrayBuffer: (value: unknown) => boolean;
+            isPromise: (value: unknown) => boolean;
+            isNativeError: (value: unknown) => boolean;
+            isMap: (value: unknown) => boolean;
+            isSet: (value: unknown) => boolean;
+            isBigInt64Array: (value: unknown) => boolean;
+            isAsyncFunction: (value: unknown) => boolean;
+            isGeneratorFunction: (value: unknown) => boolean;
+        };
+        TextEncoder: {
+            new (): {
+                readonly encoding: "utf-8";
+                encode(input?: string): Uint8Array;
+                encodeInto(source: string, destination: Uint8Array): {
+                    read: number;
+                    written: number;
+                };
+            };
+        };
+        TextDecoder: {
+            new (label?: string, options?: {
+                fatal?: boolean;
+                ignoreBOM?: boolean;
+            }): {
+                readonly encoding: string;
+                readonly fatal: boolean;
+                readonly ignoreBOM: boolean;
+                decode(input?: Uint8Array): string;
+            };
+        };
+    };
+    punycode: {
+        version: string;
+        ucs2: {
+            decode: (value: string) => number[];
+            encode: (codePoints: readonly number[]) => string;
+        };
+        decode: typeof import("./lib/punycode").decode;
+        encode: typeof import("./lib/punycode").encode;
+        toASCII: typeof import("./lib/punycode").toASCII;
+        toUnicode: typeof import("./lib/punycode").toUnicode;
+    };
+    diagnostics_channel: {
+        channel: (name: string) => {
+            readonly name: string;
+            subscribers: import("./lib/diagnostics-channel-types").Subscriber[];
+            get hasSubscribers(): boolean;
+            subscribe(onMessage: import("./lib/diagnostics-channel-types").Subscriber): void;
+            unsubscribe(onMessage: import("./lib/diagnostics-channel-types").Subscriber): void;
+            publish(message: unknown): void;
+            bindStore(_store: import("./lib/diagnostics-channel-types").ChannelStore, _transform?: unknown): void;
+            unbindStore(_store: import("./lib/diagnostics-channel-types").ChannelStore): void;
+            runStores(_context: unknown, _fn: Function, _thisArg?: unknown, ..._args: unknown[]): unknown;
+        };
+        hasSubscribers: (name: string) => boolean;
+        subscribe: (name: string, onMessage: import("./lib/diagnostics-channel-types").Subscriber) => void;
+        unsubscribe: (name: string, onMessage: import("./lib/diagnostics-channel-types").Subscriber) => void;
+        Channel: {
+            new (name: string): {
+                readonly name: string;
+                subscribers: import("./lib/diagnostics-channel-types").Subscriber[];
+                get hasSubscribers(): boolean;
+                subscribe(onMessage: import("./lib/diagnostics-channel-types").Subscriber): void;
+                unsubscribe(onMessage: import("./lib/diagnostics-channel-types").Subscriber): void;
+                publish(message: unknown): void;
+                bindStore(_store: import("./lib/diagnostics-channel-types").ChannelStore, _transform?: unknown): void;
+                unbindStore(_store: import("./lib/diagnostics-channel-types").ChannelStore): void;
+                runStores(_context: unknown, _fn: Function, _thisArg?: unknown, ..._args: unknown[]): unknown;
+            };
+        };
+    };
+    'stream/consumers': {
+        buffer: (stream: import("./lib/stream-consumers-types").ReadableLike) => Promise<bufferModule.Buffer>;
+        text: (stream: import("./lib/stream-consumers-types").ReadableLike) => Promise<string>;
+        json: (stream: import("./lib/stream-consumers-types").ReadableLike) => Promise<unknown>;
+        arrayBuffer: (stream: import("./lib/stream-consumers-types").ReadableLike) => Promise<ArrayBuffer>;
+        blob: (_stream: import("./lib/stream-consumers-types").ReadableLike) => Promise<never>;
+    };
+    v8: {
+        getHeapStatistics: () => import("./lib/v8-types").HeapStatistics;
+        getHeapSpaceStatistics: () => import("./lib/v8-types").HeapSpaceStatistics[];
+        getHeapCodeStatistics: () => import("./lib/v8-types").HeapCodeStatistics;
+        serialize: () => never;
+        deserialize: () => never;
+        setFlagsFromString: () => never;
+        cachedDataVersionTag: () => never;
+        writeHeapSnapshot: () => never;
+        takeCoverage: () => never;
+        stopCoverage: () => never;
+    };
+};
+export = api;