@types/node 15.14.7 → 16.0.1

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

@@ -2,11 +2,11 @@ declare module 'readline' {
     import { Abortable, EventEmitter } from 'events';
 
     interface Key {
-        sequence?: string;
-        name?: string;
-        ctrl?: boolean;
-        meta?: boolean;
-        shift?: boolean;
+        sequence?: string | undefined;
+        name?: string | undefined;
+        ctrl?: boolean | undefined;
+        meta?: boolean | undefined;
+        shift?: boolean | undefined;
     }
 
     class Interface extends EventEmitter {
@@ -132,34 +132,34 @@ declare module 'readline' {
     type ReadLine = Interface; // type forwarded for backwards compatibility
 
     type Completer = (line: string) => CompleterResult;
-    type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => any;
+    type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => void;
 
     type CompleterResult = [string[], string];
 
     interface ReadLineOptions {
         input: NodeJS.ReadableStream;
-        output?: NodeJS.WritableStream;
-        completer?: Completer | AsyncCompleter;
-        terminal?: boolean;
+        output?: NodeJS.WritableStream | undefined;
+        completer?: Completer | AsyncCompleter | undefined;
+        terminal?: boolean | undefined;
         /**
          *  Initial list of history lines. This option makes sense
          * only if `terminal` is set to `true` by the user or by an internal `output`
          * check, otherwise the history caching mechanism is not initialized at all.
          * @default []
          */
-        history?: string[];
-        historySize?: number;
-        prompt?: string;
-        crlfDelay?: number;
+        history?: string[] | undefined;
+        historySize?: number | undefined;
+        prompt?: string | undefined;
+        crlfDelay?: number | undefined;
         /**
          * If `true`, when a new input line added
          * to the history list duplicates an older one, this removes the older line
          * from the list.
          * @default false
          */
-        removeHistoryDuplicates?: boolean;
-        escapeCodeTimeout?: number;
-        tabSize?: number;
+        removeHistoryDuplicates?: boolean | undefined;
+        escapeCodeTimeout?: number | undefined;
+        tabSize?: number | undefined;
     }
 
     function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
@@ -190,3 +190,7 @@ declare module 'readline' {
      */
     function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
 }
+
+declare module 'node:readline' {
+    export * from 'readline';
+}

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

@@ -8,24 +8,24 @@ declare module 'repl' {
          * The input prompt to display.
          * @default "> "
          */
-        prompt?: string;
+        prompt?: string | undefined;
         /**
          * The `Readable` stream from which REPL input will be read.
          * @default process.stdin
          */
-        input?: NodeJS.ReadableStream;
+        input?: NodeJS.ReadableStream | undefined;
         /**
          * The `Writable` stream to which REPL output will be written.
          * @default process.stdout
          */
-        output?: NodeJS.WritableStream;
+        output?: NodeJS.WritableStream | undefined;
         /**
          * If `true`, specifies that the output should be treated as a TTY terminal, and have
          * ANSI/VT100 escape codes written to it.
          * Default: checking the value of the `isTTY` property on the output stream upon
          * instantiation.
          */
-        terminal?: boolean;
+        terminal?: boolean | undefined;
         /**
          * The function to be used when evaluating each given line of input.
          * Default: an async wrapper for the JavaScript `eval()` function. An `eval` function can
@@ -35,45 +35,45 @@ declare module 'repl' {
          * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_default_evaluation
          * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_custom_evaluation_functions
          */
-        eval?: REPLEval;
+        eval?: REPLEval | undefined;
         /**
          * Defines if the repl prints output previews or not.
          * @default `true` Always `false` in case `terminal` is falsy.
          */
-        preview?: boolean;
+        preview?: boolean | undefined;
         /**
          * If `true`, specifies that the default `writer` function should include ANSI color
          * styling to REPL output. If a custom `writer` function is provided then this has no
          * effect.
          * Default: the REPL instance's `terminal` value.
          */
-        useColors?: boolean;
+        useColors?: boolean | undefined;
         /**
          * If `true`, specifies that the default evaluation function will use the JavaScript
          * `global` as the context as opposed to creating a new separate context for the REPL
          * instance. The node CLI REPL sets this value to `true`.
          * Default: `false`.
          */
-        useGlobal?: boolean;
+        useGlobal?: boolean | undefined;
         /**
          * If `true`, specifies that the default writer will not output the return value of a
          * command if it evaluates to `undefined`.
          * Default: `false`.
          */
-        ignoreUndefined?: boolean;
+        ignoreUndefined?: boolean | undefined;
         /**
          * The function to invoke to format the output of each command before writing to `output`.
          * Default: a wrapper for `util.inspect`.
          *
          * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_customizing_repl_output
          */
-        writer?: REPLWriter;
+        writer?: REPLWriter | undefined;
         /**
          * An optional function used for custom Tab auto completion.
          *
          * @see https://nodejs.org/dist/latest-v11.x/docs/api/readline.html#readline_use_of_the_completer_function
          */
-        completer?: Completer | AsyncCompleter;
+        completer?: Completer | AsyncCompleter | undefined;
         /**
          * A flag that specifies whether the default evaluator executes all JavaScript commands in
          * strict mode or default (sloppy) mode.
@@ -82,13 +82,13 @@ declare module 'repl' {
          * - `repl.REPL_MODE_STRICT` - evaluates expressions in strict mode. This is equivalent to
          *   prefacing every repl statement with `'use strict'`.
          */
-        replMode?: typeof REPL_MODE_SLOPPY | typeof REPL_MODE_STRICT;
+        replMode?: typeof REPL_MODE_SLOPPY | typeof REPL_MODE_STRICT | undefined;
         /**
          * Stop evaluating the current piece of code when `SIGINT` is received, i.e. `Ctrl+C` is
          * pressed. This cannot be used together with a custom `eval` function.
          * Default: `false`.
          */
-        breakEvalOnSigint?: boolean;
+        breakEvalOnSigint?: boolean | undefined;
     }
 
     type REPLEval = (this: REPLServer, evalCmd: string, context: Context, file: string, cb: (err: Error | null, result: any) => void) => void;
@@ -106,7 +106,7 @@ declare module 'repl' {
         /**
          * Help text to be displayed when `.help` is entered.
          */
-        help?: string;
+        help?: string | undefined;
         /**
          * The function to execute, optionally accepting a single string argument.
          */
@@ -393,3 +393,7 @@ declare module 'repl' {
         constructor(err: Error);
     }
 }
+
+declare module 'node:repl' {
+    export * from 'repl';
+}

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

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

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

@@ -3,7 +3,7 @@ declare module 'stream' {
     import * as streamPromises from "stream/promises";
 
     class internal extends EventEmitter {
-        pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
+        pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean | undefined; }): T;
     }
 
     namespace internal {
@@ -12,16 +12,16 @@ declare module 'stream' {
         }
 
         interface StreamOptions<T extends Stream> extends Abortable {
-            emitClose?: boolean;
-            highWaterMark?: number;
-            objectMode?: boolean;
+            emitClose?: boolean | undefined;
+            highWaterMark?: number | undefined;
+            objectMode?: boolean | undefined;
             construct?(this: T, callback: (error?: Error | null) => void): void;
             destroy?(this: T, error: Error | null, callback: (error: Error | null) => void): void;
-            autoDestroy?: boolean;
+            autoDestroy?: boolean | undefined;
         }
 
         interface ReadableOptions extends StreamOptions<Readable> {
-            encoding?: BufferEncoding;
+            encoding?: BufferEncoding | undefined;
             read?(this: Readable, size: number): void;
         }
 
@@ -132,8 +132,8 @@ declare module 'stream' {
         }
 
         interface WritableOptions extends StreamOptions<Writable> {
-            decodeStrings?: boolean;
-            defaultEncoding?: BufferEncoding;
+            decodeStrings?: boolean | undefined;
+            defaultEncoding?: BufferEncoding | undefined;
             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;
             final?(this: Writable, callback: (error?: Error | null) => void): void;
@@ -232,12 +232,12 @@ declare module 'stream' {
         }
 
         interface DuplexOptions extends ReadableOptions, WritableOptions {
-            allowHalfOpen?: boolean;
-            readableObjectMode?: boolean;
-            writableObjectMode?: boolean;
-            readableHighWaterMark?: number;
-            writableHighWaterMark?: number;
-            writableCorked?: number;
+            allowHalfOpen?: boolean | undefined;
+            readableObjectMode?: boolean | undefined;
+            writableObjectMode?: boolean | undefined;
+            readableHighWaterMark?: number | undefined;
+            writableHighWaterMark?: number | undefined;
+            writableCorked?: number | undefined;
             construct?(this: Duplex, callback: (error?: Error | null) => void): void;
             read?(this: Duplex, size: number): void;
             write?(this: Duplex, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
@@ -302,9 +302,9 @@ declare module 'stream' {
         function addAbortSignal<T extends Stream>(signal: AbortSignal, stream: T): T;
 
         interface FinishedOptions extends Abortable {
-            error?: boolean;
-            readable?: boolean;
-            writable?: boolean;
+            error?: boolean | undefined;
+            readable?: boolean | undefined;
+            writable?: boolean | undefined;
         }
         function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, options: FinishedOptions, callback: (err?: NodeJS.ErrnoException | null) => void): () => void;
         function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, callback: (err?: NodeJS.ErrnoException | null) => void): () => void;
@@ -469,3 +469,8 @@ declare module 'stream' {
 
     export = internal;
 }
+
+declare module 'node:stream' {
+    import stream = require('stream');
+    export = stream;
+}

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

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

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

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

node/timers.d.ts

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