@types/node 16.0.0 → 16.3.0

node/net.d.ts

@@ -16,10 +16,10 @@ declare module 'net' {
     }
 
     interface SocketConstructorOpts {
-        fd?: number;
-        allowHalfOpen?: boolean;
-        readable?: boolean;
-        writable?: boolean;
+        fd?: number | undefined;
+        allowHalfOpen?: boolean | undefined;
+        readable?: boolean | undefined;
+        writable?: boolean | undefined;
     }
 
     interface OnReadOpts {
@@ -38,17 +38,17 @@ declare module 'net' {
          * Note: this will cause the streaming functionality to not provide any data, however events like 'error', 'end', and 'close' will
          * still be emitted as normal and methods like pause() and resume() will also behave as expected.
          */
-        onread?: OnReadOpts;
+        onread?: OnReadOpts | undefined;
     }
 
     interface TcpSocketConnectOpts extends ConnectOpts {
         port: number;
-        host?: string;
-        localAddress?: string;
-        localPort?: number;
-        hints?: number;
-        family?: number;
-        lookup?: LookupFunction;
+        host?: string | undefined;
+        localAddress?: string | undefined;
+        localPort?: number | undefined;
+        hints?: number | undefined;
+        family?: number | undefined;
+        lookup?: LookupFunction | undefined;
     }
 
     interface IpcSocketConnectOpts extends ConnectOpts {
@@ -87,9 +87,9 @@ declare module 'net' {
         readonly destroyed: boolean;
         readonly localAddress: string;
         readonly localPort: number;
-        readonly remoteAddress?: string;
-        readonly remoteFamily?: string;
-        readonly remotePort?: number;
+        readonly remoteAddress?: string | undefined;
+        readonly remoteFamily?: string | undefined;
+        readonly remotePort?: number | undefined;
 
         // Extended base methods
         end(cb?: () => void): void;
@@ -169,17 +169,17 @@ declare module 'net' {
     }
 
     interface ListenOptions extends Abortable {
-        port?: number;
-        host?: string;
-        backlog?: number;
-        path?: string;
-        exclusive?: boolean;
-        readableAll?: boolean;
-        writableAll?: boolean;
+        port?: number | undefined;
+        host?: string | undefined;
+        backlog?: number | undefined;
+        path?: string | undefined;
+        exclusive?: boolean | undefined;
+        readableAll?: boolean | undefined;
+        writableAll?: boolean | undefined;
         /**
          * @default false
          */
-        ipv6Only?: boolean;
+        ipv6Only?: boolean | undefined;
     }
 
     interface ServerOpts {
@@ -187,13 +187,13 @@ declare module 'net' {
          * Indicates whether half-opened TCP connections are allowed.
          * @default false
          */
-        allowHalfOpen?: boolean;
+        allowHalfOpen?: boolean | undefined;
 
         /**
          * Indicates whether the socket should be paused on incoming connections.
          * @default false
          */
-        pauseOnConnect?: boolean;
+        pauseOnConnect?: boolean | undefined;
     }
 
     // https://github.com/nodejs/node/blob/master/lib/net.js
@@ -307,11 +307,11 @@ declare module 'net' {
     }
 
     interface TcpNetConnectOpts extends TcpSocketConnectOpts, SocketConstructorOpts {
-        timeout?: number;
+        timeout?: number | undefined;
     }
 
     interface IpcNetConnectOpts extends IpcSocketConnectOpts, SocketConstructorOpts {
-        timeout?: number;
+        timeout?: number | undefined;
     }
 
     type NetConnectOpts = TcpNetConnectOpts | IpcNetConnectOpts;
@@ -333,21 +333,21 @@ declare module 'net' {
          * The network address as either an IPv4 or IPv6 string.
          * @default 127.0.0.1
          */
-        address?: string;
+        address?: string | undefined;
         /**
          * @default `'ipv4'`
          */
-        family?: IPVersion;
+        family?: IPVersion | undefined;
         /**
          * An IPv6 flow-label used only if `family` is `'ipv6'`.
          * @default 0
          */
-        flowlabel?: number;
+        flowlabel?: number | undefined;
         /**
          * An IP port.
          * @default 0
          */
-        port?: number;
+        port?: number | undefined;
     }
 
     // TODO: Mark as clonable if `kClone` symbol is set in node.

node/os.d.ts

@@ -208,6 +208,9 @@ declare module 'os' {
         }
     }
 
+    const devNull: string;
+    const EOL: string;
+
     function arch(): string;
     /**
      * Returns a string identifying the kernel version.
@@ -219,7 +222,6 @@ declare module 'os' {
     function version(): string;
     function platform(): NodeJS.Platform;
     function tmpdir(): string;
-    const EOL: string;
     function endianness(): "BE" | "LE";
     /**
      * Gets the priority of a process.

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "16.0.0",
+    "version": "16.3.0",
     "description": "TypeScript definitions for Node.js",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -227,6 +227,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "476de4c669bddcfa79d0a72250799280b3a06de4d96f30f1e357c34f930198cc",
+    "typesPublisherContentHash": "4bb604c079055370e21bcc5b3653fe8fda304149e219b7fd226fd35a9de639e9",
     "typeScriptVersion": "3.6"
 }

node/path.d.ts

@@ -40,23 +40,23 @@ declare module 'path' {
             /**
              * The root of the path such as '/' or 'c:\'
              */
-            root?: string;
+            root?: string | undefined;
             /**
              * The full directory path such as '/home/user/dir' or 'c:\path\dir'
              */
-            dir?: string;
+            dir?: string | undefined;
             /**
              * The file name including extension (if any) such as 'index.html'
              */
-            base?: string;
+            base?: string | undefined;
             /**
              * The file extension (if any) such as '.html'
              */
-            ext?: string;
+            ext?: string | undefined;
             /**
              * The file name without extension (if any) such as 'index'
              */
-            name?: string;
+            name?: string | undefined;
         }
 
         interface PlatformPath {

node/perf_hooks.d.ts

@@ -9,14 +9,14 @@ declare module 'perf_hooks' {
          * the type of garbage collection operation that occurred.
          * See perf_hooks.constants for valid values.
          */
-        readonly kind?: number;
+        readonly kind?: number | undefined;
 
         /**
          * When `performanceEntry.entryType` is equal to 'gc', the `performance.flags`
          * property contains additional information about garbage collection operation.
          * See perf_hooks.constants for valid values.
          */
-        readonly flags?: number;
+        readonly flags?: number | undefined;
     }
 
     class PerformanceEntry {
@@ -43,7 +43,7 @@ declare module 'perf_hooks' {
          */
         readonly entryType: EntryType;
 
-        readonly details?: NodeGCPerformanceDetail | unknown; // TODO: Narrow this based on entry type.
+        readonly details?: NodeGCPerformanceDetail | unknown | undefined; // TODO: Narrow this based on entry type.
     }
 
     class PerformanceNodeTiming extends PerformanceEntry {
@@ -102,31 +102,31 @@ declare module 'perf_hooks' {
         /**
          * Additional optional detail to include with the mark.
          */
-        detail?: unknown;
+        detail?: unknown | undefined;
         /**
          * An optional timestamp to be used as the mark time.
          * @default `performance.now()`.
          */
-        startTime?: number;
+        startTime?: number | undefined;
     }
 
     interface MeasureOptions {
         /**
          * Additional optional detail to include with the mark.
          */
-        detail?: unknown;
+        detail?: unknown | undefined;
         /**
          * Duration between start and end times.
          */
-        duration?: number;
+        duration?: number | undefined;
         /**
          * Timestamp to be used as the end time, or a string identifying a previously recorded mark.
          */
-        end?: number | string;
+        end?: number | string | undefined;
         /**
          * Timestamp to be used as the start time, or a string identifying a previously recorded mark.
          */
-        start?: number | string;
+        start?: number | string | undefined;
     }
 
     interface TimerifyOptions {
@@ -135,7 +135,7 @@ declare module 'perf_hooks' {
          * `perf_hooks.createHistogram()` that will record runtime durations in
          * nanoseconds.
          */
-        histogram?: RecordableHistogram;
+        histogram?: RecordableHistogram | undefined;
     }
 
     interface Performance {
@@ -262,7 +262,7 @@ declare module 'perf_hooks' {
          * Must be greater than zero.
          * @default 10
          */
-        resolution?: number;
+        resolution?: number | undefined;
     }
 
     interface Histogram {
@@ -335,18 +335,18 @@ declare module 'perf_hooks' {
          * The minimum recordable value. Must be an integer value greater than 0.
          * @default 1
          */
-        min?: number | bigint;
+        min?: number | bigint | undefined;
 
         /**
          * The maximum recordable value. Must be an integer value greater than min.
          * @default Number.MAX_SAFE_INTEGER
          */
-        max?: number | bigint;
+        max?: number | bigint | undefined;
         /**
          * The number of accuracy digits. Must be a number between 1 and 5.
          * @default 3
          */
-        figures?: number;
+        figures?: number | undefined;
     }
 
     function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;

node/process.d.ts

@@ -1,5 +1,6 @@
 declare module 'process' {
     import * as tty from 'tty';
+    import { Worker } from 'worker_threads';
 
     global {
         var process: NodeJS.Process;
@@ -38,10 +39,10 @@ declare module 'process' {
 
             interface ProcessRelease {
                 name: string;
-                sourceUrl?: string;
-                headersUrl?: string;
-                libUrl?: string;
-                lts?: string;
+                sourceUrl?: string | undefined;
+                headersUrl?: string | undefined;
+                libUrl?: string | undefined;
+                lts?: string | undefined;
             }
 
             interface ProcessVersions extends Dict<string> {
@@ -78,22 +79,26 @@ declare module 'process' {
             type BeforeExitListener = (code: number) => void;
             type DisconnectListener = () => void;
             type ExitListener = (code: number) => void;
-            type RejectionHandledListener = (promise: Promise<any>) => void;
+            type RejectionHandledListener = (promise: Promise<unknown>) => void;
             type UncaughtExceptionListener = (error: Error) => void;
-            type UnhandledRejectionListener = (reason: {} | null | undefined, promise: Promise<any>) => void;
+            type UnhandledRejectionListener = (reason: {} | null | undefined, promise: Promise<unknown>) => void;
             type WarningListener = (warning: Error) => void;
-            type MessageListener = (message: any, sendHandle: any) => void;
+            type MessageListener = (message: unknown, sendHandle: unknown) => void;
             type SignalsListener = (signal: Signals) => void;
-            type NewListenerListener = (type: string | symbol, listener: (...args: any[]) => void) => void;
-            type RemoveListenerListener = (type: string | symbol, listener: (...args: any[]) => void) => void;
-            type MultipleResolveListener = (type: MultipleResolveType, promise: Promise<any>, value: any) => void;
+            type MultipleResolveListener = (type: MultipleResolveType, promise: Promise<unknown>, value: unknown) => void;
+            type WorkerListener = (worker: Worker) => void;
 
             interface Socket extends ReadWriteStream {
-                isTTY?: true;
+                isTTY?: true | undefined;
             }
 
             // Alias for compatibility
-            interface ProcessEnv extends Dict<string> {}
+            interface ProcessEnv extends Dict<string> {
+                /**
+                 * Can be used to change the default timezone at runtime
+                 */
+                TZ?: string;
+            }
 
             interface HRTime {
                 (time?: [number, number]): [number, number];
@@ -190,24 +195,24 @@ declare module 'process' {
                  *
                  * @default 'Warning'
                  */
-                type?: string;
+                type?: string | undefined;
 
                 /**
                  * A unique identifier for the warning instance being emitted.
                  */
-                code?: string;
+                code?: string | undefined;
 
                 /**
                  * When `warning` is a `string`, `ctor` is an optional function used to limit the generated stack trace.
                  *
                  * @default process.emitWarning
                  */
-                ctor?: Function;
+                ctor?: Function | undefined;
 
                 /**
                  * Additional text to include with the error.
                  */
-                detail?: string;
+                detail?: string | undefined;
             }
 
             interface ProcessConfig {
@@ -280,7 +285,7 @@ declare module 'process' {
 
                 env: ProcessEnv;
                 exit(code?: number): never;
-                exitCode?: number;
+                exitCode?: number | undefined;
                 getgid(): number;
                 setgid(id: number | string): void;
                 getuid(): number;
@@ -303,7 +308,7 @@ declare module 'process' {
                 readonly arch: string;
                 readonly platform: Platform;
                 /** @deprecated since v14.0.0 - use `require.main` instead. */
-                mainModule?: Module;
+                mainModule?: Module | undefined;
                 memoryUsage: MemoryUsageFn;
                 cpuUsage(previousValue?: CpuUsage): CpuUsage;
                 nextTick(callback: Function, ...args: any[]): void;
@@ -332,7 +337,7 @@ declare module 'process' {
                 hrtime: HRTime;
 
                 // Worker
-                send?(message: any, sendHandle?: any, options?: { swallowErrors?: boolean}, callback?: (error: Error | null) => void): boolean;
+                send?(message: any, sendHandle?: any, options?: { swallowErrors?: boolean | undefined}, callback?: (error: Error | null) => void): boolean;
                 disconnect(): void;
                 connected: boolean;
 
@@ -346,7 +351,7 @@ declare module 'process' {
                 /**
                  * Only available with `--experimental-report`
                  */
-                report?: ProcessReport;
+                report?: ProcessReport | undefined;
 
                 resourceUsage(): ResourceUsage;
 
@@ -363,23 +368,21 @@ declare module 'process' {
                 addListener(event: "warning", listener: WarningListener): this;
                 addListener(event: "message", listener: MessageListener): this;
                 addListener(event: Signals, listener: SignalsListener): this;
-                addListener(event: "newListener", listener: NewListenerListener): this;
-                addListener(event: "removeListener", listener: RemoveListenerListener): this;
                 addListener(event: "multipleResolves", listener: MultipleResolveListener): this;
+                addListener(event: "worker", listener: WorkerListener): this;
 
                 emit(event: "beforeExit", code: number): boolean;
                 emit(event: "disconnect"): boolean;
                 emit(event: "exit", code: number): boolean;
-                emit(event: "rejectionHandled", promise: Promise<any>): boolean;
+                emit(event: "rejectionHandled", promise: Promise<unknown>): boolean;
                 emit(event: "uncaughtException", error: Error): boolean;
                 emit(event: "uncaughtExceptionMonitor", error: Error): boolean;
-                emit(event: "unhandledRejection", reason: any, promise: Promise<any>): boolean;
+                emit(event: "unhandledRejection", reason: unknown, promise: Promise<unknown>): boolean;
                 emit(event: "warning", warning: Error): boolean;
-                emit(event: "message", message: any, sendHandle: any): this;
+                emit(event: "message", message: unknown, sendHandle: unknown): this;
                 emit(event: Signals, signal: Signals): boolean;
-                emit(event: "newListener", eventName: string | symbol, listener: (...args: any[]) => void): this;
-                emit(event: "removeListener", eventName: string, listener: (...args: any[]) => void): this;
-                emit(event: "multipleResolves", listener: MultipleResolveListener): this;
+                emit(event: "multipleResolves", type: MultipleResolveType, promise: Promise<unknown>, value: unknown): this;
+                emit(event: "worker", listener: WorkerListener): this;
 
                 on(event: "beforeExit", listener: BeforeExitListener): this;
                 on(event: "disconnect", listener: DisconnectListener): this;
@@ -391,9 +394,8 @@ declare module 'process' {
                 on(event: "warning", listener: WarningListener): this;
                 on(event: "message", listener: MessageListener): this;
                 on(event: Signals, listener: SignalsListener): this;
-                on(event: "newListener", listener: NewListenerListener): this;
-                on(event: "removeListener", listener: RemoveListenerListener): this;
                 on(event: "multipleResolves", listener: MultipleResolveListener): this;
+                on(event: "worker", listener: WorkerListener): this;
                 on(event: string | symbol, listener: (...args: any[]) => void): this;
 
                 once(event: "beforeExit", listener: BeforeExitListener): this;
@@ -406,9 +408,9 @@ declare module 'process' {
                 once(event: "warning", listener: WarningListener): this;
                 once(event: "message", listener: MessageListener): this;
                 once(event: Signals, listener: SignalsListener): this;
-                once(event: "newListener", listener: NewListenerListener): this;
-                once(event: "removeListener", listener: RemoveListenerListener): this;
                 once(event: "multipleResolves", listener: MultipleResolveListener): this;
+                once(event: "worker", listener: WorkerListener): this;
+                once(event: string | symbol, listener: (...args: any[]) => void): this;
 
                 prependListener(event: "beforeExit", listener: BeforeExitListener): this;
                 prependListener(event: "disconnect", listener: DisconnectListener): this;
@@ -420,9 +422,8 @@ declare module 'process' {
                 prependListener(event: "warning", listener: WarningListener): this;
                 prependListener(event: "message", listener: MessageListener): this;
                 prependListener(event: Signals, listener: SignalsListener): this;
-                prependListener(event: "newListener", listener: NewListenerListener): this;
-                prependListener(event: "removeListener", listener: RemoveListenerListener): this;
                 prependListener(event: "multipleResolves", listener: MultipleResolveListener): this;
+                prependListener(event: "worker", listener: WorkerListener): this;
 
                 prependOnceListener(event: "beforeExit", listener: BeforeExitListener): this;
                 prependOnceListener(event: "disconnect", listener: DisconnectListener): this;
@@ -434,9 +435,8 @@ declare module 'process' {
                 prependOnceListener(event: "warning", listener: WarningListener): this;
                 prependOnceListener(event: "message", listener: MessageListener): this;
                 prependOnceListener(event: Signals, listener: SignalsListener): this;
-                prependOnceListener(event: "newListener", listener: NewListenerListener): this;
-                prependOnceListener(event: "removeListener", listener: RemoveListenerListener): this;
                 prependOnceListener(event: "multipleResolves", listener: MultipleResolveListener): this;
+                prependOnceListener(event: "worker", listener: WorkerListener): this;
 
                 listeners(event: "beforeExit"): BeforeExitListener[];
                 listeners(event: "disconnect"): DisconnectListener[];
@@ -448,9 +448,8 @@ declare module 'process' {
                 listeners(event: "warning"): WarningListener[];
                 listeners(event: "message"): MessageListener[];
                 listeners(event: Signals): SignalsListener[];
-                listeners(event: "newListener"): NewListenerListener[];
-                listeners(event: "removeListener"): RemoveListenerListener[];
                 listeners(event: "multipleResolves"): MultipleResolveListener[];
+                listeners(event: "worker"): WorkerListener[];
             }
         }
     }

node/querystring.d.ts

@@ -1,11 +1,11 @@
 declare module 'querystring' {
     interface StringifyOptions {
-        encodeURIComponent?: (str: string) => string;
+        encodeURIComponent?: ((str: string) => string) | undefined;
     }
 
     interface ParseOptions {
-        maxKeys?: number;
-        decodeURIComponent?: (str: string) => string;
+        maxKeys?: number | undefined;
+        decodeURIComponent?: ((str: string) => string) | undefined;
     }
 
     interface ParsedUrlQuery extends NodeJS.Dict<string | string[]> { }

node/readline.d.ts

@@ -2,11 +2,11 @@ declare module 'readline' {
     import { Abortable, EventEmitter } from 'events';
 
     interface Key {
-        sequence?: string;
-        name?: string;
-        ctrl?: boolean;
-        meta?: boolean;
-        shift?: boolean;
+        sequence?: string | undefined;
+        name?: string | undefined;
+        ctrl?: boolean | undefined;
+        meta?: boolean | undefined;
+        shift?: boolean | undefined;
     }
 
     class Interface extends EventEmitter {
@@ -138,28 +138,28 @@ declare module 'readline' {
 
     interface ReadLineOptions {
         input: NodeJS.ReadableStream;
-        output?: NodeJS.WritableStream;
-        completer?: Completer | AsyncCompleter;
-        terminal?: boolean;
+        output?: NodeJS.WritableStream | undefined;
+        completer?: Completer | AsyncCompleter | undefined;
+        terminal?: boolean | undefined;
         /**
          *  Initial list of history lines. This option makes sense
          * only if `terminal` is set to `true` by the user or by an internal `output`
          * check, otherwise the history caching mechanism is not initialized at all.
          * @default []
          */
-        history?: string[];
-        historySize?: number;
-        prompt?: string;
-        crlfDelay?: number;
+        history?: string[] | undefined;
+        historySize?: number | undefined;
+        prompt?: string | undefined;
+        crlfDelay?: number | undefined;
         /**
          * If `true`, when a new input line added
          * to the history list duplicates an older one, this removes the older line
          * from the list.
          * @default false
          */
-        removeHistoryDuplicates?: boolean;
-        escapeCodeTimeout?: number;
-        tabSize?: number;
+        removeHistoryDuplicates?: boolean | undefined;
+        escapeCodeTimeout?: number | undefined;
+        tabSize?: number | undefined;
     }
 
     function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;