@types/node 15.14.9 → 16.0.0

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

@@ -59,6 +59,7 @@ declare module 'process' {
                 | 'android'
                 | 'darwin'
                 | 'freebsd'
+                | 'haiku'
                 | 'linux'
                 | 'openbsd'
                 | 'sunos'
@@ -72,14 +73,13 @@ declare module 'process' {
                 "SIGSTOP" | "SIGSYS" | "SIGTERM" | "SIGTRAP" | "SIGTSTP" | "SIGTTIN" | "SIGTTOU" | "SIGUNUSED" | "SIGURG" |
                 "SIGUSR1" | "SIGUSR2" | "SIGVTALRM" | "SIGWINCH" | "SIGXCPU" | "SIGXFSZ" | "SIGBREAK" | "SIGLOST" | "SIGINFO";
 
-            type UncaughtExceptionOrigin = 'uncaughtException' | 'unhandledRejection';
             type MultipleResolveType = 'resolve' | 'reject';
 
             type BeforeExitListener = (code: number) => void;
             type DisconnectListener = () => void;
             type ExitListener = (code: number) => void;
             type RejectionHandledListener = (promise: Promise<any>) => void;
-            type UncaughtExceptionListener = (error: Error, origin: UncaughtExceptionOrigin) => void;
+            type UncaughtExceptionListener = (error: Error) => void;
             type UnhandledRejectionListener = (reason: {} | null | undefined, promise: Promise<any>) => void;
             type WarningListener = (warning: Error) => void;
             type MessageListener = (message: any, sendHandle: any) => void;
@@ -210,6 +210,33 @@ declare module 'process' {
                 detail?: string;
             }
 
+            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 {
                 /**
                  * Can also be a tty.WriteStream, not typed due to limitations.
@@ -266,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;
                 memoryUsage: MemoryUsageFn;
                 cpuUsage(previousValue?: CpuUsage): CpuUsage;
                 nextTick(callback: Function, ...args: any[]): void;
-                release: ProcessRelease;
+                readonly release: ProcessRelease;
                 features: {
                     inspector: boolean;
                     debug: boolean;
@@ -328,7 +330,6 @@ 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;
@@ -451,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

@@ -26,3 +26,7 @@ declare module 'querystring' {
     function escape(str: string): string;
     function unescape(str: string): string;
 }
+
+declare module 'node:querystring' {
+    export * from 'querystring';
+}

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

@@ -132,7 +132,7 @@ declare module 'readline' {
     type ReadLine = Interface; // type forwarded for backwards compatibility
 
     type Completer = (line: string) => CompleterResult;
-    type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => any;
+    type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => void;
 
     type CompleterResult = [string[], string];
 
@@ -190,3 +190,7 @@ declare module 'readline' {
      */
     function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
 }
+
+declare module 'node:readline' {
+    export * from 'readline';
+}

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

@@ -393,3 +393,7 @@ declare module 'repl' {
         constructor(err: Error);
     }
 }
+
+declare module 'node:repl' {
+    export * from 'repl';
+}

node v15.14/stream/promises.d.ts → node/stream/promises.d.ts

@@ -65,3 +65,7 @@ declare module "stream/promises" {
         ...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | PipelineOptions>,
     ): Promise<void>;
 }
+
+declare module 'node:stream/promises' {
+    export * from 'stream/promises';
+}

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

@@ -469,3 +469,8 @@ declare module 'stream' {
 
     export = internal;
 }
+
+declare module 'node:stream' {
+    import stream = require('stream');
+    export = stream;
+}

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

@@ -5,3 +5,7 @@ declare module 'string_decoder' {
         end(buffer?: Buffer): string;
     }
 }
+
+declare module 'node:string_decoder' {
+    export * from 'string_decoder';
+}

node v15.14/timers/promises.d.ts → node/timers/promises.d.ts

@@ -19,3 +19,7 @@ declare module 'timers/promises' {
      */
     function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;
 }
+
+declare module 'node:timers/promises' {
+    export * from 'timers/promises';
+}

node/timers.d.ts

