@types/node 13.13.50 → 14.0.1

node v13.13/perf_hooks.d.ts → node/perf_hooks.d.ts

@@ -44,34 +44,64 @@ declare module 'perf_hooks' {
     interface PerformanceNodeTiming extends PerformanceEntry {
         /**
          * The high resolution millisecond timestamp at which the Node.js process completed bootstrap.
-         * If bootstrapping has not yet finished, the property has the value of -1.
          */
         readonly bootstrapComplete: number;
 
         /**
-         * The high resolution millisecond timestamp at which the Node.js process completed bootstrapping.
-         * If bootstrapping has not yet finished, the property has the value of -1.
+         * The high resolution millisecond timestamp at which cluster processing ended.
          */
-        readonly environment: number;
+        readonly clusterSetupEnd: number;
+
+        /**
+         * The high resolution millisecond timestamp at which cluster processing started.
+         */
+        readonly clusterSetupStart: number;
 
         /**
          * The high resolution millisecond timestamp at which the Node.js event loop exited.
-         * If the event loop has not yet exited, the property has the value of -1.
-         * It can only have a value of not -1 in a handler of the 'exit' event.
          */
         readonly loopExit: number;
 
         /**
          * The high resolution millisecond timestamp at which the Node.js event loop started.
-         * If the event loop has not yet started (e.g., in the first tick of the main script), the property has the value of -1.
          */
         readonly loopStart: number;
 
+        /**
+         * The high resolution millisecond timestamp at which main module load ended.
+         */
+        readonly moduleLoadEnd: number;
+
+        /**
+         * The high resolution millisecond timestamp at which main module load started.
+         */
+        readonly moduleLoadStart: number;
+
         /**
          * The high resolution millisecond timestamp at which the Node.js process was initialized.
          */
         readonly nodeStart: number;
 
+        /**
+         * The high resolution millisecond timestamp at which preload module load ended.
+         */
+        readonly preloadModuleLoadEnd: number;
+
+        /**
+         * The high resolution millisecond timestamp at which preload module load started.
+         */
+        readonly preloadModuleLoadStart: number;
+
+        /**
+         * The high resolution millisecond timestamp at which third_party_main processing ended.
+         */
+        readonly thirdPartyMainEnd: number;
+
+        /**
+         * The high resolution millisecond timestamp at which third_party_main processing started.
+         */
+        readonly thirdPartyMainStart: number;
+
         /**
          * The high resolution millisecond timestamp at which the V8 platform was initialized.
          */
@@ -79,6 +109,13 @@ declare module 'perf_hooks' {
     }
 
     interface Performance {
+        /**
+         * If name is not provided, removes all PerformanceFunction objects from the Performance Timeline.
+         * If name is provided, removes entries with name.
+         * @param name
+         */
+        clearFunctions(name?: string): void;
+
         /**
          * If name is not provided, removes all PerformanceMark objects from the Performance Timeline.
          * If name is provided, removes only the named mark.
@@ -86,6 +123,35 @@ declare module 'perf_hooks' {
          */
         clearMarks(name?: string): void;
 
+        /**
+         * If name is not provided, removes all PerformanceMeasure objects from the Performance Timeline.
+         * If name is provided, removes only objects whose performanceEntry.name matches name.
+         */
+        clearMeasures(name?: string): void;
+
+        /**
+         * Returns a list of all PerformanceEntry objects in chronological order with respect to performanceEntry.startTime.
+         * @return list of all PerformanceEntry objects
+         */
+        getEntries(): PerformanceEntry[];
+
+        /**
+         * Returns a list of all PerformanceEntry objects in chronological order with respect to performanceEntry.startTime
+         * whose performanceEntry.name is equal to name, and optionally, whose performanceEntry.entryType is equal to type.
+         * @param name
+         * @param type
+         * @return list of all PerformanceEntry objects
+         */
+        getEntriesByName(name: string, type?: EntryType): PerformanceEntry[];
+
+        /**
+         * Returns a list of all PerformanceEntry objects in chronological order with respect to performanceEntry.startTime
+         * whose performanceEntry.entryType is equal to type.
+         * @param type
+         * @return list of all PerformanceEntry objects
+         */
+        getEntriesByType(type: EntryType): PerformanceEntry[];
+
         /**
          * Creates a new PerformanceMark entry in the Performance Timeline.
          * A PerformanceMark is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'mark',
@@ -170,7 +236,7 @@ declare module 'perf_hooks' {
          * Property buffered defaults to false.
          * @param options
          */
-        observe(options: { entryTypes: ReadonlyArray<EntryType>; buffered?: boolean }): void;
+        observe(options: { entryTypes: EntryType[]; buffered?: boolean }): void;
     }
 
     namespace constants {

node/punycode.d.ts

@@ -0,0 +1,12 @@
+declare module "punycode" {
+    function decode(string: string): string;
+    function encode(string: string): string;
+    function toUnicode(domain: string): string;
+    function toASCII(domain: string): string;
+    const ucs2: ucs2;
+    interface ucs2 {
+        decode(string: string): number[];
+        encode(codePoints: number[]): string;
+    }
+    const version: string;
+}

node v13.13/repl.d.ts → node/repl.d.ts

@@ -135,22 +135,14 @@ declare module "repl" {
          * evaluation.
          */
         readonly context: Context;
-        /**
-         * Outdated alias for `input`.
-         */
-        readonly inputStream: NodeJS.ReadableStream;
-        /**
-         * Outdated alias for `output`.
-         */
-        readonly outputStream: NodeJS.WritableStream;
         /**
          * The `Readable` stream from which REPL input will be read.
          */
-        readonly input: NodeJS.ReadableStream;
+        readonly inputStream: NodeJS.ReadableStream;
         /**
          * The `Writable` stream to which REPL output will be written.
          */
-        readonly output: NodeJS.WritableStream;
+        readonly outputStream: NodeJS.WritableStream;
         /**
          * The commands registered via `replServer.defineCommand()`.
          */

node v13.13/stream.d.ts → node/stream.d.ts

@@ -1,7 +1,7 @@
-declare module 'stream' {
-    import EventEmitter = require('events');
+declare module "stream" {
+    import * as events from "events";
 
-    class internal extends EventEmitter {
+    class internal extends events.EventEmitter {
         pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
     }
 
@@ -12,7 +12,7 @@ declare module 'stream' {
 
         interface ReadableOptions {
             highWaterMark?: number;
-            encoding?: string;
+            encoding?: BufferEncoding;
             objectMode?: boolean;
             read?(this: Readable, size: number): void;
             destroy?(this: Readable, error: Error | null, callback: (error: Error | null) => void): void;
@@ -26,9 +26,6 @@ declare module 'stream' {
             static from(iterable: Iterable<any> | AsyncIterable<any>, options?: ReadableOptions): Readable;
 
             readable: boolean;
-            readonly readableEncoding: BufferEncoding | null;
-            readonly readableEnded: boolean;
-            readonly readableFlowing: boolean | null;
             readonly readableHighWaterMark: number;
             readonly readableLength: number;
             readonly readableObjectMode: boolean;
@@ -36,14 +33,14 @@ declare module 'stream' {
             constructor(opts?: ReadableOptions);
             _read(size: number): void;
             read(size?: number): any;
-            setEncoding(encoding: string): this;
+            setEncoding(encoding: BufferEncoding): this;
             pause(): this;
             resume(): this;
             isPaused(): boolean;
             unpipe(destination?: NodeJS.WritableStream): this;
             unshift(chunk: any, encoding?: BufferEncoding): void;
             wrap(oldStream: NodeJS.ReadableStream): this;
-            push(chunk: any, encoding?: string): boolean;
+            push(chunk: any, encoding?: BufferEncoding): boolean;
             _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
             destroy(error?: Error): void;
 
@@ -127,11 +124,11 @@ declare module 'stream' {
         interface WritableOptions {
             highWaterMark?: number;
             decodeStrings?: boolean;
-            defaultEncoding?: string;
+            defaultencoding?: BufferEncoding;
             objectMode?: boolean;
             emitClose?: boolean;
-            write?(this: Writable, chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
-            writev?(this: Writable, chunks: Array<{ chunk: any, encoding: string }>, callback: (error?: Error | null) => void): void;
+            write?(this: Writable, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+            writev?(this: Writable, chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
             destroy?(this: Writable, error: Error | null, callback: (error: Error | null) => void): void;
             final?(this: Writable, callback: (error?: Error | null) => void): void;
             autoDestroy?: boolean;
@@ -147,16 +144,16 @@ declare module 'stream' {
             readonly writableCorked: number;
             destroyed: boolean;
             constructor(opts?: WritableOptions);
-            _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
-            _writev?(chunks: Array<{ chunk: any, encoding: string }>, callback: (error?: Error | null) => void): void;
+            _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+            _writev?(chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
             _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
             _final(callback: (error?: Error | null) => void): void;
             write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean;
-            write(chunk: any, encoding: string, cb?: (error: Error | null | undefined) => void): boolean;
-            setDefaultEncoding(encoding: string): this;
+            write(chunk: any, encoding: BufferEncoding, cb?: (error: Error | null | undefined) => void): boolean;
+            setDefaultEncoding(encoding: BufferEncoding): this;
             end(cb?: () => void): void;
             end(chunk: any, cb?: () => void): void;
-            end(chunk: any, encoding: string, cb?: () => void): void;
+            end(chunk: any, encoding: BufferEncoding, cb?: () => void): void;
             cork(): void;
             uncork(): void;
             destroy(error?: Error): void;
@@ -236,8 +233,8 @@ declare module 'stream' {
             writableHighWaterMark?: number;
             writableCorked?: number;
             read?(this: Duplex, size: number): void;
-            write?(this: Duplex, chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
-            writev?(this: Duplex, chunks: Array<{ chunk: any, encoding: string }>, callback: (error?: Error | null) => void): void;
+            write?(this: Duplex, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+            writev?(this: Duplex, chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
             final?(this: Duplex, callback: (error?: Error | null) => void): void;
             destroy?(this: Duplex, error: Error | null, callback: (error: Error | null) => void): void;
         }
@@ -252,16 +249,16 @@ declare module 'stream' {
             readonly writableObjectMode: boolean;
             readonly writableCorked: number;
             constructor(opts?: DuplexOptions);
-            _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
-            _writev?(chunks: Array<{ chunk: any, encoding: string }>, callback: (error?: Error | null) => void): void;
+            _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+            _writev?(chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
             _destroy(error: Error | null, callback: (error: Error | null) => void): void;
             _final(callback: (error?: Error | null) => void): void;
-            write(chunk: any, encoding?: string, cb?: (error: Error | null | undefined) => void): boolean;
+            write(chunk: any, encoding?: BufferEncoding, cb?: (error: Error | null | undefined) => void): boolean;
             write(chunk: any, cb?: (error: Error | null | undefined) => void): boolean;
-            setDefaultEncoding(encoding: string): this;
+            setDefaultEncoding(encoding: BufferEncoding): this;
             end(cb?: () => void): void;
             end(chunk: any, cb?: () => void): void;
-            end(chunk: any, encoding?: string, cb?: () => void): void;
+            end(chunk: any, encoding?: BufferEncoding, cb?: () => void): void;
             cork(): void;
             uncork(): void;
         }
@@ -270,17 +267,17 @@ declare module 'stream' {
 
         interface TransformOptions extends DuplexOptions {
             read?(this: Transform, size: number): void;
-            write?(this: Transform, chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
-            writev?(this: Transform, chunks: Array<{ chunk: any, encoding: string }>, callback: (error?: Error | null) => void): void;
+            write?(this: Transform, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+            writev?(this: Transform, chunks: Array<{ chunk: any, encoding: BufferEncoding }>, callback: (error?: Error | null) => void): void;
             final?(this: Transform, callback: (error?: Error | null) => void): void;
             destroy?(this: Transform, error: Error | null, callback: (error: Error | null) => void): void;
-            transform?(this: Transform, chunk: any, encoding: string, callback: TransformCallback): void;
+            transform?(this: Transform, chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
             flush?(this: Transform, callback: TransformCallback): void;
         }
 
         class Transform extends Duplex {
             constructor(opts?: TransformOptions);
-            _transform(chunk: any, encoding: string, callback: TransformCallback): void;
+            _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
             _flush(callback: TransformCallback): void;
         }
 
@@ -314,10 +311,7 @@ declare module 'stream' {
             stream5: T,
             callback?: (err: NodeJS.ErrnoException | null) => void,
         ): T;
-        function pipeline(
-            streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,
-            callback?: (err: NodeJS.ErrnoException | null) => void,
-        ): NodeJS.WritableStream;
+        function pipeline(streams: Array<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>, callback?: (err: NodeJS.ErrnoException | null) => void): NodeJS.WritableStream;
         function pipeline(
             stream1: NodeJS.ReadableStream,
             stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
@@ -334,7 +328,7 @@ declare module 'stream' {
                 stream4: NodeJS.ReadWriteStream,
                 stream5: NodeJS.WritableStream,
             ): Promise<void>;
-            function __promisify__(streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>): Promise<void>;
+            function __promisify__(streams: Array<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>): Promise<void>;
             function __promisify__(
                 stream1: NodeJS.ReadableStream,
                 stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,

node v13.13/string_decoder.d.ts → node/string_decoder.d.ts

@@ -1,6 +1,6 @@
 declare module "string_decoder" {
     class StringDecoder {
-        constructor(encoding?: string);
+        constructor(encoding?: BufferEncoding);
         write(buffer: Buffer): string;
         end(buffer?: Buffer): string;
     }

node v13.13/tls.d.ts → node/tls.d.ts

@@ -436,7 +436,7 @@ declare module "tls" {
 
     interface PSKCallbackNegotation {
         psk: DataView | NodeJS.TypedArray;
-        identity: string;
+        identitty: string;
     }
 
     interface ConnectionOptions extends SecureContextOptions, CommonConnectionOptions {
@@ -729,7 +729,7 @@ declare module "tls" {
      * @deprecated
      */
     function createSecurePair(credentials?: SecureContext, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
-    function createSecureContext(options?: SecureContextOptions): SecureContext;
+    function createSecureContext(details: SecureContextOptions): SecureContext;
     function getCiphers(): string[];
 
     /**

node/ts3.2/base.d.ts

@@ -0,0 +1,22 @@
+// NOTE: These definitions support NodeJS and TypeScript 3.2.
+
+// NOTE: TypeScript version-specific augmentations can be found in the following paths:
+//          - ~/base.d.ts         - Shared definitions common to all TypeScript versions
+//          - ~/index.d.ts        - Definitions specific to TypeScript 2.1
+//          - ~/ts3.2/base.d.ts   - Definitions specific to TypeScript 3.2
+//          - ~/ts3.2/index.d.ts  - Definitions specific to TypeScript 3.2 with assert pulled in
+
+// Reference required types from the default lib:
+/// <reference lib="es2018" />
+/// <reference lib="esnext.asynciterable" />
+/// <reference lib="esnext.intl" />
+/// <reference lib="esnext.bigint" />
+
+// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../base.d.ts" />
+
+// TypeScript 3.2-specific augmentations:
+/// <reference path="fs.d.ts" />
+/// <reference path="util.d.ts" />
+/// <reference path="globals.d.ts" />

node/ts3.2/fs.d.ts

@@ -0,0 +1,33 @@
+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../fs.d.ts" />
+
+declare module 'fs' {
+    interface BigIntStats extends StatsBase<bigint> {
+    }
+
+    class BigIntStats {
+        atimeNs: bigint;
+        mtimeNs: bigint;
+        ctimeNs: bigint;
+        birthtimeNs: bigint;
+    }
+
+    interface BigIntOptions {
+        bigint: true;
+    }
+
+    interface StatOptions {
+        bigint: boolean;
+    }
+
+    function stat(path: PathLike, options: BigIntOptions, callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void): void;
+    function stat(path: PathLike, options: StatOptions, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
+
+    namespace stat {
+        function __promisify__(path: PathLike, options: BigIntOptions): Promise<BigIntStats>;
+        function __promisify__(path: PathLike, options: StatOptions): Promise<Stats | BigIntStats>;
+    }
+
+    function statSync(path: PathLike, options: BigIntOptions): BigIntStats;
+    function statSync(path: PathLike, options: StatOptions): Stats | BigIntStats;
+}

node/ts3.2/globals.d.ts

@@ -0,0 +1,19 @@
+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../globals.d.ts" />
+
+declare namespace NodeJS {
+    interface HRTime {
+        bigint(): bigint;
+    }
+}
+
+interface Buffer extends Uint8Array {
+    readBigUInt64BE(offset?: number): bigint;
+    readBigUInt64LE(offset?: number): bigint;
+    readBigInt64BE(offset?: number): bigint;
+    readBigInt64LE(offset?: number): bigint;
+    writeBigInt64BE(value: bigint, offset?: number): number;
+    writeBigInt64LE(value: bigint, offset?: number): number;
+    writeBigUInt64BE(value: bigint, offset?: number): number;
+    writeBigUInt64LE(value: bigint, offset?: number): number;
+}

node/ts3.2/index.d.ts

@@ -0,0 +1,8 @@
+// NOTE: These definitions support NodeJS and TypeScript 3.2.
+// This is requried to enable typing assert in ts3.7 without causing errors
+// Typically type modifiations should be made in base.d.ts instead of here
+
+/// <reference path="base.d.ts" />
+
+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../assert.d.ts" />

node/ts3.2/util.d.ts

@@ -0,0 +1,9 @@
+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../util.d.ts" />
+
+declare module "util" {
+    namespace types {
+        function isBigInt64Array(value: any): value is BigInt64Array;
+        function isBigUint64Array(value: any): value is BigUint64Array;
+    }
+}

node/ts3.5/base.d.ts

@@ -0,0 +1,20 @@
+// NOTE: These definitions support NodeJS and TypeScript 3.5.
+
+// NOTE: TypeScript version-specific augmentations can be found in the following paths:
+//          - ~/base.d.ts         - Shared definitions common to all TypeScript versions
+//          - ~/index.d.ts        - Definitions specific to TypeScript 2.1
+//          - ~/ts3.5/base.d.ts   - Definitions specific to TypeScript 3.5
+//          - ~/ts3.5/index.d.ts  - Definitions specific to TypeScript 3.5 with assert pulled in
+
+// Reference required types from the default lib:
+/// <reference lib="es2018" />
+/// <reference lib="esnext.asynciterable" />
+/// <reference lib="esnext.intl" />
+/// <reference lib="esnext.bigint" />
+
+// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../ts3.2/base.d.ts" />
+
+// TypeScript 3.5-specific augmentations:
+/// <reference path="wasi.d.ts" />

node v13.13/ts3.6/index.d.ts → node/ts3.5/index.d.ts

@@ -1,6 +1,8 @@
 // NOTE: These definitions support NodeJS and TypeScript 3.5.
-// This is required to enable typing assert in ts3.7 without causing errors
+// This is requried to enable typing assert in ts3.7 without causing errors
 // Typically type modifiations should be made in base.d.ts instead of here
 
 /// <reference path="base.d.ts" />
-/// <reference path="assert.d.ts" />
+
+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../assert.d.ts" />

node v13.13/wasi.d.ts → node/ts3.5/wasi.d.ts

@@ -6,13 +6,11 @@ declare module 'wasi' {
          * WASI command itself.
          */
         args?: string[];
-
         /**
          * An object similar to `process.env` that the WebAssembly
          * application will see as its environment.
          */
         env?: object;
-
         /**
          * This object represents the WebAssembly application's
          * sandbox directory structure. The string keys of `preopens` are treated as
@@ -44,10 +42,9 @@ declare module 'wasi' {
          * `memory`. If `instance` does not have a `memory` export an exception is thrown.
          */
         start(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
-
         /**
          * Is an object that implements the WASI system call API. This object
-         * should be passed as the `wasi_snapshot_preview1` import during the instantiation of a
+         * should be passed as the `wasi_unstable` import during the instantiation of a
          * [`WebAssembly.Instance`][].
          */
         readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types

node v13.13/assert.d.ts → node/ts3.7/assert.d.ts

@@ -1,4 +1,4 @@
-declare module 'assert' {
+declare module "assert" {
     function assert(value: any, message?: string | Error): asserts value;
     namespace assert {
         class AssertionError implements Error {
@@ -11,27 +11,16 @@ declare module 'assert' {
             code: 'ERR_ASSERTION';
 
             constructor(options?: {
-                message?: string;
-                actual?: any;
-                expected?: any;
-                operator?: string;
-                // tslint:disable-next-line:ban-types
-                stackStartFn?: Function;
+                message?: string; actual?: any; expected?: any;
+                operator?: string; stackStartFn?: Function
             });
         }
 
-        type AssertPredicate = RegExp | (new () => object) | ((thrown: any) => boolean) | object | Error;
+        type AssertPredicate = RegExp | (new() => object) | ((thrown: any) => 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,
-            message?: string | Error,
-            operator?: string,
-            // tslint:disable-next-line:ban-types
-            stackStartFn?: Function,
-        ): never;
+        function fail(actual: any, expected: any, message?: string | Error, operator?: string, stackStartFn?: Function): never;
         function ok(value: any, message?: string | Error): asserts value;
         /** @deprecated since v9.9.0 - use strictEqual() instead. */
         function equal(actual: any, expected: any, message?: string | Error): void;
@@ -49,53 +38,19 @@ declare module 'assert' {
         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 doesNotThrow(block: () => any, error: RegExp | Function, message?: string | Error): void;
 
         function ifError(value: any): asserts value is null | undefined;
 
         function rejects(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
-        function rejects(
-            block: (() => Promise<any>) | Promise<any>,
-            error: AssertPredicate,
-            message?: string | Error,
-        ): Promise<void>;
+        function rejects(block: (() => Promise<any>) | Promise<any>, error: AssertPredicate, message?: string | Error): Promise<void>;
         function doesNotReject(block: (() => Promise<any>) | Promise<any>, message?: string | Error): Promise<void>;
-        function doesNotReject(
-            block: (() => Promise<any>) | Promise<any>,
-            error: AssertPredicate,
-            message?: string | Error,
-        ): Promise<void>;
+        function doesNotReject(block: (() => Promise<any>) | Promise<any>, error: RegExp | Function, message?: string | Error): Promise<void>;
 
         function match(value: string, regExp: RegExp, message?: string | Error): void;
         function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
 
-        const strict: Omit<
-            typeof assert,
-            | 'equal'
-            | 'notEqual'
-            | 'deepEqual'
-            | 'notDeepEqual'
-            | 'ok'
-            | 'strictEqual'
-            | 'deepStrictEqual'
-            | 'ifError'
-            | 'strict'
-        > & {
-            (value: any, message?: string | Error): asserts value;
-            equal: typeof strictEqual;
-            notEqual: typeof notStrictEqual;
-            deepEqual: typeof deepStrictEqual;
-            notDeepEqual: typeof notDeepStrictEqual;
-
-            // Mapped types and assertion functions are incompatible?
-            // TS2775: Assertions require every name in the call target
-            // to be declared with an explicit type annotation.
-            ok: typeof ok;
-            strictEqual: typeof strictEqual;
-            deepStrictEqual: typeof deepStrictEqual;
-            ifError: typeof ifError;
-            strict: typeof strict;
-        };
+        const strict: typeof assert;
     }
 
     export = assert;

node v13.13/base.d.ts → node/ts3.7/base.d.ts

@@ -13,7 +13,8 @@
 /// <reference lib="esnext.bigint" />
 
 // Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
-/// <reference path="ts3.6/base.d.ts" />
+// tslint:disable-next-line:no-bad-reference
+/// <reference path="../ts3.5/base.d.ts" />
 
 // TypeScript 3.7-specific augmentations:
 /// <reference path="assert.d.ts" />

node/ts3.7/index.d.ts

@@ -0,0 +1,5 @@
+// NOTE: These definitions support NodeJS and TypeScript 3.7.
+// This isn't strictly needed since 3.7 has the assert module, but this way we're consistent.
+// Typically type modificatons should be made in base.d.ts instead of here
+
+/// <reference path="base.d.ts" />