@types/node 15.14.7 → 16.0.1

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 | undefined;
+        showHidden?: boolean | undefined;
+        /**
+         * @default 2
+         */
+        depth?: number | null | undefined;
+        colors?: boolean | undefined;
+        customInspect?: boolean | undefined;
+        showProxy?: boolean | undefined;
+        maxArrayLength?: number | null | undefined;
+        /**
+         * 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 | undefined;
+        breakLength?: number | undefined;
+        /**
+         * 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 | undefined;
+        sorted?: boolean | ((a: string, b: string) => number) | undefined;
+    }
+
     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;
@@ -126,11 +168,11 @@ declare module 'util' {
         readonly ignoreBOM: boolean;
         constructor(
           encoding?: string,
-          options?: { fatal?: boolean; ignoreBOM?: boolean }
+          options?: { fatal?: boolean | undefined; ignoreBOM?: boolean | undefined }
         );
         decode(
           input?: NodeJS.ArrayBufferView | ArrayBuffer | null,
-          options?: { stream?: boolean }
+          options?: { stream?: boolean | undefined }
         ): string;
     }
 
@@ -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

@@ -5,67 +5,67 @@ declare module 'vm' {
          * Specifies the filename used in stack traces produced by this script.
          * Default: `''`.
          */
-        filename?: string;
+        filename?: string | undefined;
         /**
          * Specifies the line number offset that is displayed in stack traces produced by this script.
          * Default: `0`.
          */
-        lineOffset?: number;
+        lineOffset?: number | undefined;
         /**
          * Specifies the column number offset that is displayed in stack traces produced by this script.
          * @default 0
          */
-        columnOffset?: number;
+        columnOffset?: number | undefined;
     }
     interface ScriptOptions extends BaseOptions {
-        displayErrors?: boolean;
-        timeout?: number;
-        cachedData?: Buffer;
+        displayErrors?: boolean | undefined;
+        timeout?: number | undefined;
+        cachedData?: Buffer | undefined;
         /** @deprecated in favor of `script.createCachedData()` */
-        produceCachedData?: boolean;
+        produceCachedData?: boolean | undefined;
     }
     interface RunningScriptOptions extends BaseOptions {
         /**
          * When `true`, if an `Error` occurs while compiling the `code`, the line of code causing the error is attached to the stack trace.
          * Default: `true`.
          */
-        displayErrors?: boolean;
+        displayErrors?: boolean | undefined;
         /**
          * Specifies the number of milliseconds to execute code before terminating execution.
          * If execution is terminated, an `Error` will be thrown. This value must be a strictly positive integer.
          */
-        timeout?: number;
+        timeout?: number | undefined;
         /**
          * If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received.
          * Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that.
          * If execution is terminated, an `Error` will be thrown.
          * Default: `false`.
          */
-        breakOnSigint?: boolean;
+        breakOnSigint?: boolean | undefined;
         /**
          * If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
          */
-        microtaskMode?: 'afterEvaluate';
+        microtaskMode?: 'afterEvaluate' | undefined;
     }
     interface CompileFunctionOptions extends BaseOptions {
         /**
          * Provides an optional data with V8's code cache data for the supplied source.
          */
-        cachedData?: Buffer;
+        cachedData?: Buffer | undefined;
         /**
          * Specifies whether to produce new cache data.
          * Default: `false`,
          */
-        produceCachedData?: boolean;
+        produceCachedData?: boolean | undefined;
         /**
          * The sandbox/context in which the said function should be compiled in.
          */
-        parsingContext?: Context;
+        parsingContext?: Context | undefined;
 
         /**
          * An array containing a collection of context extensions (objects wrapping the current scope) to be applied while compiling
          */
-        contextExtensions?: Object[];
+        contextExtensions?: Object[] | undefined;
     }
 
     interface CreateContextOptions {
@@ -73,7 +73,7 @@ declare module 'vm' {
          * Human-readable name of the newly created context.
          * @default 'VM Context i' Where i is an ascending numerical index of the created context.
          */
-        name?: string;
+        name?: string | undefined;
         /**
          * Corresponds to the newly created context for display purposes.
          * The origin should be formatted like a `URL`, but with only the scheme, host, and port (if necessary),
@@ -81,24 +81,24 @@ declare module 'vm' {
          * Most notably, this string should omit the trailing slash, as that denotes a path.
          * @default ''
          */
-        origin?: string;
+        origin?: string | undefined;
         codeGeneration?: {
             /**
              * If set to false any calls to eval or function constructors (Function, GeneratorFunction, etc)
              * will throw an EvalError.
              * @default true
              */
-            strings?: boolean;
+            strings?: boolean | undefined;
             /**
              * If set to false any attempt to compile a WebAssembly module will throw a WebAssembly.CompileError.
              * @default true
              */
-            wasm?: boolean;
-        };
+            wasm?: boolean | undefined;
+        } | undefined;
         /**
          * If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
          */
-        microtaskMode?: 'afterEvaluate';
+        microtaskMode?: 'afterEvaluate' | undefined;
     }
 
     type MeasureMemoryMode = 'summary' | 'detailed';
