@types/node 15.0.3 → 15.3.0

node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for Node.js (http://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Wed, 12 May 2021 19:31:25 GMT
+ * Last updated: Fri, 14 May 2021 19:01:37 GMT
  * Dependencies: none
  * Global values: `AbortController`, `AbortSignal`, `Buffer`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
 

node/child_process.d.ts

@@ -41,6 +41,7 @@ declare module 'child_process' {
          * 3. error
          * 4. exit
          * 5. message
+         * 6. spawn
          */
 
         addListener(event: string, listener: (...args: any[]) => void): this;
@@ -49,6 +50,7 @@ declare module 'child_process' {
         addListener(event: "error", listener: (err: Error) => void): this;
         addListener(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
         addListener(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
+        addListener(event: "spawn", listener: () => void): this;
 
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: "close", code: number | null, signal: NodeJS.Signals | null): boolean;
@@ -56,6 +58,7 @@ declare module 'child_process' {
         emit(event: "error", err: Error): boolean;
         emit(event: "exit", code: number | null, signal: NodeJS.Signals | null): boolean;
         emit(event: "message", message: Serializable, sendHandle: SendHandle): boolean;
+        emit(event: "spawn", listener: () => void): boolean;
 
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
@@ -63,6 +66,7 @@ declare module 'child_process' {
         on(event: "error", listener: (err: Error) => void): this;
         on(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
         on(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
+        on(event: "spawn", listener: () => void): this;
 
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
@@ -70,6 +74,7 @@ declare module 'child_process' {
         once(event: "error", listener: (err: Error) => void): this;
         once(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
         once(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
+        once(event: "spawn", listener: () => void): this;
 
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
@@ -77,6 +82,7 @@ declare module 'child_process' {
         prependListener(event: "error", listener: (err: Error) => void): this;
         prependListener(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
         prependListener(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
+        prependListener(event: "spawn", listener: () => void): this;
 
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
@@ -84,6 +90,7 @@ declare module 'child_process' {
         prependOnceListener(event: "error", listener: (err: Error) => void): this;
         prependOnceListener(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
         prependOnceListener(event: "message", listener: (message: Serializable, sendHandle: SendHandle) => void): this;
+        prependOnceListener(event: "spawn", listener: () => void): this;
     }
 
     // return this object when stdio option is undefined or not specified

node/diagnostic_channel.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @experimental
+ */
+declare module 'diagnostic_channel' {
+    /**
+     * Returns wether a named channel has subscribers or not.
+     */
+    function hasSubscribers(name: string): boolean;
+
+    /**
+     * Gets or create a diagnostic channel by name.
+     */
+    function channel(name: string): Channel;
+
+    type ChannelListener = (name: string, message: unknown) => void;
+
+    /**
+     * Simple diagnostic channel that allows
+     */
+    class Channel {
+        readonly name: string;
+        readonly hashSubscribers: boolean;
+        private constructor(name: string);
+
+        /**
+         * Add a listener to the message channel.
+         */
+        subscribe(listener: ChannelListener): void;
+        /**
+         * Removes a previously registered listener.
+         */
+        unsubscribe(listener: ChannelListener): void;
+    }
+}

node/events.d.ts

@@ -28,6 +28,10 @@ declare module 'events' {
 
         /** @deprecated since v4.0.0 */
         static listenerCount(emitter: NodeJS.EventEmitter, event: string | symbol): number;
+        /**
+         * Returns a list listener for a specific emitter event name.
+         */
+        static getEventListener(emitter: DOMEventTarget | NodeJS.EventEmitter, name: string | symbol): Function[];
 
         /**
          * This symbol shall be used to install a listener for only monitoring `'error'`

node/fs/promises.d.ts

@@ -16,6 +16,7 @@ declare module 'fs/promises' {
         BufferEncodingOption,
         OpenMode,
         Mode,
+        Abortable,
     } from 'fs';
 
     interface FileHandle {
@@ -143,7 +144,7 @@ declare module 'fs/promises' {
          * If `mode` is a string, it is parsed as an octal integer.
          * If `flag` is not supplied, the default of `'w'` is used.
          */
-        writeFile(data: string | Uint8Array, options?: BaseEncodingOptions & { mode?: Mode, flag?: OpenMode } | BufferEncoding | null): Promise<void>;
+        writeFile(data: string | Uint8Array, options?: BaseEncodingOptions & { mode?: Mode, flag?: OpenMode } & Abortable | BufferEncoding | null): Promise<void>;
 
         /**
          * See `fs.writev` promisified version.
@@ -510,7 +511,7 @@ declare module 'fs/promises' {
      * If `mode` is a string, it is parsed as an octal integer.
      * If `flag` is not supplied, the default of `'w'` is used.
      */
-    function writeFile(path: PathLike | FileHandle, data: string | Uint8Array, options?: BaseEncodingOptions & { mode?: Mode, flag?: OpenMode } | BufferEncoding | null): Promise<void>;
+    function writeFile(path: PathLike | FileHandle, data: string | Uint8Array, options?: BaseEncodingOptions & { mode?: Mode, flag?: OpenMode } & Abortable | BufferEncoding | null): Promise<void>;
 
     /**
      * Asynchronously append data to a file, creating the file if it does not exist.
@@ -533,7 +534,7 @@ declare module 'fs/promises' {
      * @param options An object that may contain an optional flag.
      * If a flag is not provided, it defaults to `'r'`.
      */
-    function readFile(path: PathLike | FileHandle, options?: { encoding?: null, flag?: OpenMode } | null): Promise<Buffer>;
+    function readFile(path: PathLike | FileHandle, options?: { encoding?: null, flag?: OpenMode } & Abortable | null): Promise<Buffer>;
 
     /**
      * Asynchronously reads the entire contents of a file.
@@ -542,7 +543,7 @@ declare module 'fs/promises' {
      * @param options An object that may contain an optional flag.
      * If a flag is not provided, it defaults to `'r'`.
      */
-    function readFile(path: PathLike | FileHandle, options: { encoding: BufferEncoding, flag?: OpenMode } | BufferEncoding): Promise<string>;
+    function readFile(path: PathLike | FileHandle, options: { encoding: BufferEncoding, flag?: OpenMode } & Abortable | BufferEncoding): Promise<string>;
 
     /**
      * Asynchronously reads the entire contents of a file.
@@ -551,7 +552,7 @@ declare module 'fs/promises' {
      * @param options An object that may contain an optional flag.
      * If a flag is not provided, it defaults to `'r'`.
      */
-    function readFile(path: PathLike | FileHandle, options?: BaseEncodingOptions & { flag?: OpenMode } | BufferEncoding | null): Promise<string | Buffer>;
+    function readFile(path: PathLike | FileHandle, options?: BaseEncodingOptions & Abortable & { flag?: OpenMode } | BufferEncoding | null): Promise<string | Buffer>;
 
     function opendir(path: string, options?: OpenDirOptions): Promise<Dir>;
 }

node/fs.d.ts

@@ -142,6 +142,11 @@ declare module 'fs' {
         prependOnceListener(event: "close", listener: () => void): this;
     }
 
+    // TODO: Move this to a more central location
+    export interface Abortable {
+        signal?: AbortSignal;
+    }
+
     export class ReadStream extends stream.Readable {
         close(): void;
         bytesRead: number;
@@ -552,13 +557,21 @@ declare module 'fs' {
         function __promisify__(path: PathLike, options?: StatOptions): Promise<Stats | BigIntStats>;
     }
 
+    export interface StatSyncFn<TDescriptor = PathLike> extends Function {
+        (path: TDescriptor, options?: undefined): Stats;
+        (path: TDescriptor, options?: StatOptions & { bigint?: false; throwIfNoEntry: false }): Stats | undefined;
+        (path: TDescriptor, options: StatOptions & { bigint: true; throwIfNoEntry: false }): BigIntStats | undefined;
+        (path: TDescriptor, options?: StatOptions & { bigint?: false }): Stats;
+        (path: TDescriptor, options: StatOptions & { bigint: true }): BigIntStats;
+        (path: TDescriptor, options: StatOptions & { bigint: boolean; throwIfNoEntry?: false }): Stats | BigIntStats;
+        (path: TDescriptor, options?: StatOptions): Stats | BigIntStats | undefined;
+    }
+
     /**
      * Synchronous stat(2) - Get file status.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    export function statSync(path: PathLike, options?: StatOptions & { bigint?: false }): Stats;
-    export function statSync(path: PathLike, options: StatOptions & { bigint: true }): BigIntStats;
-    export function statSync(path: PathLike, options?: StatOptions): Stats | BigIntStats;
+    export const statSync: StatSyncFn;
 
     /**
      * Asynchronous fstat(2) - Get file status.
@@ -584,9 +597,7 @@ declare module 'fs' {
      * Synchronous fstat(2) - Get file status.
      * @param fd A file descriptor.
      */
-    export function fstatSync(fd: number, options?: StatOptions & { bigint?: false }): Stats;
-    export function fstatSync(fd: number, options: StatOptions & { bigint: true }): BigIntStats;
-    export function fstatSync(fd: number, options?: StatOptions): Stats | BigIntStats;
+    export const fstatSync: StatSyncFn<number>;
 
     /**
      * Asynchronous lstat(2) - Get file status. Does not dereference symbolic links.
@@ -612,10 +623,7 @@ declare module 'fs' {
      * Synchronous lstat(2) - Get file status. Does not dereference symbolic links.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    export function lstatSync(path: PathLike, options?: StatOptions & { bigint?: false }): Stats;
-    export function lstatSync(path: PathLike, options: StatOptions & { bigint: true }): BigIntStats;
-    export function lstatSync(path: PathLike, options?: StatOptions): Stats | BigIntStats;
-
+    export const lstatSync: StatSyncFn;
     /**
      * Asynchronous link(2) - Create a new link (also known as a hard link) to an existing file.
      * @param existingPath A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -1557,7 +1565,11 @@ declare module 'fs' {
      * @param options An object that may contain an optional flag.
      * If a flag is not provided, it defaults to `'r'`.
      */
-    export function readFile(path: PathLike | number, options: { encoding?: null; flag?: string; } | undefined | null, callback: (err: NodeJS.ErrnoException | null, data: Buffer) => void): void;
+    export function readFile(
+        path: PathLike | number,
+        options: { encoding?: null; flag?: string; } & Abortable | undefined | null,
+        callback: (err: NodeJS.ErrnoException | null, data: Buffer) => void,
+    ): void;
 
     /**
      * Asynchronously reads the entire contents of a file.
@@ -1567,7 +1579,11 @@ declare module 'fs' {
      * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
      * If a flag is not provided, it defaults to `'r'`.
      */
-    export function readFile(path: PathLike | number, options: { encoding: BufferEncoding; flag?: string; } | string, callback: (err: NodeJS.ErrnoException | null, data: string) => void): void;
+    export function readFile(
+        path: PathLike | number,
+        options: { encoding: BufferEncoding; flag?: string; } & Abortable | string,
+        callback: (err: NodeJS.ErrnoException | null, data: string) => void,
+    ): void;
 
     /**
      * Asynchronously reads the entire contents of a file.
@@ -1579,7 +1595,8 @@ declare module 'fs' {
      */
     export function readFile(
         path: PathLike | number,
-        options: BaseEncodingOptions & { flag?: string; } | string | undefined | null,
+        // TODO: unify the options across all readfile functions
+        options: BaseEncodingOptions & { flag?: string; } & Abortable | string | undefined | null,
         callback: (err: NodeJS.ErrnoException | null, data: string | Buffer) => void,
     ): void;
 
@@ -1651,7 +1668,7 @@ declare module 'fs' {
      */
     export function readFileSync(path: PathLike | number, options?: BaseEncodingOptions & { flag?: string; } | BufferEncoding | null): string | Buffer;
 
-    export type WriteFileOptions = BaseEncodingOptions & { mode?: Mode; flag?: string; } | string | null;
+    export type WriteFileOptions = (BaseEncodingOptions & Abortable & { mode?: Mode; flag?: string; }) | string | null;
 
     /**
      * Asynchronously writes data to a file, replacing the file if it already exists.
@@ -2253,5 +2270,6 @@ declare module 'fs' {
 
     export interface StatOptions {
         bigint?: boolean;
+        throwIfNoEntry?: boolean;
     }
 }

node/http.d.ts

@@ -77,6 +77,7 @@ declare module 'http' {
     }
 
     interface ClientRequestArgs {
+        abort?: AbortSignal;
         protocol?: string | null;
         host?: string | null;
         hostname?: string | null;

node/http2.d.ts

@@ -466,7 +466,16 @@ declare module 'http2' {
         origins?: string[];
     }
 
-    export interface Http2Server extends net.Server {
+    interface HTTP2ServerCommon {
+        setTimeout(msec?: number, callback?: () => void): this;
+        /**
+         * Throws ERR_HTTP2_INVALID_SETTING_VALUE for invalid settings values.
+         * Throws ERR_INVALID_ARG_TYPE for invalid settings argument.
+         */
+        updateSettings(settings: Settings): void;
+    }
+
+    export interface Http2Server extends net.Server, HTTP2ServerCommon {
         addListener(event: "checkContinue", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
         addListener(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
         addListener(event: "session", listener: (session: ServerHttp2Session) => void): this;
@@ -514,11 +523,9 @@ declare module 'http2' {
         prependOnceListener(event: "stream", listener: (stream: ServerHttp2Stream, headers: IncomingHttpHeaders, flags: number) => void): this;
         prependOnceListener(event: "timeout", listener: () => void): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
-
-        setTimeout(msec?: number, callback?: () => void): this;
     }
 
-    export interface Http2SecureServer extends tls.Server {
+    export interface Http2SecureServer extends tls.Server, HTTP2ServerCommon {
         addListener(event: "checkContinue", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
         addListener(event: "request", listener: (request: Http2ServerRequest, response: Http2ServerResponse) => void): this;
         addListener(event: "session", listener: (session: ServerHttp2Session) => void): this;
@@ -572,8 +579,6 @@ declare module 'http2' {
         prependOnceListener(event: "timeout", listener: () => void): this;
         prependOnceListener(event: "unknownProtocol", listener: (socket: tls.TLSSocket) => void): this;
         prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
-
-        setTimeout(msec?: number, callback?: () => void): this;
     }
 
     export class Http2ServerRequest extends stream.Readable {

node/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for non-npm package Node.js 15.0
+// Type definitions for non-npm package Node.js 15.3
 // Project: http://nodejs.org/
 // Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
 //                 DefinitelyTyped <https://github.com/DefinitelyTyped>

node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "15.0.3",
+    "version": "15.3.0",
     "description": "TypeScript definitions for Node.js",
     "license": "MIT",
     "contributors": [
@@ -226,6 +226,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "7eb5009dd18ced46416312bd99ea35153ef26b85864ab15d6e7d84966531879b",
+    "typesPublisherContentHash": "db9f33705bb813befe4fef062f49dad7d922e4feb6d132c446fd94911812a697",
     "typeScriptVersion": "3.5"
 }

node/path.d.ts

@@ -1,3 +1,13 @@
+declare module 'path/posix' {
+    import path = require('path');
+    export = path;
+}
+
+declare module 'path/win32' {
+    import path = require('path');
+    export = path;
+}
+
 declare module 'path' {
     namespace path {
         /**

node/perf_hooks.d.ts

@@ -84,6 +84,12 @@ declare module 'perf_hooks' {
         utilization: number;
     }
 
+    /**
+     * @param util1 The result of a previous call to eventLoopUtilization()
+     * @param util2 The result of a previous call to eventLoopUtilization() prior to util1
+     */
+    type EventLoopUtilityFunction = (util1?: EventLoopUtilization, util2?: EventLoopUtilization) => EventLoopUtilization;
+
     interface Performance {
         /**
          * If name is not provided, removes all PerformanceMark objects from the Performance Timeline.
@@ -144,11 +150,8 @@ declare module 'perf_hooks' {
          * eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
          * It represents the percentage of time the event loop has spent outside the event loop's event provider (e.g. epoll_wait).
          * No other CPU idle time is taken into consideration.
-         *
-         * @param util1 The result of a previous call to eventLoopUtilization()
-         * @param util2 The result of a previous call to eventLoopUtilization() prior to util1
          */
-        eventLoopUtilization(util1?: EventLoopUtilization, util2?: EventLoopUtilization): EventLoopUtilization;
+        eventLoopUtilization: EventLoopUtilityFunction;
     }
 
     interface PerformanceObserverEntryList {

node/readline.d.ts

@@ -38,6 +38,7 @@ declare module 'readline' {
          */
         protected constructor(options: ReadLineOptions);
 
+        getPrompt(): string;
         setPrompt(prompt: string): void;
         prompt(preserveCursor?: boolean): void;
         question(query: string, callback: (answer: string) => void): void;

node/ts3.6/base.d.ts

@@ -23,6 +23,7 @@
 /// <reference path="../constants.d.ts" />
 /// <reference path="../crypto.d.ts" />
 /// <reference path="../dgram.d.ts" />
+/// <reference path="../diagnostic_channel.d.ts" />
 /// <reference path="../dns.d.ts" />
 /// <reference path="../dns/promises.d.ts" />
 /// <reference path="../dns/promises.d.ts" />
@@ -54,6 +55,7 @@
 /// <reference path="../tty.d.ts" />
 /// <reference path="../url.d.ts" />
 /// <reference path="../util.d.ts" />
+/// <reference path="../util/types.d.ts" />
 /// <reference path="../v8.d.ts" />
 /// <reference path="../vm.d.ts" />
 /// <reference path="../worker_threads.d.ts" />

node/util/types.d.ts

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

node/util.d.ts

@@ -1,17 +1,19 @@
 declare module 'util' {
-    interface InspectOptions extends NodeJS.InspectOptions { }
-    type Style = 'special' | 'number' | 'bigint' | 'boolean' | 'undefined' | 'null' | 'string' | 'symbol' | 'date' | 'regexp' | 'module';
-    type CustomInspectFunction = (depth: number, options: InspectOptionsStylized) => string;
-    interface InspectOptionsStylized extends InspectOptions {
+    import * as types from 'util/types';
+
+    export interface InspectOptions extends NodeJS.InspectOptions { }
+    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 {
         stylize(text: string, styleType: Style): string;
     }
-    function format(format?: any, ...param: any[]): string;
-    function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
+    export function format(format?: any, ...param: any[]): string;
+    export function formatWithOptions(inspectOptions: InspectOptions, format?: any, ...param: any[]): string;
     /** @deprecated since v0.11.3 - use a third party module instead. */
-    function log(string: string): void;
-    function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): string;
-    function inspect(object: any, options: InspectOptions): string;
-    namespace inspect {
+    export function log(string: string): void;
+    export function inspect(object: any, showHidden?: boolean, depth?: number | null, color?: boolean): string;
+    export function inspect(object: any, options: InspectOptions): string;
+    export namespace inspect {
         let colors: NodeJS.Dict<[number, number]>;
         let styles: {
             [K in Style]: string
@@ -24,156 +26,101 @@ declare module 'util' {
         const custom: unique symbol;
     }
     /** @deprecated since v4.0.0 - use `Array.isArray()` instead. */
-    function isArray(object: any): object is any[];
+    export function isArray(object: any): object is any[];
     /** @deprecated since v4.0.0 - use `util.types.isRegExp()` instead. */
-    function isRegExp(object: any): object is RegExp;
+    export function isRegExp(object: any): object is RegExp;
     /** @deprecated since v4.0.0 - use `util.types.isDate()` instead. */
-    function isDate(object: any): object is Date;
+    export function isDate(object: any): object is Date;
     /** @deprecated since v4.0.0 - use `util.types.isNativeError()` instead. */
-    function isError(object: any): object is Error;
-    function inherits(constructor: any, superConstructor: any): void;
-    function debuglog(key: string): (msg: string, ...param: any[]) => void;
+    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;
     /** @deprecated since v4.0.0 - use `typeof value === 'boolean'` instead. */
-    function isBoolean(object: any): object is boolean;
+    export function isBoolean(object: any): object is boolean;
     /** @deprecated since v4.0.0 - use `Buffer.isBuffer()` instead. */
-    function isBuffer(object: any): object is Buffer;
+    export function isBuffer(object: any): object is Buffer;
     /** @deprecated since v4.0.0 - use `typeof value === 'function'` instead. */
-    function isFunction(object: any): boolean;
+    export function isFunction(object: any): boolean;
     /** @deprecated since v4.0.0 - use `value === null` instead. */
-    function isNull(object: any): object is null;
+    export function isNull(object: any): object is null;
     /** @deprecated since v4.0.0 - use `value === null || value === undefined` instead. */
-    function isNullOrUndefined(object: any): object is null | undefined;
+    export function isNullOrUndefined(object: any): object is null | undefined;
     /** @deprecated since v4.0.0 - use `typeof value === 'number'` instead. */
-    function isNumber(object: any): object is number;
+    export function isNumber(object: any): object is number;
     /** @deprecated since v4.0.0 - use `value !== null && typeof value === 'object'` instead. */
-    function isObject(object: any): boolean;
+    export function isObject(object: any): boolean;
     /** @deprecated since v4.0.0 - use `(typeof value !== 'object' && typeof value !== 'function') || value === null` instead. */
-    function isPrimitive(object: any): boolean;
+    export function isPrimitive(object: any): boolean;
     /** @deprecated since v4.0.0 - use `typeof value === 'string'` instead. */
-    function isString(object: any): object is string;
+    export function isString(object: any): object is string;
     /** @deprecated since v4.0.0 - use `typeof value === 'symbol'` instead. */
-    function isSymbol(object: any): object is symbol;
+    export function isSymbol(object: any): object is symbol;
     /** @deprecated since v4.0.0 - use `value === undefined` instead. */
-    function isUndefined(object: any): object is undefined;
-    function deprecate<T extends Function>(fn: T, message: string, code?: string): T;
-    function isDeepStrictEqual(val1: any, val2: any): boolean;
+    export function isUndefined(object: any): object is undefined;
+    export function deprecate<T extends Function>(fn: T, message: string, code?: string): T;
+    export function isDeepStrictEqual(val1: any, val2: any): boolean;
 
-    function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void;
-    function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
-    function callbackify<T1>(fn: (arg1: T1) => Promise<void>): (arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void;
-    function callbackify<T1, TResult>(fn: (arg1: T1) => Promise<TResult>): (arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
-    function callbackify<T1, T2>(fn: (arg1: T1, arg2: T2) => Promise<void>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void;
-    function callbackify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2) => Promise<TResult>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
-    function callbackify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void;
-    function callbackify<T1, T2, T3, TResult>(
+    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;
+    export function callbackify<T1>(fn: (arg1: T1) => Promise<void>): (arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<T1, TResult>(fn: (arg1: T1) => Promise<TResult>): (arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void;
+    export function callbackify<T1, T2>(fn: (arg1: T1, arg2: T2) => Promise<void>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2) => Promise<TResult>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
+    export function callbackify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void;
+    export function callbackify<T1, T2, T3, TResult>(
         fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
-    function callbackify<T1, T2, T3, T4>(
+        export function callbackify<T1, T2, T3, T4>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => void;
-    function callbackify<T1, T2, T3, T4, TResult>(
+        export function callbackify<T1, T2, T3, T4, TResult>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
-    function callbackify<T1, T2, T3, T4, T5>(
+        export function callbackify<T1, T2, T3, T4, T5>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException) => void) => void;
-    function callbackify<T1, T2, T3, T4, T5, TResult>(
+        export function callbackify<T1, T2, T3, T4, T5, TResult>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
-    function callbackify<T1, T2, T3, T4, T5, T6>(
+    export function callbackify<T1, T2, T3, T4, T5, T6>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException) => void) => void;
-    function callbackify<T1, T2, T3, T4, T5, T6, TResult>(
+    export function callbackify<T1, T2, T3, T4, T5, T6, TResult>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void;
 
-    interface CustomPromisifyLegacy<TCustom extends Function> extends Function {
+    export interface CustomPromisifyLegacy<TCustom extends Function> extends Function {
         __promisify__: TCustom;
     }
 
-    interface CustomPromisifySymbol<TCustom extends Function> extends Function {
+    export interface CustomPromisifySymbol<TCustom extends Function> extends Function {
         [promisify.custom]: TCustom;
     }
 
-    type CustomPromisify<TCustom extends Function> = CustomPromisifySymbol<TCustom> | CustomPromisifyLegacy<TCustom>;
+    export type CustomPromisify<TCustom extends Function> = CustomPromisifySymbol<TCustom> | CustomPromisifyLegacy<TCustom>;
 
-    function promisify<TCustom extends Function>(fn: CustomPromisify<TCustom>): TCustom;
-    function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>;
-    function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>;
-    function promisify<T1, TResult>(fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void): (arg1: T1) => Promise<TResult>;
-    function promisify<T1>(fn: (arg1: T1, callback: (err?: any) => void) => void): (arg1: T1) => Promise<void>;
-    function promisify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2) => Promise<TResult>;
-    function promisify<T1, T2>(fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2) => Promise<void>;
-    function promisify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void):
+    export function promisify<TCustom extends Function>(fn: CustomPromisify<TCustom>): TCustom;
+    export function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>;
+    export function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>;
+    export function promisify<T1, TResult>(fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void): (arg1: T1) => Promise<TResult>;
+    export function promisify<T1>(fn: (arg1: T1, callback: (err?: any) => void) => void): (arg1: T1) => Promise<void>;
+    export function promisify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2) => Promise<TResult>;
+    export function promisify<T1, T2>(fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2) => Promise<void>;
+    export function promisify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void):
         (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>;
-    function promisify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>;
-    function promisify<T1, T2, T3, T4, TResult>(
+    export function promisify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>;
+    export function promisify<T1, T2, T3, T4, TResult>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>;
-    function promisify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void):
+    export function promisify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void):
         (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>;
-    function promisify<T1, T2, T3, T4, T5, TResult>(
+        export function promisify<T1, T2, T3, T4, T5, TResult>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>;
-    function promisify<T1, T2, T3, T4, T5>(
+    export function promisify<T1, T2, T3, T4, T5>(
         fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void,
     ): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>;
-    function promisify(fn: Function): Function;
-    namespace promisify {
+    export function promisify(fn: Function): Function;
+    export namespace promisify {
         const custom: unique symbol;
     }
-
-    namespace types {
-        function isAnyArrayBuffer(object: any): object is ArrayBufferLike;
-        function isArgumentsObject(object: any): object is IArguments;
-        function isArrayBuffer(object: any): object is ArrayBuffer;
-        function isArrayBufferView(object: any): object is NodeJS.ArrayBufferView;
-        function isAsyncFunction(object: any): boolean;
-        function isBigInt64Array(value: any): value is BigInt64Array;
-        function isBigUint64Array(value: any): value is BigUint64Array;
-        function isBooleanObject(object: any): object is Boolean;
-        function isBoxedPrimitive(object: any): object is String | Number | BigInt | Boolean | Symbol;
-        function isDataView(object: any): object is DataView;
-        function isDate(object: any): object is Date;
-        function isExternal(object: any): boolean;
-        function isFloat32Array(object: any): object is Float32Array;
-        function isFloat64Array(object: any): object is Float64Array;
-        function isGeneratorFunction(object: any): object is GeneratorFunction;
-        function isGeneratorObject(object: any): object is Generator;
-        function isInt8Array(object: any): object is Int8Array;
-        function isInt16Array(object: any): object is Int16Array;
-        function isInt32Array(object: any): object is Int32Array;
-        function isMap<T>(
-            object: T | {},
-        ): object is T extends ReadonlyMap<any, any>
-            ? unknown extends T
-                ? never
-                : ReadonlyMap<any, any>
-            : Map<any, any>;
-        function isMapIterator(object: any): boolean;
-        function isModuleNamespaceObject(value: any): boolean;
-        function isNativeError(object: any): object is Error;
-        function isNumberObject(object: any): object is Number;
-        function isPromise(object: any): object is Promise<any>;
-        function isProxy(object: any): boolean;
-        function isRegExp(object: any): object is RegExp;
-        function isSet<T>(
-            object: T | {},
-        ): object is T extends ReadonlySet<any>
-            ? unknown extends T
-                ? never
-                : ReadonlySet<any>
-            : Set<any>;
-        function isSetIterator(object: any): boolean;
-        function isSharedArrayBuffer(object: any): object is SharedArrayBuffer;
-        function isStringObject(object: any): object is String;
-        function isSymbolObject(object: any): object is Symbol;
-        function isTypedArray(object: any): object is NodeJS.TypedArray;
-        function isUint8Array(object: any): object is Uint8Array;
-        function isUint8ClampedArray(object: any): object is Uint8ClampedArray;
-        function isUint16Array(object: any): object is Uint16Array;
-        function isUint32Array(object: any): object is Uint32Array;
-        function isWeakMap(object: any): object is WeakMap<any, any>;
-        function isWeakSet(object: any): object is WeakSet<any>;
-    }
-
-    class TextDecoder {
+    export class TextDecoder {
         readonly encoding: string;
         readonly fatal: boolean;
         readonly ignoreBOM: boolean;
@@ -187,7 +134,7 @@ declare module 'util' {
         ): string;
     }
 
-    interface EncodeIntoResult {
+    export interface EncodeIntoResult {
         /**
          * The read Unicode code units of input.
          */
@@ -199,7 +146,9 @@ declare module 'util' {
         written: number;
     }
 
-    class TextEncoder {
+    export { types };
+
+    export class TextEncoder {
         readonly encoding: string;
         encode(input?: string): Uint8Array;
         encodeInto(input: string, output: Uint8Array): EncodeIntoResult;

node/v8.d.ts

@@ -184,4 +184,15 @@ declare module 'v8' {
      * Uses a `DefaultDeserializer` with default options to read a JS value from a buffer.
      */
     function deserialize(data: NodeJS.TypedArray): any;
+
+    /**
+     * Begins writing coverage report based on the `NODE_V8_COVERAGE` env var.
+     * Noop is the env var is not set.
+     */
+    function takeCoverage(): void;
+
+    /**
+     * Stops writing coverage report.
+     */
+    function stopCoverage(): void;
 }

node/worker_threads.d.ts

@@ -4,6 +4,7 @@ declare module 'worker_threads' {
     import { Readable, Writable } from 'stream';
     import { URL } from 'url';
     import { FileHandle } from 'fs/promises';
+    import { EventLoopUtilityFunction } from 'perf_hooks';
 
     const isMainThread: boolean;
     const parentPort: null | MessagePort;
@@ -17,6 +18,10 @@ declare module 'worker_threads' {
         readonly port2: MessagePort;
     }
 
+    interface WorkerPerformance {
+        eventLoopUtilitzation: EventLoopUtilityFunction;
+    }
+
     type TransferListItem = ArrayBuffer | MessagePort | FileHandle;
 
     class MessagePort extends EventEmitter {
@@ -119,6 +124,7 @@ declare module 'worker_threads' {
         readonly stderr: Readable;
         readonly threadId: number;
         readonly resourceLimits?: ResourceLimits;
+        readonly performance: WorkerPerformance;
 
         /**
          * @param filename  The path to the Worker’s main script or module.