@types/node 15.3.1 → 15.9.0

node/readline.d.ts

@@ -1,5 +1,5 @@
 declare module 'readline' {
-    import EventEmitter = require('events');
+    import { Abortable, EventEmitter } from 'events';
 
     interface Key {
         sequence?: string;
@@ -42,6 +42,7 @@ declare module 'readline' {
         setPrompt(prompt: string): void;
         prompt(preserveCursor?: boolean): void;
         question(query: string, callback: (answer: string) => void): void;
+        question(query: string, options: Abortable, callback: (answer: string) => void): void;
         pause(): this;
         resume(): this;
         close(): void;
@@ -63,8 +64,8 @@ declare module 'readline' {
          * 5. SIGCONT
          * 6. SIGINT
          * 7. SIGTSTP
+         * 8. history
          */
-
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: "close", listener: () => void): this;
         addListener(event: "line", listener: (input: string) => void): this;
@@ -73,6 +74,7 @@ declare module 'readline' {
         addListener(event: "SIGCONT", listener: () => void): this;
         addListener(event: "SIGINT", listener: () => void): this;
         addListener(event: "SIGTSTP", listener: () => void): this;
+        addListener(event: "history", listener: (history: string[]) => void): this;
 
         emit(event: string | symbol, ...args: any[]): boolean;
         emit(event: "close"): boolean;
@@ -82,6 +84,7 @@ declare module 'readline' {
         emit(event: "SIGCONT"): boolean;
         emit(event: "SIGINT"): boolean;
         emit(event: "SIGTSTP"): boolean;
+        emit(event: "history", history: string[]): boolean;
 
         on(event: string, listener: (...args: any[]) => void): this;
         on(event: "close", listener: () => void): this;
@@ -91,6 +94,7 @@ declare module 'readline' {
         on(event: "SIGCONT", listener: () => void): this;
         on(event: "SIGINT", listener: () => void): this;
         on(event: "SIGTSTP", listener: () => void): this;
+        on(event: "history", listener: (history: string[]) => void): this;
 
         once(event: string, listener: (...args: any[]) => void): this;
         once(event: "close", listener: () => void): this;
@@ -100,6 +104,7 @@ declare module 'readline' {
         once(event: "SIGCONT", listener: () => void): this;
         once(event: "SIGINT", listener: () => void): this;
         once(event: "SIGTSTP", listener: () => void): this;
+        once(event: "history", listener: (history: string[]) => void): this;
 
         prependListener(event: string, listener: (...args: any[]) => void): this;
         prependListener(event: "close", listener: () => void): this;
@@ -109,6 +114,7 @@ declare module 'readline' {
         prependListener(event: "SIGCONT", listener: () => void): this;
         prependListener(event: "SIGINT", listener: () => void): this;
         prependListener(event: "SIGTSTP", listener: () => void): this;
+        prependListener(event: "history", listener: (history: string[]) => void): this;
 
         prependOnceListener(event: string, listener: (...args: any[]) => void): this;
         prependOnceListener(event: "close", listener: () => void): this;
@@ -118,6 +124,8 @@ declare module 'readline' {
         prependOnceListener(event: "SIGCONT", listener: () => void): this;
         prependOnceListener(event: "SIGINT", listener: () => void): this;
         prependOnceListener(event: "SIGTSTP", listener: () => void): this;
+        prependOnceListener(event: "history", listener: (history: string[]) => void): this;
+
         [Symbol.asyncIterator](): AsyncIterableIterator<string>;
     }
 
@@ -133,9 +141,22 @@ declare module 'readline' {
         output?: NodeJS.WritableStream;
         completer?: Completer | AsyncCompleter;
         terminal?: boolean;
+        /**
+         *  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;
+        /**
+         * 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;

node/stream.d.ts

@@ -1,5 +1,5 @@
 declare module 'stream' {
-    import EventEmitter = require('events');
+    import { EventEmitter, Abortable } from 'events';
     import * as streamPromises from "stream/promises";
 
     class internal extends EventEmitter {
@@ -11,16 +11,20 @@ declare module 'stream' {
             constructor(opts?: ReadableOptions);
         }
 
-        interface ReadableOptions {
+        interface StreamOptions<T extends Stream> extends Abortable {
+            emitClose?: boolean;
             highWaterMark?: number;
-            encoding?: BufferEncoding;
             objectMode?: boolean;
-            read?(this: Readable, size: number): void;
-            construct?(this: Readable, callback: (error?: Error | null) => void): void;
-            destroy?(this: Readable, error: Error | null, callback: (error: Error | null) => void): void;
+            construct?(this: T, callback: (error?: Error | null) => void): void;
+            destroy?(this: T, error: Error | null, callback: (error: Error | null) => void): void;
             autoDestroy?: boolean;
         }
 
+        interface ReadableOptions extends StreamOptions<Readable> {
+            encoding?: BufferEncoding;
+            read?(this: Readable, size: number): void;
+        }
+
         class Readable extends Stream implements NodeJS.ReadableStream {
             /**
              * A utility method for creating Readable Streams out of iterators.
@@ -127,18 +131,12 @@ declare module 'stream' {
             [Symbol.asyncIterator](): AsyncIterableIterator<any>;
         }
 
-        interface WritableOptions {
-            highWaterMark?: number;
+        interface WritableOptions extends StreamOptions<Writable> {
             decodeStrings?: boolean;
             defaultEncoding?: BufferEncoding;
-            objectMode?: boolean;
-            emitClose?: boolean;
-            construct?(this: Writable, 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;
         }
 
         class Writable extends Stream implements NodeJS.WritableStream {
@@ -293,6 +291,16 @@ declare module 'stream' {
 
         class PassThrough extends Transform { }
 
+        /**
+         * Attaches an AbortSignal to a readable or writeable stream. This lets code
+         * control stream destruction using an `AbortController`.
+         *
+         * Calling `abort` on the `AbortController` corresponding to the passed
+         * `AbortSignal` will behave the same way as calling `.destroy(new AbortError())`
+         * on the stream.
+         */
+        function addAbortSignal<T extends Stream>(signal: AbortSignal, stream: T): T;
+
         interface FinishedOptions {
             error?: boolean;
             readable?: boolean;

node/timers/promises.d.ts

@@ -3,11 +3,19 @@ declare module 'timers/promises' {
 
     /**
      * Returns a promise that resolves after the specified delay in milliseconds.
+     * @param delay defaults to 1
      */
-    function setTimeout<T>(delay: number, value?: T, options?: TimerOptions): Promise<T>;
+    function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;
 
     /**
      * Returns a promise that resolves in the next tick.
      */
-    function setImmediate<T>(value: T, options?: TimerOptions): Promise<T>;
+    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>;
 }

node/timers.d.ts

@@ -1,16 +1,13 @@
 declare module 'timers' {
-    interface TimerOptions {
+    import { Abortable } from 'events';
+
+    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;
-
-        /**
-         * An optional `AbortSignal` that can be used to cancel the scheduled `Timeout`.
-         */
-        signal?: AbortSignal;
     }
 
     function setTimeout(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout;

node/tls.d.ts

@@ -1,4 +1,5 @@
 declare module 'tls' {
+    import { X509Certificate } from 'crypto';
     import * as net from 'net';
 
     const CLIENT_RENEG_LIMIT: number;
@@ -295,6 +296,16 @@ declare module 'tls' {
          */
         enableTrace(): void;
 
+        /**
+         * If there is no peer certificate, or the socket has been destroyed, `undefined` will be returned.
+         */
+        getPeerX509Certificate(): X509Certificate | undefined;
+
+        /**
+         * If there is no local certificate, or the socket has been destroyed, `undefined` will be returned.
+         */
+        getX509Certificate(): X509Certificate | undefined;
+
         /**
          * @param length number of bytes to retrieve from keying material
          * @param label an application specific label, typically this will be a value from the
@@ -553,6 +564,9 @@ declare module 'tls' {
         prependOnceListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
     }
 
+    /**
+     * @deprecated since v0.11.3 Use `tls.TLSSocket` instead.
+     */
     interface SecurePair {
         encrypted: TLSSocket;
         cleartext: TLSSocket;

node/util/types.d.ts

@@ -51,7 +51,3 @@ declare module 'util/types' {
     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/wasi.d.ts

@@ -58,7 +58,7 @@ declare module 'wasi' {
          * invoke the `__wasi_unstable_reactor_start()` export. If neither of those exports
          * is present on `instance`, then `start()` does nothing.
          *
-         * `start()` requires that `instance` exports a [`WebAssembly.Memory`][] named
+         * `start()` requires that `instance` exports a `WebAssembly.Memory` named
          * `memory`. If `instance` does not have a `memory` export an exception is thrown.
          *
          * If `start()` is called more than once, an exception is thrown.
@@ -69,7 +69,7 @@ declare module 'wasi' {
          * Attempt to initialize `instance` as a WASI reactor by invoking its `_initialize()` export, if it is present.
          * If `instance` contains a `_start()` export, then an exception is thrown.
          *
-         * `start()` requires that `instance` exports a [`WebAssembly.Memory`][] named
+         * `start()` requires that `instance` exports a `WebAssembly.Memory` named
          * `memory`. If `instance` does not have a `memory` export an exception is thrown.
          *
          * If `initialize()` is called more than once, an exception is thrown.
@@ -79,7 +79,7 @@ declare module 'wasi' {
         /**
          * 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
-         * [`WebAssembly.Instance`][].
+         * `WebAssembly.Instance`.
          */
         readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
     }

node/worker_threads.d.ts

@@ -1,10 +1,12 @@
 declare module 'worker_threads' {
+    import { Blob } from 'node:buffer';
     import { Context } from 'vm';
-    import EventEmitter = require('events');
+    import { EventEmitter } from 'events';
+    import { EventLoopUtilityFunction } from 'perf_hooks';
+    import { FileHandle } from 'fs/promises';
     import { Readable, Writable } from 'stream';
     import { URL } from 'url';
-    import { FileHandle } from 'fs/promises';
-    import { EventLoopUtilityFunction } from 'perf_hooks';
+    import { X509Certificate } from 'crypto';
 
     const isMainThread: boolean;
     const parentPort: null | MessagePort;
@@ -22,7 +24,7 @@ declare module 'worker_threads' {
         eventLoopUtilization: EventLoopUtilityFunction;
     }
 
-    type TransferListItem = ArrayBuffer | MessagePort | FileHandle;
+    type TransferListItem = ArrayBuffer | MessagePort | FileHandle | X509Certificate | Blob;
 
     class MessagePort extends EventEmitter {
         close(): void;
@@ -144,11 +146,11 @@ declare module 'worker_threads' {
 
         /**
          * Returns a readable stream for a V8 snapshot of the current state of the Worker.
-         * See [`v8.getHeapSnapshot()`][] for more details.
+         * See `v8.getHeapSnapshot()` for more details.
          *
          * If the Worker thread is no longer running, which may occur before the
-         * [`'exit'` event][] is emitted, the returned `Promise` will be rejected
-         * immediately with an [`ERR_WORKER_NOT_RUNNING`][] error
+         * `'exit'` event is emitted, the returned `Promise` will be rejected
+         * immediately with an `ERR_WORKER_NOT_RUNNING` error
          */
         getHeapSnapshot(): Promise<Readable>;
 
@@ -209,6 +211,22 @@ declare module 'worker_threads' {
         off(event: string | symbol, listener: (...args: any[]) => void): this;
     }
 
+    interface BroadcastChannel extends NodeJS.RefCounted {}
+
+    /**
+     * See https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel
+     */
+    class BroadcastChannel {
+        readonly name: string;
+        onmessage: (message: unknown) => void;
+        onmessageerror: (message: unknown) => void;
+
+        constructor(name: string);
+
+        close(): void;
+        postMessage(message: unknown): void;
+    }
+
     /**
      * Mark an object as not transferable.
      * If `object` occurs in the transfer list of a `port.postMessage()` call, it will be ignored.