@types/node 15.14.7 → 16.0.1

node v15.14/child_process.d.ts → node/child_process.d.ts

@@ -11,7 +11,7 @@ declare module 'child_process' {
         stdin: Writable | null;
         stdout: Readable | null;
         stderr: Readable | null;
-        readonly channel?: Pipe | null;
+        readonly channel?: Pipe | null | undefined;
         readonly stdio: [
             Writable | null, // stdin
             Readable | null, // stdout
@@ -20,7 +20,7 @@ declare module 'child_process' {
             Readable | Writable | null | undefined // extra
         ];
         readonly killed: boolean;
-        readonly pid?: number;
+        readonly pid?: number | undefined;
         readonly connected: boolean;
         readonly exitCode: number | null;
         readonly signalCode: NodeJS.Signals | null;
@@ -126,7 +126,7 @@ declare module 'child_process' {
     }
 
     interface MessageOptions {
-        keepOpen?: boolean;
+        keepOpen?: boolean | undefined;
     }
 
     type IOType = "overlapped" | "pipe" | "ignore" | "inherit";
@@ -140,51 +140,51 @@ declare module 'child_process' {
          * Specify the kind of serialization used for sending messages between processes.
          * @default 'json'
          */
-        serialization?: SerializationType;
+        serialization?: SerializationType | undefined;
 
         /**
          * The signal value to be used when the spawned process will be killed by the abort signal.
          * @default 'SIGTERM'
          */
-        killSignal?: NodeJS.Signals | number;
+        killSignal?: NodeJS.Signals | number | undefined;
 
         /**
          * In milliseconds the maximum amount of time the process is allowed to run.
          */
-        timeout?: number;
+        timeout?: number | undefined;
     }
 
     interface ProcessEnvOptions {
-        uid?: number;
-        gid?: number;
-        cwd?: string;
-        env?: NodeJS.ProcessEnv;
+        uid?: number | undefined;
+        gid?: number | undefined;
+        cwd?: string | undefined;
+        env?: NodeJS.ProcessEnv | undefined;
     }
 
     interface CommonOptions extends ProcessEnvOptions {
         /**
          * @default true
          */
-        windowsHide?: boolean;
+        windowsHide?: boolean | undefined;
         /**
          * @default 0
          */
-        timeout?: number;
+        timeout?: number | undefined;
     }
 
     interface CommonSpawnOptions extends CommonOptions, MessagingOptions, Abortable {
-        argv0?: string;
-        stdio?: StdioOptions;
-        shell?: boolean | string;
-        windowsVerbatimArguments?: boolean;
+        argv0?: string | undefined;
+        stdio?: StdioOptions | undefined;
+        shell?: boolean | string | undefined;
+        windowsVerbatimArguments?: boolean | undefined;
     }
 
     interface SpawnOptions extends CommonSpawnOptions {
-        detached?: boolean;
+        detached?: boolean | undefined;
     }
 
     interface SpawnOptionsWithoutStdio extends SpawnOptions {
-        stdio?: StdioPipeNamed | StdioPipe[];
+        stdio?: StdioPipeNamed | StdioPipe[] | undefined;
     }
 
     type StdioNull = 'inherit' | 'ignore' | Stream;
@@ -284,9 +284,9 @@ declare module 'child_process' {
     function spawn(command: string, args: ReadonlyArray<string>, options: SpawnOptions): ChildProcess;
 
     interface ExecOptions extends CommonOptions {
-        shell?: string;
-        maxBuffer?: number;
-        killSignal?: NodeJS.Signals | number;
+        shell?: string | undefined;
+        maxBuffer?: number | undefined;
+        killSignal?: NodeJS.Signals | number | undefined;
     }
 
     interface ExecOptionsWithStringEncoding extends ExecOptions {
@@ -298,10 +298,10 @@ declare module 'child_process' {
     }
 
     interface ExecException extends Error {
-        cmd?: string;
-        killed?: boolean;
-        code?: number;
-        signal?: NodeJS.Signals;
+        cmd?: string | undefined;
+        killed?: boolean | undefined;
+        code?: number | undefined;
+        signal?: NodeJS.Signals | undefined;
     }
 
     // no `options` definitely means stdout/stderr are `string`.
@@ -345,11 +345,11 @@ declare module 'child_process' {
     }
 
     interface ExecFileOptions extends CommonOptions, Abortable {
-        maxBuffer?: number;
-        killSignal?: NodeJS.Signals | number;
-        windowsVerbatimArguments?: boolean;
-        shell?: boolean | string;
-        signal?: AbortSignal;
+        maxBuffer?: number | undefined;
+        killSignal?: NodeJS.Signals | number | undefined;
+        windowsVerbatimArguments?: boolean | undefined;
+        shell?: boolean | string | undefined;
+        signal?: AbortSignal | undefined;
     }
     interface ExecFileOptionsWithStringEncoding extends ExecFileOptions {
         encoding: BufferEncoding;
@@ -450,26 +450,26 @@ declare module 'child_process' {
     }
 
     interface ForkOptions extends ProcessEnvOptions, MessagingOptions, Abortable {
-        execPath?: string;
-        execArgv?: string[];
-        silent?: boolean;
-        stdio?: StdioOptions;
-        detached?: boolean;
-        windowsVerbatimArguments?: boolean;
+        execPath?: string | undefined;
+        execArgv?: string[] | undefined;
+        silent?: boolean | undefined;
+        stdio?: StdioOptions | undefined;
+        detached?: boolean | undefined;
+        windowsVerbatimArguments?: boolean | undefined;
     }
     function fork(modulePath: string, options?: ForkOptions): ChildProcess;
     function fork(modulePath: string, args?: ReadonlyArray<string>, options?: ForkOptions): ChildProcess;
 
     interface SpawnSyncOptions extends CommonSpawnOptions {
-        input?: string | NodeJS.ArrayBufferView;
-        maxBuffer?: number;
-        encoding?: BufferEncoding | 'buffer' | null;
+        input?: string | NodeJS.ArrayBufferView | undefined;
+        maxBuffer?: number | undefined;
+        encoding?: BufferEncoding | 'buffer' | null | undefined;
     }
     interface SpawnSyncOptionsWithStringEncoding extends SpawnSyncOptions {
         encoding: BufferEncoding;
     }
     interface SpawnSyncOptionsWithBufferEncoding extends SpawnSyncOptions {
-        encoding?: 'buffer' | null;
+        encoding?: 'buffer' | null | undefined;
     }
     interface SpawnSyncReturns<T> {
         pid: number;
@@ -478,7 +478,7 @@ declare module 'child_process' {
         stderr: T;
         status: number | null;
         signal: NodeJS.Signals | null;
-        error?: Error;
+        error?: Error | undefined;
     }
     function spawnSync(command: string): SpawnSyncReturns<Buffer>;
     function spawnSync(command: string, options?: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
@@ -488,22 +488,22 @@ declare module 'child_process' {
     function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
     function spawnSync(command: string, args?: ReadonlyArray<string>, options?: SpawnSyncOptions): SpawnSyncReturns<Buffer>;
 
-    interface CommonExecOptions extends CommonOptions {
-        input?: string | NodeJS.ArrayBufferView;
-        stdio?: StdioOptions;
-        killSignal?: NodeJS.Signals | number;
-        maxBuffer?: number;
-        encoding?: BufferEncoding | 'buffer' | null;
+    interface CommonExecOptions extends ProcessEnvOptions {
+        input?: string | NodeJS.ArrayBufferView | undefined;
+        stdio?: StdioOptions | undefined;
+        killSignal?: NodeJS.Signals | number | undefined;
+        maxBuffer?: number | undefined;
+        encoding?: BufferEncoding | 'buffer' | null | undefined;
     }
 
     interface ExecSyncOptions extends CommonExecOptions {
-        shell?: string;
+        shell?: string | undefined;
     }
     interface ExecSyncOptionsWithStringEncoding extends ExecSyncOptions {
         encoding: BufferEncoding;
     }
     interface ExecSyncOptionsWithBufferEncoding extends ExecSyncOptions {
-        encoding?: 'buffer' | null;
+        encoding?: 'buffer' | null | undefined;
     }
     function execSync(command: string): Buffer;
     function execSync(command: string, options?: ExecSyncOptionsWithStringEncoding): string;
@@ -511,7 +511,7 @@ declare module 'child_process' {
     function execSync(command: string, options?: ExecSyncOptions): Buffer;
 
     interface ExecFileSyncOptions extends CommonExecOptions {
-        shell?: boolean | string;
+        shell?: boolean | string | undefined;
     }
     interface ExecFileSyncOptionsWithStringEncoding extends ExecFileSyncOptions {
         encoding: BufferEncoding;
@@ -527,3 +527,7 @@ declare module 'child_process' {
     function execFileSync(command: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptionsWithBufferEncoding): Buffer;
     function execFileSync(command: string, args?: ReadonlyArray<string>, options?: ExecFileSyncOptions): Buffer;
 }
+
+declare module 'node:child_process' {
+    export * from 'child_process';
+}

node v15.14/cluster.d.ts → node/cluster.d.ts

@@ -1,27 +1,27 @@
+// Requires `esModuleInterop: true`
 declare module 'cluster' {
     import * as child from 'child_process';
     import EventEmitter = require('events');
     import * as net from 'net';
 
-    // interfaces
-    interface ClusterSettings {
-        execArgv?: string[]; // default: process.execArgv
-        exec?: string;
-        args?: string[];
-        silent?: boolean;
-        stdio?: any[];
-        uid?: number;
-        gid?: number;
-        inspectPort?: number | (() => number);
+    export interface ClusterSettings {
+        execArgv?: string[] | undefined; // default: process.execArgv
+        exec?: string | undefined;
+        args?: string[] | undefined;
+        silent?: boolean | undefined;
+        stdio?: any[] | undefined;
+        uid?: number | undefined;
+        gid?: number | undefined;
+        inspectPort?: number | (() => number) | undefined;
     }
 
-    interface Address {
+    export interface Address {
         address: string;
         port: number;
         addressType: number | "udp4" | "udp6";  // 4, 6, -1, "udp4", "udp6"
     }
 
-    class Worker extends EventEmitter {
+    export class Worker extends EventEmitter {
         id: number;
         process: child.ChildProcess;
         send(message: child.Serializable, sendHandle?: child.SendHandle, callback?: (error: Error | null) => void): boolean;
@@ -90,17 +90,23 @@ declare module 'cluster' {
         prependOnceListener(event: "online", listener: () => void): this;
     }
 
-    interface Cluster extends EventEmitter {
-        Worker: Worker;
+    export interface Cluster extends EventEmitter {
         disconnect(callback?: () => void): void;
         fork(env?: any): Worker;
-        isMaster: boolean;
-        isWorker: boolean;
+        /** @deprecated since v16.0.0 - use setupPrimary. */
+        readonly isMaster: boolean;
+        readonly isPrimary: boolean;
+        readonly isWorker: boolean;
         schedulingPolicy: number;
-        settings: ClusterSettings;
+        readonly settings: ClusterSettings;
+        /** @deprecated since v16.0.0 - use setupPrimary. */
         setupMaster(settings?: ClusterSettings): void;
-        worker?: Worker;
-        workers?: NodeJS.Dict<Worker>;
+        /**
+         * `setupPrimary` is used to change the default 'fork' behavior. Once called, the settings will be present in cluster.settings.
+         */
+        setupPrimary(settings?: ClusterSettings): void;
+        readonly worker?: Worker | undefined;
+        readonly workers?: NodeJS.Dict<Worker> | undefined;
 
         readonly SCHED_NONE: number;
         readonly SCHED_RR: number;
@@ -147,7 +153,7 @@ declare module 'cluster' {
         once(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;
         once(event: "fork", listener: (worker: Worker) => void): this;
         once(event: "listening", listener: (worker: Worker, address: Address) => void): this;
-        once(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this;  // the handle is a net.Socket or net.Server object, or undefined.
+        once(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this; // the handle is a net.Socket or net.Server object, or undefined.
         once(event: "online", listener: (worker: Worker) => void): this;
         once(event: "setup", listener: (settings: ClusterSettings) => void): this;
 
@@ -156,7 +162,8 @@ declare module 'cluster' {
         prependListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): this;
         prependListener(event: "fork", listener: (worker: Worker) => void): this;
         prependListener(event: "listening", listener: (worker: Worker, address: Address) => void): this;
-        prependListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): this;  // the handle is a net.Socket or net.Server object, or undefined.
+        // the handle is a net.Socket or net.Server object, or undefined.
+        prependListener(event: "message", listener: (worker: Worker, message: any, handle?: net.Socket | net.Server) => void): this;
         prependListener(event: "online", listener: (worker: Worker) => void): this;
         prependListener(event: "setup", listener: (settings: ClusterSettings) => void): this;
 
@@ -171,92 +178,10 @@ declare module 'cluster' {
         prependOnceListener(event: "setup", listener: (settings: ClusterSettings) => void): this;
     }
 
-    const SCHED_NONE: number;
-    const SCHED_RR: number;
-
-    function disconnect(callback?: () => void): void;
-    function fork(env?: any): Worker;
-    const isMaster: boolean;
-    const isWorker: boolean;
-    let schedulingPolicy: number;
-    const settings: ClusterSettings;
-    function setupMaster(settings?: ClusterSettings): void;
-    const worker: Worker;
-    const workers: NodeJS.Dict<Worker>;
-
-    /**
-     * events.EventEmitter
-     *   1. disconnect
-     *   2. exit
-     *   3. fork
-     *   4. listening
-     *   5. message
-     *   6. online
-     *   7. setup
-     */
-    function addListener(event: string, listener: (...args: any[]) => void): Cluster;
-    function addListener(event: "disconnect", listener: (worker: Worker) => void): Cluster;
-    function addListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): Cluster;
-    function addListener(event: "fork", listener: (worker: Worker) => void): Cluster;
-    function addListener(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
-     // the handle is a net.Socket or net.Server object, or undefined.
-    function addListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;
-    function addListener(event: "online", listener: (worker: Worker) => void): Cluster;
-    function addListener(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
-
-    function emit(event: string | symbol, ...args: any[]): boolean;
-    function emit(event: "disconnect", worker: Worker): boolean;
-    function emit(event: "exit", worker: Worker, code: number, signal: string): boolean;
-    function emit(event: "fork", worker: Worker): boolean;
-    function emit(event: "listening", worker: Worker, address: Address): boolean;
-    function emit(event: "message", worker: Worker, message: any, handle: net.Socket | net.Server): boolean;
-    function emit(event: "online", worker: Worker): boolean;
-    function emit(event: "setup", settings: ClusterSettings): boolean;
-
-    function on(event: string, listener: (...args: any[]) => void): Cluster;
-    function on(event: "disconnect", listener: (worker: Worker) => void): Cluster;
-    function on(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): Cluster;
-    function on(event: "fork", listener: (worker: Worker) => void): Cluster;
-    function on(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
-    function on(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;  // the handle is a net.Socket or net.Server object, or undefined.
-    function on(event: "online", listener: (worker: Worker) => void): Cluster;
-    function on(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
-
-    function once(event: string, listener: (...args: any[]) => void): Cluster;
-    function once(event: "disconnect", listener: (worker: Worker) => void): Cluster;
-    function once(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): Cluster;
-    function once(event: "fork", listener: (worker: Worker) => void): Cluster;
-    function once(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
-    function once(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;  // the handle is a net.Socket or net.Server object, or undefined.
-    function once(event: "online", listener: (worker: Worker) => void): Cluster;
-    function once(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
-
-    function removeListener(event: string, listener: (...args: any[]) => void): Cluster;
-    function removeAllListeners(event?: string): Cluster;
-    function setMaxListeners(n: number): Cluster;
-    function getMaxListeners(): number;
-    function listeners(event: string): Function[];
-    function listenerCount(type: string): number;
-
-    function prependListener(event: string, listener: (...args: any[]) => void): Cluster;
-    function prependListener(event: "disconnect", listener: (worker: Worker) => void): Cluster;
-    function prependListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): Cluster;
-    function prependListener(event: "fork", listener: (worker: Worker) => void): Cluster;
-    function prependListener(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
-     // the handle is a net.Socket or net.Server object, or undefined.
-    function prependListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;
-    function prependListener(event: "online", listener: (worker: Worker) => void): Cluster;
-    function prependListener(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
-
-    function prependOnceListener(event: string, listener: (...args: any[]) => void): Cluster;
-    function prependOnceListener(event: "disconnect", listener: (worker: Worker) => void): Cluster;
-    function prependOnceListener(event: "exit", listener: (worker: Worker, code: number, signal: string) => void): Cluster;
-    function prependOnceListener(event: "fork", listener: (worker: Worker) => void): Cluster;
-    function prependOnceListener(event: "listening", listener: (worker: Worker, address: Address) => void): Cluster;
-     // the handle is a net.Socket or net.Server object, or undefined.
-    function prependOnceListener(event: "message", listener: (worker: Worker, message: any, handle: net.Socket | net.Server) => void): Cluster;
-    function prependOnceListener(event: "online", listener: (worker: Worker) => void): Cluster;
-    function prependOnceListener(event: "setup", listener: (settings: ClusterSettings) => void): Cluster;
+    const cluster: Cluster;
+    export default cluster;
+}
 
-    function eventNames(): string[];
+declare module 'node:cluster' {
+    export * from 'cluster';
 }

node v15.14/console.d.ts → node/console.d.ts

@@ -4,7 +4,7 @@ declare module 'console' {
     global {
         // This needs to be global to avoid TS2403 in case lib.dom.d.ts is present in the same build
         interface Console {
-            Console: NodeJS.ConsoleConstructor;
+            Console: console.ConsoleConstructor;
             /**
              * A simple assertion test that verifies whether `value` is truthy.
              * If it is not, an `AssertionError` is thrown.
@@ -25,16 +25,16 @@ declare module 'console' {
              */
             countReset(label?: string): void;
             /**
-             * The `console.debug()` function is an alias for {@link console.log()}.
+             * The `console.debug()` function is an alias for {@link console.log}.
              */
             debug(message?: any, ...optionalParams: any[]): void;
             /**
-             * Uses {@link util.inspect()} on `obj` and prints the resulting string to `stdout`.
+             * Uses {@link util.inspect} on `obj` and prints the resulting string to `stdout`.
              * This function bypasses any custom `inspect()` function defined on `obj`.
              */
             dir(obj: any, options?: InspectOptions): void;
             /**
-             * This method calls {@link console.log()} passing it the arguments received. Please note that this method does not produce any XML formatting
+             * This method calls {@link console.log} passing it the arguments received. Please note that this method does not produce any XML formatting
              */
             dirxml(...data: any[]): void;
             /**
@@ -47,7 +47,7 @@ declare module 'console' {
              */
             group(...label: any[]): void;
             /**
-             * The `console.groupCollapsed()` function is an alias for {@link console.group()}.
+             * The `console.groupCollapsed()` function is an alias for {@link console.group}.
              */
             groupCollapsed(...label: any[]): void;
             /**
@@ -55,7 +55,7 @@ declare module 'console' {
              */
             groupEnd(): void;
             /**
-             * The {@link console.info()} function is an alias for {@link console.log()}.
+             * The {@link console.info} function is an alias for {@link console.log}.
              */
             info(message?: any, ...optionalParams: any[]): void;
             /**
@@ -72,19 +72,19 @@ declare module 'console' {
              */
             time(label?: string): void;
             /**
-             * Stops a timer that was previously started by calling {@link console.time()} and prints the result to `stdout`.
+             * Stops a timer that was previously started by calling {@link console.time} and prints the result to `stdout`.
              */
             timeEnd(label?: string): void;
             /**
-             * For a timer that was previously started by calling {@link console.time()}, prints the elapsed time and other `data` arguments to `stdout`.
+             * For a timer that was previously started by calling {@link console.time}, prints the elapsed time and other `data` arguments to `stdout`.
              */
             timeLog(label?: string, ...data: any[]): void;
             /**
-             * Prints to `stderr` the string 'Trace :', followed by the {@link util.format()} formatted message and stack trace to the current position in the code.
+             * Prints to `stderr` the string 'Trace :', followed by the {@link util.format} formatted message and stack trace to the current position in the code.
              */
             trace(message?: any, ...optionalParams: any[]): void;
             /**
-             * The {@link console.warn()} function is an alias for {@link console.error()}.
+             * The {@link console.warn} function is an alias for {@link console.error}.
              */
             warn(message?: any, ...optionalParams: any[]): void;
 
@@ -106,28 +106,29 @@ declare module 'console' {
             timeStamp(label?: string): void;
         }
 
-        var console: Console;
-
-        namespace NodeJS {
+        namespace console {
             interface ConsoleConstructorOptions {
-                stdout: WritableStream;
-                stderr?: WritableStream;
-                ignoreErrors?: boolean;
-                colorMode?: boolean | 'auto';
-                inspectOptions?: InspectOptions;
+                stdout: NodeJS.WritableStream;
+                stderr?: NodeJS.WritableStream | undefined;
+                ignoreErrors?: boolean | undefined;
+                colorMode?: boolean | 'auto' | undefined;
+                inspectOptions?: InspectOptions | undefined;
             }
 
             interface ConsoleConstructor {
                 prototype: Console;
-                new(stdout: WritableStream, stderr?: WritableStream, ignoreErrors?: boolean): Console;
+                new(stdout: NodeJS.WritableStream, stderr?: NodeJS.WritableStream, ignoreErrors?: boolean): Console;
                 new(options: ConsoleConstructorOptions): Console;
             }
-
-            interface Global {
-                console: typeof console;
-            }
         }
+
+        var console: Console;
     }
 
+    export = globalThis.console;
+}
+
+declare module 'node:console' {
+    import console = require('console');
     export = console;
 }

node v15.14/constants.d.ts → node/constants.d.ts

@@ -11,3 +11,8 @@ declare module 'constants' {
         typeof fsConstants;
     export = exp;
 }
+
+declare module 'node:constants' {
+    import constants = require('constants');
+    export = constants;
+}