@@ -107,8 +107,8 @@ declare module 'vm' {
         /**
          * @default 'summary'
          */
-        mode?: MeasureMemoryMode;
-        context?: Context;
+        mode?: MeasureMemoryMode | undefined;
+        context?: Context | undefined;
     }
 
     interface MemoryMeasurement {
@@ -124,7 +124,7 @@ declare module 'vm' {
         runInNewContext(sandbox?: Context, options?: RunningScriptOptions): any;
         runInThisContext(options?: RunningScriptOptions): any;
         createCachedData(): Buffer;
-        cachedDataRejected?: boolean;
+        cachedDataRejected?: boolean | undefined;
     }
     function createContext(sandbox?: Context, options?: CreateContextOptions): Context;
     function isContext(sandbox: Context): boolean;
@@ -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

@@ -5,13 +5,13 @@ declare module 'wasi' {
          * see as command line arguments. The first argument is the virtual path to the
          * WASI command itself.
          */
-        args?: string[];
+        args?: string[] | undefined;
 
         /**
          * An object similar to `process.env` that the WebAssembly
          * application will see as its environment.
          */
-        env?: object;
+        env?: object | undefined;
 
         /**
          * This object represents the WebAssembly application's
@@ -19,7 +19,7 @@ declare module 'wasi' {
          * directories within the sandbox. The corresponding values in `preopens` are
          * the real paths to those directories on the host machine.
          */
-        preopens?: NodeJS.Dict<string>;
+        preopens?: NodeJS.Dict<string> | undefined;
 
         /**
          * By default, WASI applications terminate the Node.js
@@ -28,25 +28,25 @@ declare module 'wasi' {
          * process.
          * @default false
          */
-        returnOnExit?: boolean;
+        returnOnExit?: boolean | undefined;
 
         /**
          * The file descriptor used as standard input in the WebAssembly application.
          * @default 0
          */
-        stdin?: number;
+        stdin?: number | undefined;
 
         /**
          * The file descriptor used as standard output in the WebAssembly application.
          * @default 1
          */
-        stdout?: number;
+        stdout?: number | undefined;
 
         /**
          * The file descriptor used as standard error in the WebAssembly application.
          * @default 2
          */
-        stderr?: number;
+        stderr?: number | undefined;
     }
 
     class WASI {
@@ -84,3 +84,7 @@ declare module 'wasi' {
         readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
     }
 }
+
+declare module 'node:wasi' {
+    export * from 'wasi';
+}

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

@@ -81,43 +81,43 @@ declare module 'worker_threads' {
          * but the values will be available on the global `process.argv` as if they
          * were passed as CLI options to the script.
          */
-        argv?: any[];
-        env?: NodeJS.Dict<string> | typeof SHARE_ENV;
-        eval?: boolean;
+        argv?: any[] | undefined;
+        env?: NodeJS.Dict<string> | typeof SHARE_ENV | undefined;
+        eval?: boolean | undefined;
         workerData?: any;
-        stdin?: boolean;
-        stdout?: boolean;
-        stderr?: boolean;
-        execArgv?: string[];
-        resourceLimits?: ResourceLimits;
+        stdin?: boolean | undefined;
+        stdout?: boolean | undefined;
+        stderr?: boolean | undefined;
+        execArgv?: string[] | undefined;
+        resourceLimits?: ResourceLimits | undefined;
         /**
          * Additional data to send in the first worker message.
          */
-        transferList?: TransferListItem[];
+        transferList?: TransferListItem[] | undefined;
         /**
          * @default true
          */
-        trackUnmanagedFds?: boolean;
+        trackUnmanagedFds?: boolean | undefined;
     }
 
     interface ResourceLimits {
         /**
          * The maximum size of a heap space for recently created objects.
          */
-        maxYoungGenerationSizeMb?: number;
+        maxYoungGenerationSizeMb?: number | undefined;
         /**
          * The maximum size of the main heap in MB.
          */
-        maxOldGenerationSizeMb?: number;
+        maxOldGenerationSizeMb?: number | undefined;
         /**
          * The size of a pre-allocated memory range used for generated code.
          */
-        codeRangeSizeMb?: number;
+        codeRangeSizeMb?: number | undefined;
         /**
          * The default maximum stack size for the thread. Small values may lead to unusable Worker instances.
          * @default 4
          */
-        stackSizeMb?: number;
+        stackSizeMb?: number | undefined;
     }
 
     class Worker extends EventEmitter {
@@ -125,7 +125,7 @@ declare module 'worker_threads' {
         readonly stdout: Readable;
         readonly stderr: Readable;
         readonly threadId: number;
-        readonly resourceLimits?: ResourceLimits;
+        readonly resourceLimits?: ResourceLimits | undefined;
         readonly performance: WorkerPerformance;
 
         /**
@@ -280,3 +280,7 @@ declare module 'worker_threads' {
      */
     function setEnvironmentData(key: Serializable, value: Serializable): void;
 }
+
+declare module 'node:worker_threads' {
+    export * from 'worker_threads';
+}

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

@@ -5,51 +5,51 @@ declare module 'zlib' {
         /**
          * @default constants.Z_NO_FLUSH
          */
-        flush?: number;
+        flush?: number | undefined;
         /**
          * @default constants.Z_FINISH
          */
-        finishFlush?: number;
+        finishFlush?: number | undefined;
         /**
          * @default 16*1024
          */
-        chunkSize?: number;
-        windowBits?: number;
-        level?: number; // compression only
-        memLevel?: number; // compression only
-        strategy?: number; // compression only
-        dictionary?: NodeJS.ArrayBufferView | ArrayBuffer; // deflate/inflate only, empty dictionary by default
-        info?: boolean;
-        maxOutputLength?: number;
+        chunkSize?: number | undefined;
+        windowBits?: number | undefined;
+        level?: number | undefined; // compression only
+        memLevel?: number | undefined; // compression only
+        strategy?: number | undefined; // compression only
+        dictionary?: NodeJS.ArrayBufferView | ArrayBuffer | undefined; // deflate/inflate only, empty dictionary by default
+        info?: boolean | undefined;
+        maxOutputLength?: number | undefined;
     }
 
     interface BrotliOptions {
         /**
          * @default constants.BROTLI_OPERATION_PROCESS
          */
-        flush?: number;
+        flush?: number | undefined;
         /**
          * @default constants.BROTLI_OPERATION_FINISH
          */
-        finishFlush?: number;
+        finishFlush?: number | undefined;
         /**
          * @default 16*1024
          */
-        chunkSize?: number;
+        chunkSize?: number | undefined;
         params?: {
             /**
              * Each key is a `constants.BROTLI_*` constant.
              */
             [key: number]: boolean | number;
-        };
-        maxOutputLength?: number;
+        } | undefined;
+        maxOutputLength?: number | undefined;
     }
 
     interface Zlib {
         /** @deprecated Use bytesWritten instead. */
         readonly bytesRead: number;
         readonly bytesWritten: number;
-        shell?: boolean | string;
+        shell?: boolean | string | undefined;
         close(callback?: () => void): void;
         flush(kind?: number, callback?: () => void): void;
         flush(callback?: () => void): void;
@@ -359,3 +359,7 @@ declare module 'zlib' {
     /** @deprecated */
     const Z_DEFLATED: number;
 }
+
+declare module 'node:zlib' {
+    export * from 'zlib';
+}

node v15.14/assert/strict.d.ts

@@ -1,4 +0,0 @@
-declare module 'assert/strict' {
-    import { strict } from 'assert';
-    export = strict;
-}

node v15.14/buffer.d.ts

@@ -1,112 +0,0 @@
-declare module 'buffer' {
-    import { BinaryLike } from 'crypto';
-
-    export const INSPECT_MAX_BYTES: number;
-    export const kMaxLength: number;
-    export const kStringMaxLength: number;
-    export const constants: {
-        MAX_LENGTH: number;
-        MAX_STRING_LENGTH: number;
-    };
-    const BuffType: typeof Buffer;
-
-    export type TranscodeEncoding = "ascii" | "utf8" | "utf16le" | "ucs2" | "latin1" | "binary";
-
-    export function transcode(source: Uint8Array, fromEnc: TranscodeEncoding, toEnc: TranscodeEncoding): Buffer;
-
-    export const SlowBuffer: {
-        /** @deprecated since v6.0.0, use `Buffer.allocUnsafeSlow()` */
-        new(size: number): Buffer;
-        prototype: Buffer;
-    };
-
-    export { BuffType as Buffer };
-
-    /**
-     * @experimental
-     */
-    export interface BlobOptions {
-        /**
-         * @default 'utf8'
-         */
-        encoding?: BufferEncoding;
-
-        /**
-         * The Blob content-type. The intent is for `type` to convey
-         * the MIME media type of the data, however no validation of the type format
-         * is performed.
-         */
-        type?: string;
-    }
-
-    /**
-     * @experimental
-     */
-    export class Blob {
-        /**
-         * Returns a promise that fulfills with an {ArrayBuffer} containing a copy of the `Blob` data.
-         */
-        readonly size: number;
-
-        /**
-         * The content-type of the `Blob`.
-         */
-        readonly type: string;
-
-        /**
-         * Creates a new `Blob` object containing a concatenation of the given sources.
-         *
-         * {ArrayBuffer}, {TypedArray}, {DataView}, and {Buffer} sources are copied into
-         * the 'Blob' and can therefore be safely modified after the 'Blob' is created.
-         *
-         * String sources are also copied into the `Blob`.
-         */
-        constructor(sources: Array<(BinaryLike | Blob)>, options?: BlobOptions);
-
-        arrayBuffer(): Promise<ArrayBuffer>;
-
-        /**
-         * @param start The starting index.
-         * @param end The ending index.
-         * @param type The content-type for the new `Blob`
-         */
-        slice(start?: number, end?: number, type?: string): Blob;
-
-        /**
-         * Returns a promise that resolves the contents of the `Blob` decoded as a UTF-8 string.
-         */
-        text(): Promise<string>;
-    }
-
-    /**
-     * Decodes a string of Base64-encoded data into bytes, and encodes those bytes into a string using Latin-1 (ISO-8859-1).
-     *
-     * This function is only provided for compatibility with legacy web platform APIs
-     * and should never be used in new code, because they use strings to represent
-     * binary data and predate the introduction of typed arrays in JavaScript.
-     * For code running using Node.js APIs, converting between base64-encoded strings
-     * and binary data should be performed using `Buffer.from(str, 'base64')` and
-     * `buf.toString('base64')`.
-     *
-     * @deprecated dom compatibility
-     */
-     export function atob(input: string): string;
-
-    /**
-     * Decodes a string into bytes using Latin-1 (ISO-8859), and encodes those bytes into a string using Base64.
-     *
-     * This function is only provided for compatibility with legacy web platform APIs
-     * and should never be used in new code, because they use strings to represent
-     * binary data and predate the introduction of typed arrays in JavaScript.
-     * For code running using Node.js APIs, converting between base64-encoded strings
-     * and binary data should be performed using `Buffer.from(str, 'base64')` and
-     * `buf.toString('base64')`.
-     *
-     * @deprecated dom compatibility
-     */
-     export function btoa(input: string): string;
-}
-
-declare module 'node:buffer' {
-    export * from 'buffer';
-}

node v15.14/domain.d.ts

@@ -1,24 +0,0 @@
-declare module 'domain' {
-    import EventEmitter = require('events');
-
-    global {
-        namespace NodeJS {
-            interface Domain extends EventEmitter {
-                run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
-                add(emitter: EventEmitter | Timer): void;
-                remove(emitter: EventEmitter | Timer): void;
-                bind<T extends Function>(cb: T): T;
-                intercept<T extends Function>(cb: T): T;
-            }
-        }
-    }
-
-    interface Domain extends NodeJS.Domain {}
-    class Domain extends EventEmitter {
-        members: Array<EventEmitter | NodeJS.Timer>;
-        enter(): void;
-        exit(): void;
-    }
-
-    function create(): Domain;
-}