@types/node 15.14.7 → 16.0.1

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

@@ -37,10 +37,6 @@ declare module 'module' {
         static runMain(): void;
         static wrap(code: string): string;
 
-        /**
-         * @deprecated Deprecated since: v12.2.0. Please use createRequire() instead.
-         */
-        static createRequireFromPath(path: string): NodeRequire;
         static createRequire(path: string | URL): NodeRequire;
         static builtinModules: string[];
 
@@ -48,5 +44,30 @@ declare module 'module' {
 
         constructor(id: string, parent?: Module);
     }
+
+    global {
+        interface ImportMeta {
+            url: string;
+            /**
+             * @experimental
+             * This feature is only available with the `--experimental-import-meta-resolve`
+             * command flag enabled.
+             *
+             * Provides a module-relative resolution function scoped to each module, returning
+             * the URL string.
+             *
+             * @param specified The module specifier to resolve relative to `parent`.
+             * @param parent The absolute parent module URL to resolve from. If none
+             * is specified, the value of `import.meta.url` is used as the default.
+             */
+            resolve?(specified: string, parent?: string | URL): Promise<string>;
+        }
+    }
+
     export = Module;
 }
+
+declare module 'node:module' {
+    import module = require('module');
+    export = module;
+}

node v15.14/net.d.ts → 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;
@@ -115,7 +115,6 @@ declare module 'net' {
         addListener(event: "end", listener: () => void): this;
         addListener(event: "error", listener: (err: Error) => void): this;
         addListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
-        addListener(event: "ready", listener: () => void): this;
         addListener(event: "timeout", listener: () => void): this;
 
         emit(event: string | symbol, ...args: any[]): boolean;
@@ -126,7 +125,6 @@ declare module 'net' {
         emit(event: "end"): boolean;
         emit(event: "error", err: Error): boolean;
         emit(event: "lookup", err: Error, address: string, family: string | number, host: string): boolean;
-        emit(event: "ready"): boolean;
         emit(event: "timeout"): boolean;
 
         on(event: string, listener: (...args: any[]) => void): this;
@@ -137,7 +135,6 @@ declare module 'net' {
         on(event: "end", listener: () => void): this;
         on(event: "error", listener: (err: Error) => void): this;
         on(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
-        on(event: "ready", listener: () => void): this;
         on(event: "timeout", listener: () => void): this;
 
         once(event: string, listener: (...args: any[]) => void): this;
@@ -148,7 +145,6 @@ declare module 'net' {
         once(event: "end", listener: () => void): this;
         once(event: "error", listener: (err: Error) => void): this;
         once(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
-        once(event: "ready", listener: () => void): this;
         once(event: "timeout", listener: () => void): this;
 
         prependListener(event: string, listener: (...args: any[]) => void): this;
@@ -159,7 +155,6 @@ declare module 'net' {
         prependListener(event: "end", listener: () => void): this;
         prependListener(event: "error", listener: (err: Error) => void): this;
         prependListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
-        prependListener(event: "ready", listener: () => void): this;
         prependListener(event: "timeout", listener: () => void): this;
 
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
@@ -170,22 +165,21 @@ declare module 'net' {
         prependOnceListener(event: "end", listener: () => void): this;
         prependOnceListener(event: "error", listener: (err: Error) => void): this;
         prependOnceListener(event: "lookup", listener: (err: Error, address: string, family: string | number, host: string) => void): this;
-        prependOnceListener(event: "ready", listener: () => void): this;
         prependOnceListener(event: "timeout", listener: () => void): this;
     }
 
     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 {
@@ -193,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
@@ -313,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;
@@ -339,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.
@@ -368,3 +362,7 @@ declare module 'net' {
         readonly flowlabel: number;
     }
 }
+
+declare module 'node:net' {
+    export * from 'net';
+}

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

@@ -237,3 +237,7 @@ declare module 'os' {
      */
     function setPriority(pid: number, priority: number): void;
 }
+
+declare module 'node:os' {
+    export * from 'os';
+}

node v15.14/package.json → node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "15.14.7",
+    "version": "16.0.1",
     "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": "f60b71b8600b8ad396862537ba53704951e5478f885bc912439da78112025cbf",
+    "typesPublisherContentHash": "439cbcc286cf9e49d4bb3d391b53e338b23d39ce5de6ced5355197c306990b02",
     "typeScriptVersion": "3.6"
 }

node v15.14/path.d.ts → 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 {
@@ -161,3 +161,8 @@ declare module 'path' {
     const path: path.PlatformPath;
     export = path;
 }
+
+declare module 'node:path' {
+    import path = require('path');
+    export = path;
+}

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

@@ -3,6 +3,22 @@ declare module 'perf_hooks' {
 
     type EntryType = 'node' | 'mark' | 'measure' | 'gc' | 'function' | 'http2' | 'http';
 
+    interface NodeGCPerformanceDetail {
+        /**
+         * When `performanceEntry.entryType` is equal to 'gc', `the performance.kind` property identifies
+         * the type of garbage collection operation that occurred.
+         * See perf_hooks.constants for valid values.
+         */
+        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 | undefined;
+    }
+
     class PerformanceEntry {
         protected constructor();
         /**
@@ -27,19 +43,7 @@ declare module 'perf_hooks' {
          */
         readonly entryType: EntryType;
 
-        /**
-         * When `performanceEntry.entryType` is equal to 'gc', `the performance.kind` property identifies
-         * the type of garbage collection operation that occurred.
-         * See perf_hooks.constants for valid values.
-         */
-        readonly kind?: number;
-
-        /**
-         * 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 details?: NodeGCPerformanceDetail | unknown | undefined; // TODO: Narrow this based on entry type.
     }
 
     class PerformanceNodeTiming extends PerformanceEntry {
@@ -94,6 +98,46 @@ declare module 'perf_hooks' {
         util2?: EventLoopUtilization,
     ) => EventLoopUtilization;
 
+    interface MarkOptions {
+        /**
+         * Additional optional detail to include with the mark.
+         */
+        detail?: unknown | undefined;
+        /**
+         * An optional timestamp to be used as the mark time.
+         * @default `performance.now()`.
+         */
+        startTime?: number | undefined;
+    }
+
+    interface MeasureOptions {
+        /**
+         * Additional optional detail to include with the mark.
+         */
+        detail?: unknown | undefined;
+        /**
+         * Duration between start and end times.
+         */
+        duration?: number | undefined;
+        /**
+         * Timestamp to be used as the end time, or a string identifying a previously recorded mark.
+         */
+        end?: number | string | undefined;
+        /**
+         * Timestamp to be used as the start time, or a string identifying a previously recorded mark.
+         */
+        start?: number | string | undefined;
+    }
+
+    interface TimerifyOptions {
+        /**
+         * A histogram object created using
+         * `perf_hooks.createHistogram()` that will record runtime durations in
+         * nanoseconds.
+         */
+        histogram?: RecordableHistogram | undefined;
+    }
+
     interface Performance {
         /**
          * If name is not provided, removes all PerformanceMark objects from the Performance Timeline.
@@ -109,7 +153,7 @@ declare module 'perf_hooks' {
          * Performance marks are used to mark specific significant moments in the Performance Timeline.
          * @param name
          */
-        mark(name?: string): void;
+        mark(name?: string, options?: MarkOptions): void;
 
         /**
          * Creates a new PerformanceMeasure entry in the Performance Timeline.
@@ -127,6 +171,7 @@ declare module 'perf_hooks' {
          * @param endMark
          */
         measure(name: string, startMark?: string, endMark?: string): void;
+        measure(name: string, options: MeasureOptions): void;
 
         /**
          * An instance of the PerformanceNodeTiming class that provides performance metrics for specific Node.js operational milestones.
@@ -148,7 +193,7 @@ declare module 'perf_hooks' {
          * A PerformanceObserver must be subscribed to the 'function' event type in order for the timing details to be accessed.
          * @param fn
          */
-        timerify<T extends (...optionalParams: any[]) => any>(fn: T): T;
+        timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
 
         /**
          * eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
@@ -188,12 +233,10 @@ declare module 'perf_hooks' {
         disconnect(): void;
 
         /**
-         * Subscribes the PerformanceObserver instance to notifications of new PerformanceEntry instances identified by options.entryTypes.
+         * Subscribes the PerformanceObserver instance to notifications of new PerformanceEntry instances identified by options.entryTypes or options.type.
          * When options.buffered is false, the callback will be invoked once for every PerformanceEntry instance.
-         * Property buffered defaults to false.
-         * @param options
          */
-        observe(options: { entryTypes: ReadonlyArray<EntryType>; buffered?: boolean }): void;
+        observe(options: { entryTypes: ReadonlyArray<EntryType> } | { type: EntryType }): void;
     }
 
     namespace constants {
@@ -219,7 +262,7 @@ declare module 'perf_hooks' {
          * Must be greater than zero.
          * @default 10
          */
-        resolution?: number;
+        resolution?: number | undefined;
     }
 
     interface Histogram {
@@ -292,19 +335,23 @@ 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;
 }
+
+declare module 'node:perf_hooks' {
+    export * from 'perf_hooks';
+}

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

@@ -38,10 +38,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> {
@@ -59,6 +59,7 @@ declare module 'process' {
                 | 'android'
                 | 'darwin'
                 | 'freebsd'
+                | 'haiku'
                 | 'linux'
                 | 'openbsd'
                 | 'sunos'
@@ -88,7 +89,7 @@ declare module 'process' {
             type MultipleResolveListener = (type: MultipleResolveType, promise: Promise<any>, value: any) => void;
 
             interface Socket extends ReadWriteStream {
-                isTTY?: true;
+                isTTY?: true | undefined;
             }
 
             // Alias for compatibility
@@ -189,24 +190,51 @@ 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 {
+                readonly target_defaults: {
+                    readonly cflags: any[];
+                    readonly default_configuration: string;
+                    readonly defines: string[];
+                    readonly include_dirs: string[];
+                    readonly libraries: string[];
+                };
+                readonly variables: {
+                    readonly clang: number;
+                    readonly host_arch: string;
+                    readonly node_install_npm: boolean;
+                    readonly node_install_waf: boolean;
+                    readonly node_prefix: string;
+                    readonly node_shared_openssl: boolean;
+                    readonly node_shared_v8: boolean;
+                    readonly node_shared_zlib: boolean;
+                    readonly node_use_dtrace: boolean;
+                    readonly node_use_etw: boolean;
+                    readonly node_use_openssl: boolean;
+                    readonly target_arch: string;
+                    readonly v8_no_strict_aliasing: number;
+                    readonly v8_use_snapshot: boolean;
+                    readonly visibility: string;
+                };
             }
 
             interface Process extends EventEmitter {
@@ -252,7 +280,7 @@ declare module 'process' {
 
                 env: ProcessEnv;
                 exit(code?: number): never;
-                exitCode?: number;
+                exitCode?: number | undefined;
                 getgid(): number;
                 setgid(id: number | string): void;
                 getuid(): number;
@@ -265,46 +293,21 @@ declare module 'process' {
                 setgroups(groups: ReadonlyArray<string | number>): void;
                 setUncaughtExceptionCaptureCallback(cb: ((err: Error) => void) | null): void;
                 hasUncaughtExceptionCaptureCallback(): boolean;
-                version: string;
-                versions: ProcessVersions;
-                config: {
-                    target_defaults: {
-                        cflags: any[];
-                        default_configuration: string;
-                        defines: string[];
-                        include_dirs: string[];
-                        libraries: string[];
-                    };
-                    variables: {
-                        clang: number;
-                        host_arch: string;
-                        node_install_npm: boolean;
-                        node_install_waf: boolean;
-                        node_prefix: string;
-                        node_shared_openssl: boolean;
-                        node_shared_v8: boolean;
-                        node_shared_zlib: boolean;
-                        node_use_dtrace: boolean;
-                        node_use_etw: boolean;
-                        node_use_openssl: boolean;
-                        target_arch: string;
-                        v8_no_strict_aliasing: number;
-                        v8_use_snapshot: boolean;
-                        visibility: string;
-                    };
-                };
+                readonly version: string;
+                readonly versions: ProcessVersions;
+                readonly config: ProcessConfig;
                 kill(pid: number, signal?: string | number): true;
-                pid: number;
-                ppid: number;
+                readonly pid: number;
+                readonly ppid: number;
                 title: string;
-                arch: string;
-                platform: Platform;
+                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;
-                release: ProcessRelease;
+                readonly release: ProcessRelease;
                 features: {
                     inspector: boolean;
                     debug: boolean;
@@ -327,10 +330,9 @@ declare module 'process' {
                 umask(mask: string | number): number;
                 uptime(): number;
                 hrtime: HRTime;
-                domain: Domain;
 
                 // 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;
 
@@ -344,7 +346,7 @@ declare module 'process' {
                 /**
                  * Only available with `--experimental-report`
                  */
-                report?: ProcessReport;
+                report?: ProcessReport | undefined;
 
                 resourceUsage(): ResourceUsage;
 
@@ -450,12 +452,13 @@ declare module 'process' {
                 listeners(event: "removeListener"): RemoveListenerListener[];
                 listeners(event: "multipleResolves"): MultipleResolveListener[];
             }
-
-            interface Global {
-                process: Process;
-            }
         }
     }
 
     export = process;
 }
+
+declare module 'node:process' {
+    import process = require('process');
+    export = process;
+}

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

@@ -73,3 +73,7 @@ declare module 'punycode' {
      */
     const version: string;
 }
+
+declare module 'node:punycode' {
+    export * from 'punycode';
+}

node v15.14/querystring.d.ts → 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[]> { }
@@ -26,3 +26,7 @@ declare module 'querystring' {
     function escape(str: string): string;
     function unescape(str: string): string;
 }
+
+declare module 'node:querystring' {
+    export * from 'querystring';
+}