@@ -0,0 +1,92 @@
+declare module 'timers' {
+    import { Abortable } from 'events';
+    import { setTimeout as setTimeoutPromise, setImmediate as setImmediatePromise, setInterval as setIntervalPromise } from 'timers/promises';
+
+    interface TimerOptions extends Abortable {
+        /**
+         * Set to `false` to indicate that the scheduled `Timeout`
+         * should not require the Node.js event loop to remain active.
+         * @default true
+         */
+        ref?: boolean;
+    }
+
+    let setTimeout: typeof global.setTimeout;
+    let clearTimeout: typeof global.clearTimeout;
+    let setInterval: typeof global.setInterval;
+    let clearInterval: typeof global.clearInterval;
+    let setImmediate: typeof global.setImmediate;
+    let clearImmediate: typeof global.clearImmediate;
+
+    global {
+        namespace NodeJS {
+            // compatibility with older typings
+            interface Timer extends RefCounted {
+                hasRef(): boolean;
+                refresh(): this;
+                [Symbol.toPrimitive](): number;
+            }
+
+            interface Immediate extends RefCounted {
+                hasRef(): boolean;
+                _onImmediate: Function; // to distinguish it from the Timeout class
+            }
+
+            interface Timeout extends Timer {
+                hasRef(): boolean;
+                refresh(): this;
+                [Symbol.toPrimitive](): number;
+            }
+        }
+
+        function setTimeout<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timeout;
+        namespace setTimeout {
+            const __promisify__: typeof setTimeoutPromise;
+        }
+        function clearTimeout(timeoutId: NodeJS.Timeout): void;
+
+        function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timer;
+        namespace setInterval {
+            const __promisify__: typeof setIntervalPromise;
+        }
+        function clearInterval(intervalId: NodeJS.Timeout): void;
+
+        function setImmediate<TArgs extends any[]>(callback: (...args: TArgs) => void, ...args: TArgs): NodeJS.Immediate;
+        namespace setImmediate {
+            const __promisify__: typeof setImmediatePromise;
+        }
+        function clearImmediate(immediateId: NodeJS.Immediate): void;
+
+        function queueMicrotask(callback: () => void): void;
+    }
+}
+
+declare module 'node:timers' {
+    export * from 'timers';
+}
+
+declare module 'timers/promises' {
+    import { TimerOptions } from 'timers';
+
+    /**
+     * Returns a promise that resolves after the specified delay in milliseconds.
+     * @param delay defaults to 1
+     */
+    function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;
+
+    /**
+     * Returns a promise that resolves in the next tick.
+     */
+    function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;
+
+    /**
+     *
+     * Returns an async iterator that generates values in an interval of delay ms.
+     * @param delay defaults to 1
+     */
+    function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;
+}
+
+declare module 'node:timers/promises' {
+    export * from 'timers/promises';
+}

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

@@ -791,3 +791,7 @@ declare module 'tls' {
      */
     const rootCertificates: ReadonlyArray<string>;
 }
+
+declare module 'node:tls' {
+    export * from 'tls';
+}

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

@@ -59,3 +59,7 @@ declare module 'trace_events' {
      */
     function getEnabledCategories(): string | undefined;
 }
+
+declare module 'node:trace_events' {
+    export * from 'trace_events';
+}

node v15.14/ts3.6/assert.d.ts → node/ts3.6/assert.d.ts

