aws-delivlib 14.4.2 → 14.4.3

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/readline.d.ts

@@ -1,5 +1,5 @@
 /**
- * The `readline` module provides an interface for reading data from a `Readable` stream (such as `process.stdin`) one line at a time.
+ * The `node:readline` module provides an interface for reading data from a `Readable` stream (such as `process.stdin`) one line at a time.
  *
  * To use the promise-based APIs:
  *
@@ -13,11 +13,11 @@
  * import * as readline from 'node:readline';
  * ```
  *
- * The following simple example illustrates the basic use of the `readline` module.
+ * The following simple example illustrates the basic use of the `node:readline`module.
  *
  * ```js
  * import * as readline from 'node:readline/promises';
- * import { stdin as input, stdout as output } from 'process';
+ * import { stdin as input, stdout as output } from 'node:process';
  *
  * const rl = readline.createInterface({ input, output });
  *
@@ -30,11 +30,13 @@
  *
  * Once this code is invoked, the Node.js application will not terminate until the`readline.Interface` is closed because the interface waits for data to be
  * received on the `input` stream.
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/readline.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/readline.js)
  */
 declare module 'readline' {
     import { Abortable, EventEmitter } from 'node:events';
-    interface Key {
+    import * as promises from 'node:readline/promises';
+    export { promises };
+    export interface Key {
         sequence?: string | undefined;
         name?: string | undefined;
         ctrl?: boolean | undefined;
@@ -48,7 +50,7 @@ declare module 'readline' {
      * and is read from, the `input` stream.
      * @since v0.1.104
      */
-    class Interface extends EventEmitter {
+    export class Interface extends EventEmitter {
         readonly terminal: boolean;
         /**
          * The current input data being processed by node.
@@ -71,7 +73,7 @@ declare module 'readline' {
          * const showResults = debounce(() => {
          *   console.log(
          *     '\n',
-         *     values.filter((val) => val.startsWith(rl.line)).join(' ')
+         *     values.filter((val) => val.startsWith(rl.line)).join(' '),
          *   );
          * }, 300);
          * process.stdin.on('keypress', (c, k) => {
@@ -97,7 +99,7 @@ declare module 'readline' {
          * > Instances of the `readline.Interface` class are constructed using the
          * > `readline.createInterface()` method.
          *
-         * @see https://nodejs.org/dist/latest-v10.x/docs/api/readline.html#readline_class_interface
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/readline.html#class-interfaceconstructor
          */
         protected constructor(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean);
         /**
@@ -106,12 +108,12 @@ declare module 'readline' {
          * > Instances of the `readline.Interface` class are constructed using the
          * > `readline.createInterface()` method.
          *
-         * @see https://nodejs.org/dist/latest-v10.x/docs/api/readline.html#readline_class_interface
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/readline.html#class-interfaceconstructor
          */
         protected constructor(options: ReadLineOptions);
         /**
          * The `rl.getPrompt()` method returns the current prompt used by `rl.prompt()`.
-         * @since v15.3.0
+         * @since v15.3.0, v14.17.0
          * @return the current prompt string
          */
         getPrompt(): string;
@@ -121,13 +123,13 @@ declare module 'readline' {
          */
         setPrompt(prompt: string): void;
         /**
-         * The `rl.prompt()` method writes the `readline.Interface` instances configured`prompt` to a new line in `output` in order to provide a user with a new
+         * The `rl.prompt()` method writes the `Interface` instances configured`prompt` to a new line in `output` in order to provide a user with a new
          * location at which to provide input.
          *
          * When called, `rl.prompt()` will resume the `input` stream if it has been
          * paused.
          *
-         * If the `readline.Interface` was created with `output` set to `null` or`undefined` the prompt is not written.
+         * If the `Interface` was created with `output` set to `null` or`undefined` the prompt is not written.
          * @since v0.1.98
          * @param preserveCursor If `true`, prevents the cursor placement from being reset to `0`.
          */
@@ -139,12 +141,14 @@ declare module 'readline' {
          * When called, `rl.question()` will resume the `input` stream if it has been
          * paused.
          *
-         * If the `readline.Interface` was created with `output` set to `null` or`undefined` the `query` is not written.
+         * If the `Interface` was created with `output` set to `null` or`undefined` the `query` is not written.
          *
          * The `callback` function passed to `rl.question()` does not follow the typical
          * pattern of accepting an `Error` object or `null` as the first argument.
          * The `callback` is called with the provided answer as the only argument.
          *
+         * An error will be thrown if calling `rl.question()` after `rl.close()`.
+         *
          * Example usage:
          *
          * ```js
@@ -169,25 +173,6 @@ declare module 'readline' {
          *
          * setTimeout(() => ac.abort(), 10000);
          * ```
-         *
-         * If this method is invoked as it's util.promisify()ed version, it returns a
-         * Promise that fulfills with the answer. If the question is canceled using
-         * an `AbortController` it will reject with an `AbortError`.
-         *
-         * ```js
-         * const util = require('util');
-         * const question = util.promisify(rl.question).bind(rl);
-         *
-         * async function questionExample() {
-         *   try {
-         *     const answer = await question('What is you favorite food? ');
-         *     console.log(`Oh, so your favorite food is ${answer}`);
-         *   } catch (err) {
-         *     console.error('Question rejected', err);
-         *   }
-         * }
-         * questionExample();
-         * ```
          * @since v0.3.3
          * @param query A statement or query to write to `output`, prepended to the prompt.
          * @param callback A callback function that is invoked with the user's input in response to the `query`.
@@ -198,7 +183,7 @@ declare module 'readline' {
          * The `rl.pause()` method pauses the `input` stream, allowing it to be resumed
          * later if necessary.
          *
-         * Calling `rl.pause()` does not immediately pause other events (including`'line'`) from being emitted by the `readline.Interface` instance.
+         * Calling `rl.pause()` does not immediately pause other events (including`'line'`) from being emitted by the `Interface` instance.
          * @since v0.3.4
          */
         pause(): this;
@@ -208,12 +193,12 @@ declare module 'readline' {
          */
         resume(): this;
         /**
-         * The `rl.close()` method closes the `readline.Interface` instance and
+         * The `rl.close()` method closes the `Interface` instance and
          * relinquishes control over the `input` and `output` streams. When called,
          * the `'close'` event will be emitted.
          *
          * Calling `rl.close()` does not immediately stop other events (including `'line'`)
-         * from being emitted by the `readline.Interface` instance.
+         * from being emitted by the `Interface` instance.
          * @since v0.1.98
          */
         close(): void;
@@ -228,7 +213,7 @@ declare module 'readline' {
          * When called, `rl.write()` will resume the `input` stream if it has been
          * paused.
          *
-         * If the `readline.Interface` was created with `output` set to `null` or`undefined` the `data` and `key` are not written.
+         * If the `Interface` was created with `output` set to `null` or`undefined` the `data` and `key` are not written.
          *
          * ```js
          * rl.write('Delete this!');
@@ -315,11 +300,11 @@ declare module 'readline' {
         prependOnceListener(event: 'history', listener: (history: string[]) => void): this;
         [Symbol.asyncIterator](): AsyncIterableIterator<string>;
     }
-    type ReadLine = Interface; // type forwarded for backwards compatibility
-    type Completer = (line: string) => CompleterResult;
-    type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => void;
-    type CompleterResult = [string[], string];
-    interface ReadLineOptions {
+    export type ReadLine = Interface; // type forwarded for backwards compatibility
+    export type Completer = (line: string) => CompleterResult;
+    export type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => void;
+    export type CompleterResult = [string[], string];
+    export interface ReadLineOptions {
         input: NodeJS.ReadableStream;
         output?: NodeJS.WritableStream | undefined;
         completer?: Completer | AsyncCompleter | undefined;
@@ -348,10 +333,10 @@ declare module 'readline' {
      * The `readline.createInterface()` method creates a new `readline.Interface`instance.
      *
      * ```js
-     * const readline = require('readline');
+     * const readline = require('node:readline');
      * const rl = readline.createInterface({
      *   input: process.stdin,
-     *   output: process.stdout
+     *   output: process.stdout,
      * });
      * ```
      *
@@ -370,18 +355,12 @@ declare module 'readline' {
      * (`process.stdout` does this automatically when it is a TTY).
      *
      * When creating a `readline.Interface` using `stdin` as input, the program
-     * will not terminate until it receives `EOF` (Ctrl+D on
-     * Linux/macOS, Ctrl+Z followed by Return on
-     * Windows).
-     * If you want your application to exit without waiting for user input, you can `unref()` the standard input stream:
-     *
-     * ```js
-     * process.stdin.unref();
-     * ```
+     * will not terminate until it receives an [EOF character](https://en.wikipedia.org/wiki/End-of-file#EOF_character). To exit without
+     * waiting for user input, call `process.stdin.unref()`.
      * @since v0.1.98
      */
-    function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
-    function createInterface(options: ReadLineOptions): Interface;
+    export function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
+    export function createInterface(options: ReadLineOptions): Interface;
     /**
      * The `readline.emitKeypressEvents()` method causes the given `Readable` stream to begin emitting `'keypress'` events corresponding to received input.
      *
@@ -405,11 +384,11 @@ declare module 'readline' {
      * implement a small command-line interface:
      *
      * ```js
-     * const readline = require('readline');
+     * const readline = require('node:readline');
      * const rl = readline.createInterface({
      *   input: process.stdin,
      *   output: process.stdout,
-     *   prompt: 'OHAI> '
+     *   prompt: 'OHAI> ',
      * });
      *
      * rl.prompt();
@@ -437,15 +416,15 @@ declare module 'readline' {
      * well as a `for await...of` loop:
      *
      * ```js
-     * const fs = require('fs');
-     * const readline = require('readline');
+     * const fs = require('node:fs');
+     * const readline = require('node:readline');
      *
      * async function processLineByLine() {
      *   const fileStream = fs.createReadStream('input.txt');
      *
      *   const rl = readline.createInterface({
      *     input: fileStream,
-     *     crlfDelay: Infinity
+     *     crlfDelay: Infinity,
      *   });
      *   // Note: we use the crlfDelay option to recognize all instances of CR LF
      *   // ('\r\n') in input.txt as a single line break.
@@ -462,12 +441,12 @@ declare module 'readline' {
      * Alternatively, one could use the `'line'` event:
      *
      * ```js
-     * const fs = require('fs');
-     * const readline = require('readline');
+     * const fs = require('node:fs');
+     * const readline = require('node:readline');
      *
      * const rl = readline.createInterface({
      *   input: fs.createReadStream('sample.txt'),
-     *   crlfDelay: Infinity
+     *   crlfDelay: Infinity,
      * });
      *
      * rl.on('line', (line) => {
@@ -478,15 +457,15 @@ declare module 'readline' {
      * Currently, `for await...of` loop can be a bit slower. If `async` / `await`flow and speed are both essential, a mixed approach can be applied:
      *
      * ```js
-     * const { once } = require('events');
-     * const { createReadStream } = require('fs');
-     * const { createInterface } = require('readline');
+     * const { once } = require('node:events');
+     * const { createReadStream } = require('node:fs');
+     * const { createInterface } = require('node:readline');
      *
      * (async function processLineByLine() {
      *   try {
      *     const rl = createInterface({
      *       input: createReadStream('big-file.txt'),
-     *       crlfDelay: Infinity
+     *       crlfDelay: Infinity,
      *     });
      *
      *     rl.on('line', (line) => {
@@ -503,9 +482,9 @@ declare module 'readline' {
      * ```
      * @since v0.7.7
      */
-    function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
-    type Direction = -1 | 0 | 1;
-    interface CursorPos {
+    export function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
+    export type Direction = -1 | 0 | 1;
+    export interface CursorPos {
         rows: number;
         cols: number;
     }
@@ -516,7 +495,7 @@ declare module 'readline' {
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
+    export function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
     /**
      * The `readline.clearScreenDown()` method clears the given `TTY` stream from
      * the current position of the cursor down.
@@ -524,7 +503,7 @@ declare module 'readline' {
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
+    export function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
     /**
      * The `readline.cursorTo()` method moves cursor to the specified position in a
      * given `TTY` `stream`.
@@ -532,118 +511,15 @@ declare module 'readline' {
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
+    export function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
     /**
      * The `readline.moveCursor()` method moves the cursor _relative_ to its current
      * position in a given `TTY` `stream`.
-     *
-     * ## Example: Tiny CLI
-     *
-     * The following example illustrates the use of `readline.Interface` class to
-     * implement a small command-line interface:
-     *
-     * ```js
-     * const readline = require('readline');
-     * const rl = readline.createInterface({
-     *   input: process.stdin,
-     *   output: process.stdout,
-     *   prompt: 'OHAI> '
-     * });
-     *
-     * rl.prompt();
-     *
-     * rl.on('line', (line) => {
-     *   switch (line.trim()) {
-     *     case 'hello':
-     *       console.log('world!');
-     *       break;
-     *     default:
-     *       console.log(`Say what? I might have heard '${line.trim()}'`);
-     *       break;
-     *   }
-     *   rl.prompt();
-     * }).on('close', () => {
-     *   console.log('Have a great day!');
-     *   process.exit(0);
-     * });
-     * ```
-     *
-     * ## Example: Read file stream line-by-Line
-     *
-     * A common use case for `readline` is to consume an input file one line at a
-     * time. The easiest way to do so is leveraging the `fs.ReadStream` API as
-     * well as a `for await...of` loop:
-     *
-     * ```js
-     * const fs = require('fs');
-     * const readline = require('readline');
-     *
-     * async function processLineByLine() {
-     *   const fileStream = fs.createReadStream('input.txt');
-     *
-     *   const rl = readline.createInterface({
-     *     input: fileStream,
-     *     crlfDelay: Infinity
-     *   });
-     *   // Note: we use the crlfDelay option to recognize all instances of CR LF
-     *   // ('\r\n') in input.txt as a single line break.
-     *
-     *   for await (const line of rl) {
-     *     // Each line in input.txt will be successively available here as `line`.
-     *     console.log(`Line from file: ${line}`);
-     *   }
-     * }
-     *
-     * processLineByLine();
-     * ```
-     *
-     * Alternatively, one could use the `'line'` event:
-     *
-     * ```js
-     * const fs = require('fs');
-     * const readline = require('readline');
-     *
-     * const rl = readline.createInterface({
-     *   input: fs.createReadStream('sample.txt'),
-     *   crlfDelay: Infinity
-     * });
-     *
-     * rl.on('line', (line) => {
-     *   console.log(`Line from file: ${line}`);
-     * });
-     * ```
-     *
-     * Currently, `for await...of` loop can be a bit slower. If `async` / `await`flow and speed are both essential, a mixed approach can be applied:
-     *
-     * ```js
-     * const { once } = require('events');
-     * const { createReadStream } = require('fs');
-     * const { createInterface } = require('readline');
-     *
-     * (async function processLineByLine() {
-     *   try {
-     *     const rl = createInterface({
-     *       input: createReadStream('big-file.txt'),
-     *       crlfDelay: Infinity
-     *     });
-     *
-     *     rl.on('line', (line) => {
-     *       // Process the line.
-     *     });
-     *
-     *     await once(rl, 'close');
-     *
-     *     console.log('File processed.');
-     *   } catch (err) {
-     *     console.error(err);
-     *   }
-     * })();
-     * ```
      * @since v0.7.7
      * @param callback Invoked once the operation completes.
      * @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
      */
-    function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
+    export function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
 }
 declare module 'node:readline' {
     export * from 'readline';

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/repl.d.ts

@@ -1,12 +1,12 @@
 /**
- * The `repl` module provides a Read-Eval-Print-Loop (REPL) implementation that
- * is available both as a standalone program or includible in other applications.
- * It can be accessed using:
+ * The `node:repl` module provides a Read-Eval-Print-Loop (REPL) implementation
+ * that is available both as a standalone program or includible in other
+ * applications. It can be accessed using:
  *
  * ```js
- * const repl = require('repl');
+ * const repl = require('node:repl');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/repl.js)
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/repl.js)
  */
 declare module 'repl' {
     import { Interface, Completer, AsyncCompleter } from 'node:readline';
@@ -41,8 +41,8 @@ declare module 'repl' {
          * error with `repl.Recoverable` to indicate the input was incomplete and prompt for
          * additional lines.
          *
-         * @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
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/repl.html#repl_default_evaluation
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/repl.html#repl_custom_evaluation_functions
          */
         eval?: REPLEval | undefined;
         /**
@@ -74,13 +74,13 @@ declare module 'repl' {
          * 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
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/repl.html#repl_customizing_repl_output
          */
         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
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/readline.html#readline_use_of_the_completer_function
          */
         completer?: Completer | AsyncCompleter | undefined;
         /**
@@ -124,7 +124,7 @@ declare module 'repl' {
      * or directly using the JavaScript `new` keyword.
      *
      * ```js
-     * const repl = require('repl');
+     * const repl = require('node:repl');
      *
      * const options = { useColors: true };
      *
@@ -162,33 +162,33 @@ declare module 'repl' {
         /**
          * A value indicating whether the REPL is currently in "editor mode".
          *
-         * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_commands_and_special_keys
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/repl.html#repl_commands_and_special_keys
          */
         readonly editorMode: boolean;
         /**
          * A value indicating whether the `_` variable has been assigned.
          *
-         * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
          */
         readonly underscoreAssigned: boolean;
         /**
          * The last evaluation result from the REPL (assigned to the `_` variable inside of the REPL).
          *
-         * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
          */
         readonly last: any;
         /**
          * A value indicating whether the `_error` variable has been assigned.
          *
          * @since v9.8.0
-         * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
          */
         readonly underscoreErrAssigned: boolean;
         /**
          * The last error raised inside the REPL (assigned to the `_error` variable inside of the REPL).
          *
          * @since v9.8.0
-         * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
          */
         readonly lastError: any;
         /**
@@ -240,7 +240,7 @@ declare module 'repl' {
          *
          * `REPLServer` cannot be subclassed due to implementation specifics in NodeJS.
          *
-         * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_class_replserver
+         * @see https://nodejs.org/dist/latest-v20.x/docs/api/repl.html#repl_class_replserver
          */
         private constructor();
         /**
@@ -251,7 +251,7 @@ declare module 'repl' {
          * The following example shows two new commands added to the REPL instance:
          *
          * ```js
-         * const repl = require('repl');
+         * const repl = require('node:repl');
          *
          * const replServer = repl.start({ prompt: '> ' });
          * replServer.defineCommand('sayhello', {
@@ -260,7 +260,7 @@ declare module 'repl' {
          *     this.clearBufferedCommand();
          *     console.log(`Hello, ${name}!`);
          *     this.displayPrompt();
-         *   }
+         *   },
          * });
          * replServer.defineCommand('saybye', function saybye() {
          *   console.log('Goodbye!');
@@ -277,7 +277,7 @@ declare module 'repl' {
          * Goodbye!
          * ```
          * @since v0.3.0
-         * @param keyword The command keyword (*without* a leading `.` character).
+         * @param keyword The command keyword (_without_ a leading `.` character).
          * @param cmd The function to invoke when the command is processed.
          */
         defineCommand(keyword: string, cmd: REPLCommandAction | REPLCommand): void;
@@ -401,7 +401,7 @@ declare module 'repl' {
      * If `options` is a string, then it specifies the input prompt:
      *
      * ```js
-     * const repl = require('repl');
+     * const repl = require('node:repl');
      *
      * // a Unix style prompt
      * repl.start('$ ');
@@ -412,7 +412,7 @@ declare module 'repl' {
     /**
      * Indicates a recoverable error that a `REPLServer` can use to support multi-line input.
      *
-     * @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_recoverable_errors
+     * @see https://nodejs.org/dist/latest-v20.x/docs/api/repl.html#repl_recoverable_errors
      */
     class Recoverable extends SyntaxError {
         err: Error;

package/lib/publishing/github/node_modules/@types/jsonwebtoken/node_modules/@types/node/stream/consumers.d.ts

@@ -1,22 +1,10 @@
-// Duplicates of interface in lib.dom.ts.
-// Duplicated here rather than referencing lib.dom.ts because doing so causes lib.dom.ts to be loaded for "test-all"
-// Which in turn causes tests to pass that shouldn't pass.
-//
-// This interface is not, and should not be, exported.
-interface Blob {
-    readonly size: number;
-    readonly type: string;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    slice(start?: number, end?: number, contentType?: string): Blob;
-    stream(): NodeJS.ReadableStream;
-    text(): Promise<string>;
-}
 declare module 'stream/consumers' {
+    import { Blob as NodeBlob } from 'node:buffer';
     import { Readable } from 'node:stream';
     function buffer(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<Buffer>;
     function text(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<string>;
     function arrayBuffer(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<ArrayBuffer>;
-    function blob(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<Blob>;
+    function blob(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<NodeBlob>;
     function json(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<unknown>;
 }
 declare module 'node:stream/consumers' {