@@ -1,10 +1,10 @@
 declare module 'assert' {
     /** An alias of `assert.ok()`. */
-    function assert(value: any, message?: string | Error): void;
+    function assert(value: unknown, message?: string | Error): void;
     namespace assert {
         class AssertionError extends Error {
-            actual: any;
-            expected: any;
+            actual: unknown;
+            expected: unknown;
             operator: string;
             generatedMessage: boolean;
             code: 'ERR_ASSERTION';
@@ -13,9 +13,9 @@ declare module 'assert' {
                 /** If provided, the error message is set to this value. */
                 message?: string;
                 /** The `actual` property on the error instance. */
-                actual?: any;
+                actual?: unknown;
                 /** The `expected` property on the error instance. */
-                expected?: any;
+                expected?: unknown;
                 /** The `operator` property on the error instance. */
                 operator?: string;
                 /** If provided, the generated stack trace omits frames before this function. */
@@ -42,48 +42,48 @@ declare module 'assert' {
             stack: object;
         }
 
-        type AssertPredicate = RegExp | (new () => object) | ((thrown: any) => boolean) | object | Error;
+        type AssertPredicate = RegExp | (new () => object) | ((thrown: unknown) => boolean) | object | Error;
 
         function fail(message?: string | Error): never;
         /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
         function fail(
-            actual: any,
-            expected: any,
+            actual: unknown,
+            expected: unknown,
             message?: string | Error,
             operator?: string,
             // tslint:disable-next-line:ban-types
             stackStartFn?: Function,
         ): never;
-        function ok(value: any, message?: string | Error): void;
+        function ok(value: unknown, message?: string | Error): void;
         /** @deprecated since v9.9.0 - use strictEqual() instead. */
-        function equal(actual: any, expected: any, message?: string | Error): void;
+        function equal(actual: unknown, expected: unknown, message?: string | Error): void;
         /** @deprecated since v9.9.0 - use notStrictEqual() instead. */
-        function notEqual(actual: any, expected: any, message?: string | Error): void;
+        function notEqual(actual: unknown, expected: unknown, message?: string | Error): void;
         /** @deprecated since v9.9.0 - use deepStrictEqual() instead. */
-        function deepEqual(actual: any, expected: any, message?: string | Error): void;
+        function deepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
         /** @deprecated since v9.9.0 - use notDeepStrictEqual() instead. */
-        function notDeepEqual(actual: any, expected: any, message?: string | Error): void;
-        function strictEqual(actual: any, expected: any, message?: string | Error): void;
-        function notStrictEqual(actual: any, expected: any, message?: string | Error): void;
-        function deepStrictEqual(actual: any, expected: any, message?: string | Error): void;
-        function notDeepStrictEqual(actual: any, expected: any, message?: string | Error): void;
+        function notDeepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        function strictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        function notStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        function deepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
+        function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
 
-        function throws(block: () => any, message?: string | Error): void;
-        function throws(block: () => any, error: AssertPredicate, message?: string | Error): void;
-        function doesNotThrow(block: () => any, message?: string | Error): void;
-        function doesNotThrow(block: () => any, error: AssertPredicate, message?: string | Error): void;
+        function throws(block: () => unknown, message?: string | Error): void;
+        function throws(block: () => unknown, error: AssertPredicate, message?: string | Error): void;
+        function doesNotThrow(block: () => unknown, message?: string | Error): void;
+        function doesNotThrow(block: () => unknown, error: AssertPredicate, message?: string | Error): void;
 
-        function ifError(value: any): void;
+        function ifError(value: unknown): void;
 
-        function rejects(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function rejects(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
         function rejects(
-            block: (() => Promise<any>) | Promise<any>,
+            block: (() => Promise<unknown>) | Promise<unknown>,
             error: AssertPredicate,
             message?: string | Error,
         ): Promise<void>;
-        function doesNotReject(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
+        function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
         function doesNotReject(
-            block: (() => Promise<any>) | Promise<any>,
+            block: (() => Promise<unknown>) | Promise<unknown>,
             error: AssertPredicate,
             message?: string | Error,
         ): Promise<void>;

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

@@ -64,3 +64,7 @@ declare module 'tty' {
         isTTY: boolean;
     }
 }
+
+declare module 'node:tty' {
+    export * from 'tty';
+}

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

@@ -114,3 +114,7 @@ declare module 'url' {
         [Symbol.iterator](): IterableIterator<[string, string]>;
     }
 }
+
+declare module 'node:url' {
+    export * from 'url';
+}

node/util/types.d.ts

@@ -0,0 +1,57 @@
+declare module 'util/types' {
+    function isAnyArrayBuffer(object: unknown): object is ArrayBufferLike;
+    function isArgumentsObject(object: unknown): object is IArguments;
+    function isArrayBuffer(object: unknown): object is ArrayBuffer;
+    function isArrayBufferView(object: unknown): object is NodeJS.ArrayBufferView;
+    function isAsyncFunction(object: unknown): boolean;
+    function isBigInt64Array(value: unknown): value is BigInt64Array;
+    function isBigUint64Array(value: unknown): value is BigUint64Array;
+    function isBooleanObject(object: unknown): object is Boolean;
+    function isBoxedPrimitive(object: unknown): object is String | Number | BigInt | Boolean | Symbol;
+    function isDataView(object: unknown): object is DataView;
+    function isDate(object: unknown): object is Date;
+    function isExternal(object: unknown): boolean;
+    function isFloat32Array(object: unknown): object is Float32Array;
+    function isFloat64Array(object: unknown): object is Float64Array;
+    function isGeneratorFunction(object: unknown): object is GeneratorFunction;
+    function isGeneratorObject(object: unknown): object is Generator;
+    function isInt8Array(object: unknown): object is Int8Array;
+    function isInt16Array(object: unknown): object is Int16Array;
+    function isInt32Array(object: unknown): object is Int32Array;
+    function isMap<T>(
+        object: T | {},
+    ): object is T extends ReadonlyMap<any, any>
+        ? unknown extends T
+            ? never
+            : ReadonlyMap<any, any>
+        : Map<unknown, unknown>;
+    function isMapIterator(object: unknown): boolean;
+    function isModuleNamespaceObject(value: unknown): boolean;
+    function isNativeError(object: unknown): object is Error;
+    function isNumberObject(object: unknown): object is Number;
+    function isPromise(object: unknown): object is Promise<unknown>;
+    function isProxy(object: unknown): boolean;
+    function isRegExp(object: unknown): object is RegExp;
+    function isSet<T>(
+        object: T | {},
+    ): object is T extends ReadonlySet<any>
+        ? unknown extends T
+            ? never
+            : ReadonlySet<any>
+        : Set<unknown>;
+    function isSetIterator(object: unknown): boolean;
+    function isSharedArrayBuffer(object: unknown): object is SharedArrayBuffer;
+    function isStringObject(object: unknown): object is String;
+    function isSymbolObject(object: unknown): object is Symbol;
+    function isTypedArray(object: unknown): object is NodeJS.TypedArray;
+    function isUint8Array(object: unknown): object is Uint8Array;
+    function isUint8ClampedArray(object: unknown): object is Uint8ClampedArray;
+    function isUint16Array(object: unknown): object is Uint16Array;
+    function isUint32Array(object: unknown): object is Uint32Array;
+    function isWeakMap(object: unknown): object is WeakMap<object, unknown>;
+    function isWeakSet(object: unknown): object is WeakSet<object>;
+}
+
+declare module 'node:util/types' {
+    export * from 'util/types';
+}

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

@@ -1,7 +1,47 @@
 declare module 'util' {
     import * as types from 'util/types';
 
-    export interface InspectOptions extends NodeJS.InspectOptions { }
+    export interface InspectOptions {
+        /**
+         * If set to `true`, getters are going to be
+         * inspected as well. If set to `'get'` only getters without setter are going
+         * to be inspected. If set to `'set'` only getters having a corresponding
+         * setter are going to be inspected. This might cause side effects depending on
+         * the getter function.
+         * @default `false`
+         */
+        getters?: 'get' | 'set' | boolean;
+        showHidden?: boolean;
+        /**
+         * @default 2
+         */
+        depth?: number | null;
+        colors?: boolean;
+        customInspect?: boolean;
+        showProxy?: boolean;
+        maxArrayLength?: number | null;
+        /**
+         * Specifies the maximum number of characters to
+         * include when formatting. Set to `null` or `Infinity` to show all elements.
+         * Set to `0` or negative to show no characters.
+         * @default 10000
+         */
+        maxStringLength?: number | null;
+        breakLength?: number;
+        /**
+         * Setting this to `false` causes each object key
+         * to be displayed on a new line. It will also add new lines to text that is
+         * longer than `breakLength`. If set to a number, the most `n` inner elements
+         * are united on a single line as long as all properties fit into
+         * `breakLength`. Short array elements are also grouped together. Note that no
+         * text will be reduced below 16 characters, no matter the `breakLength` size.
+         * For more information, see the example below.
+         * @default `true`
+         */
+        compact?: boolean | number;
+        sorted?: boolean | ((a: string, b: string) => number);
+    }
+
     export type Style = 'special' | 'number' | 'bigint' | 'boolean' | 'undefined' | 'null' | 'string' | 'symbol' | 'date' | 'regexp' | 'module';
     export type CustomInspectFunction = (depth: number, options: InspectOptionsStylized) => string;
     export interface InspectOptionsStylized extends InspectOptions {
@@ -9,6 +49,8 @@ declare module 'util' {
     }
     export function format(format?: any, ...param: any[]): string;
     export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
+    export function getSystemErrorMap(): Map<number, [string, string]>;
+
     /** @deprecated since v0.11.3 - use a third party module instead. */
     export function log(string: string): void;
     export function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): string;
@@ -26,39 +68,39 @@ declare module 'util' {
         const custom: unique symbol;
     }
     /** @deprecated since v4.0.0 - use `Array.isArray()` instead. */
-    export function isArray(object: any): object is any[];
+    export function isArray(object: unknown): object is unknown[];
     /** @deprecated since v4.0.0 - use `util.types.isRegExp()` instead. */
-    export function isRegExp(object: any): object is RegExp;
+    export function isRegExp(object: unknown): object is RegExp;
     /** @deprecated since v4.0.0 - use `util.types.isDate()` instead. */
-    export function isDate(object: any): object is Date;
+    export function isDate(object: unknown): object is Date;
     /** @deprecated since v4.0.0 - use `util.types.isNativeError()` instead. */
-    export function isError(object: any): object is Error;
-    export function inherits(constructor: any, superConstructor: any): void;
-    export function debuglog(key: string): (msg: string, ...param: any[]) => void;
+    export function isError(object: unknown): object is Error;
+    export function inherits(constructor: unknown, superConstructor: unknown): void;
+    export function debuglog(key: string): (msg: string, ...param: unknown[]) => void;
     /** @deprecated since v4.0.0 - use `typeof value === 'boolean'` instead. */
-    export function isBoolean(object: any): object is boolean;
+    export function isBoolean(object: unknown): object is boolean;
     /** @deprecated since v4.0.0 - use `Buffer.isBuffer()` instead. */
-    export function isBuffer(object: any): object is Buffer;
+    export function isBuffer(object: unknown): object is Buffer;
     /** @deprecated since v4.0.0 - use `typeof value === 'function'` instead. */
-    export function isFunction(object: any): boolean;
+    export function isFunction(object: unknown): boolean;
     /** @deprecated since v4.0.0 - use `value === null` instead. */
-    export function isNull(object: any): object is null;
+    export function isNull(object: unknown): object is null;
     /** @deprecated since v4.0.0 - use `value === null || value === undefined` instead. */
-    export function isNullOrUndefined(object: any): object is null | undefined;
+    export function isNullOrUndefined(object: unknown): object is null | undefined;
     /** @deprecated since v4.0.0 - use `typeof value === 'number'` instead. */
-    export function isNumber(object: any): object is number;
+    export function isNumber(object: unknown): object is number;
     /** @deprecated since v4.0.0 - use `value !== null && typeof value === 'object'` instead. */
-    export function isObject(object: any): boolean;
+    export function isObject(object: unknown): boolean;
     /** @deprecated since v4.0.0 - use `(typeof value !== 'object' && typeof value !== 'function') || value === null` instead. */
-    export function isPrimitive(object: any): boolean;
+    export function isPrimitive(object: unknown): boolean;
     /** @deprecated since v4.0.0 - use `typeof value === 'string'` instead. */
-    export function isString(object: any): object is string;
+    export function isString(object: unknown): object is string;
     /** @deprecated since v4.0.0 - use `typeof value === 'symbol'` instead. */
-    export function isSymbol(object: any): object is symbol;
+    export function isSymbol(object: unknown): object is symbol;
     /** @deprecated since v4.0.0 - use `value === undefined` instead. */
-    export function isUndefined(object: any): object is undefined;
+    export function isUndefined(object: unknown): object is undefined;
     export function deprecate<T extends Function>(fn: T, message: string, code?: string): T;
-    export function isDeepStrictEqual(val1: any, val2: any): boolean;
+    export function isDeepStrictEqual(val1: unknown, val2: unknown): boolean;
 
     export function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void;
     export function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
@@ -154,3 +196,7 @@ declare module 'util' {
         encodeInto(input: string, output: Uint8Array): EncodeIntoResult;
     }
 }
+
+declare module 'node:util' {
+    export * from 'util';
+}

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

@@ -196,3 +196,7 @@ declare module 'v8' {
      */
     function stopCoverage(): void;
 }
+
+declare module 'node:v8' {
+    export * from 'v8';
+}

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

@@ -150,3 +150,7 @@ declare module 'vm' {
      */
     function measureMemory(options?: MeasureMemoryOptions): Promise<MemoryMeasurement>;
 }
+
+declare module 'node:vm' {
+    export * from 'vm';
+}

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

@@ -84,3 +84,7 @@ declare module 'wasi' {
         readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
     }
 }
+
+declare module 'node:wasi' {
+    export * from 'wasi';
+}