@types/node 18.11.5 → 20.2.5

node/ts4.8/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/v18.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!');
@@ -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;

node/ts4.8/stream/consumers.d.ts

@@ -1,5 +1,5 @@
 declare module 'stream/consumers' {
-    import { Blob as NodeBlob } from "node:buffer";
+    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>;

node/ts4.8/stream.d.ts

@@ -1,24 +1,24 @@
 /**
  * A stream is an abstract interface for working with streaming data in Node.js.
- * The `stream` module provides an API for implementing the stream interface.
+ * The `node:stream` module provides an API for implementing the stream interface.
  *
  * There are many stream objects provided by Node.js. For instance, a `request to an HTTP server` and `process.stdout` are both stream instances.
  *
  * Streams can be readable, writable, or both. All streams are instances of `EventEmitter`.
  *
- * To access the `stream` module:
+ * To access the `node:stream` module:
  *
  * ```js
- * const stream = require('stream');
+ * const stream = require('node:stream');
  * ```
  *
- * The `stream` module is useful for creating new types of stream instances. It is
- * usually not necessary to use the `stream` module to consume streams.
- * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/stream.js)
+ * The `node:stream` module is useful for creating new types of stream instances.
+ * It is usually not necessary to use the `node:stream` module to consume streams.
+ * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/stream.js)
  */
 declare module 'stream' {
     import { EventEmitter, Abortable } from 'node:events';
-    import { Blob as NodeBlob } from "node:buffer";
+    import { Blob as NodeBlob } from 'node:buffer';
     import * as streamPromises from 'node:stream/promises';
     import * as streamConsumers from 'node:stream/consumers';
     import * as streamWeb from 'node:stream/web';
@@ -124,12 +124,12 @@ declare module 'stream' {
             readonly readableObjectMode: boolean;
             /**
              * Is `true` after `readable.destroy()` has been called.
-             * @since v18.0.0
+             * @since v8.0.0
              */
             destroyed: boolean;
             /**
-             * Is true after 'close' has been emitted.
-             * @since v8.0.0
+             * Is `true` after `'close'` has been emitted.
+             * @since v18.0.0
              */
             readonly closed: boolean;
             /**
@@ -310,7 +310,7 @@ declare module 'stream' {
              * the method does nothing.
              *
              * ```js
-             * const fs = require('fs');
+             * const fs = require('node:fs');
              * const readable = getReadableStreamSomehow();
              * const writable = fs.createWriteStream('file.txt');
              * // All the data from readable goes into 'file.txt',
@@ -348,7 +348,7 @@ declare module 'stream' {
              * // Pull off a header delimited by \n\n.
              * // Use unshift() if we get too much.
              * // Call the callback with (error, header, stream).
-             * const { StringDecoder } = require('string_decoder');
+             * const { StringDecoder } = require('node:string_decoder');
              * function parseHeader(stream, callback) {
              *   stream.on('error', callback);
              *   stream.on('readable', onReadable);
@@ -388,14 +388,14 @@ declare module 'stream' {
              * however it is best to simply avoid calling `readable.unshift()` while in the
              * process of performing a read.
              * @since v0.9.11
-             * @param chunk Chunk of data to unshift onto the read queue. For streams not operating in object mode, `chunk` must be a string, `Buffer`, `Uint8Array` or `null`. For object mode
+             * @param chunk Chunk of data to unshift onto the read queue. For streams not operating in object mode, `chunk` must be a string, `Buffer`, `Uint8Array`, or `null`. For object mode
              * streams, `chunk` may be any JavaScript value.
              * @param encoding Encoding of string chunks. Must be a valid `Buffer` encoding, such as `'utf8'` or `'ascii'`.
              */
             unshift(chunk: any, encoding?: BufferEncoding): void;
             /**
-             * Prior to Node.js 0.10, streams did not implement the entire `stream` module API
-             * as it is currently defined. (See `Compatibility` for more information.)
+             * Prior to Node.js 0.10, streams did not implement the entire `node:stream`module API as it is currently defined. (See `Compatibility` for more
+             * information.)
              *
              * When using an older Node.js library that emits `'data'` events and has a {@link pause} method that is advisory only, the`readable.wrap()` method can be used to create a `Readable`
              * stream that uses
@@ -407,7 +407,7 @@ declare module 'stream' {
              *
              * ```js
              * const { OldReader } = require('./old-api-module.js');
-             * const { Readable } = require('stream');
+             * const { Readable } = require('node:stream');
              * const oreader = new OldReader();
              * const myReader = new Readable().wrap(oreader);
              *
@@ -534,7 +534,7 @@ declare module 'stream' {
             static toWeb(streamWritable: Writable): streamWeb.WritableStream;
             /**
              * Is `true` if it is safe to call `writable.write()`, which means
-             * the stream has not been destroyed, errored or ended.
+             * the stream has not been destroyed, errored, or ended.
              * @since v11.4.0
              */
             readonly writable: boolean;
@@ -578,8 +578,8 @@ declare module 'stream' {
              */
             destroyed: boolean;
             /**
-             * Is true after 'close' has been emitted.
-             * @since v8.0.0
+             * Is `true` after `'close'` has been emitted.
+             * @since v18.0.0
              */
             readonly closed: boolean;
             /**
@@ -588,7 +588,7 @@ declare module 'stream' {
              */
             readonly errored: Error | null;
             /**
-             * Is `true` if the stream's buffer has been full and stream will emit 'drain'.
+             * Is `true` if the stream's buffer has been full and stream will emit `'drain'`.
              * @since v15.2.0, v14.17.0
              */
             readonly writableNeedDrain: boolean;
@@ -678,7 +678,7 @@ declare module 'stream' {
              *
              * ```js
              * // Write 'hello, ' and then end with 'world!'.
-             * const fs = require('fs');
+             * const fs = require('node:fs');
              * const file = fs.createWriteStream('example.txt');
              * file.write('hello, ');
              * file.end('world!');
@@ -864,7 +864,7 @@ declare module 'stream' {
             /**
              * If `false` then the stream will automatically end the writable side when the
              * readable side ends. Set initially by the `allowHalfOpen` constructor option,
-             * which defaults to `false`.
+             * which defaults to `true`.
              *
              * This can be changed manually to change the half-open behavior of an existing`Duplex` stream instance, but must be changed before the `'end'` event is
              * emitted.
@@ -912,6 +912,105 @@ declare module 'stream' {
             end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this;
             cork(): void;
             uncork(): void;
+            /**
+             * Event emitter
+             * The defined events on documents including:
+             * 1.  close
+             * 2.  data
+             * 3.  drain
+             * 4.  end
+             * 5.  error
+             * 6.  finish
+             * 7.  pause
+             * 8.  pipe
+             * 9.  readable
+             * 10. resume
+             * 11. unpipe
+             */
+            addListener(event: 'close', listener: () => void): this;
+            addListener(event: 'data', listener: (chunk: any) => void): this;
+            addListener(event: 'drain', listener: () => void): this;
+            addListener(event: 'end', listener: () => void): this;
+            addListener(event: 'error', listener: (err: Error) => void): this;
+            addListener(event: 'finish', listener: () => void): this;
+            addListener(event: 'pause', listener: () => void): this;
+            addListener(event: 'pipe', listener: (src: Readable) => void): this;
+            addListener(event: 'readable', listener: () => void): this;
+            addListener(event: 'resume', listener: () => void): this;
+            addListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            emit(event: 'close'): boolean;
+            emit(event: 'data', chunk: any): boolean;
+            emit(event: 'drain'): boolean;
+            emit(event: 'end'): boolean;
+            emit(event: 'error', err: Error): boolean;
+            emit(event: 'finish'): boolean;
+            emit(event: 'pause'): boolean;
+            emit(event: 'pipe', src: Readable): boolean;
+            emit(event: 'readable'): boolean;
+            emit(event: 'resume'): boolean;
+            emit(event: 'unpipe', src: Readable): boolean;
+            emit(event: string | symbol, ...args: any[]): boolean;
+            on(event: 'close', listener: () => void): this;
+            on(event: 'data', listener: (chunk: any) => void): this;
+            on(event: 'drain', listener: () => void): this;
+            on(event: 'end', listener: () => void): this;
+            on(event: 'error', listener: (err: Error) => void): this;
+            on(event: 'finish', listener: () => void): this;
+            on(event: 'pause', listener: () => void): this;
+            on(event: 'pipe', listener: (src: Readable) => void): this;
+            on(event: 'readable', listener: () => void): this;
+            on(event: 'resume', listener: () => void): this;
+            on(event: 'unpipe', listener: (src: Readable) => void): this;
+            on(event: string | symbol, listener: (...args: any[]) => void): this;
+            once(event: 'close', listener: () => void): this;
+            once(event: 'data', listener: (chunk: any) => void): this;
+            once(event: 'drain', listener: () => void): this;
+            once(event: 'end', listener: () => void): this;
+            once(event: 'error', listener: (err: Error) => void): this;
+            once(event: 'finish', listener: () => void): this;
+            once(event: 'pause', listener: () => void): this;
+            once(event: 'pipe', listener: (src: Readable) => void): this;
+            once(event: 'readable', listener: () => void): this;
+            once(event: 'resume', listener: () => void): this;
+            once(event: 'unpipe', listener: (src: Readable) => void): this;
+            once(event: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener(event: 'close', listener: () => void): this;
+            prependListener(event: 'data', listener: (chunk: any) => void): this;
+            prependListener(event: 'drain', listener: () => void): this;
+            prependListener(event: 'end', listener: () => void): this;
+            prependListener(event: 'error', listener: (err: Error) => void): this;
+            prependListener(event: 'finish', listener: () => void): this;
+            prependListener(event: 'pause', listener: () => void): this;
+            prependListener(event: 'pipe', listener: (src: Readable) => void): this;
+            prependListener(event: 'readable', listener: () => void): this;
+            prependListener(event: 'resume', listener: () => void): this;
+            prependListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener(event: 'close', listener: () => void): this;
+            prependOnceListener(event: 'data', listener: (chunk: any) => void): this;
+            prependOnceListener(event: 'drain', listener: () => void): this;
+            prependOnceListener(event: 'end', listener: () => void): this;
+            prependOnceListener(event: 'error', listener: (err: Error) => void): this;
+            prependOnceListener(event: 'finish', listener: () => void): this;
+            prependOnceListener(event: 'pause', listener: () => void): this;
+            prependOnceListener(event: 'pipe', listener: (src: Readable) => void): this;
+            prependOnceListener(event: 'readable', listener: () => void): this;
+            prependOnceListener(event: 'resume', listener: () => void): this;
+            prependOnceListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
+            removeListener(event: 'close', listener: () => void): this;
+            removeListener(event: 'data', listener: (chunk: any) => void): this;
+            removeListener(event: 'drain', listener: () => void): this;
+            removeListener(event: 'end', listener: () => void): this;
+            removeListener(event: 'error', listener: (err: Error) => void): this;
+            removeListener(event: 'finish', listener: () => void): this;
+            removeListener(event: 'pause', listener: () => void): this;
+            removeListener(event: 'pipe', listener: (src: Readable) => void): this;
+            removeListener(event: 'readable', listener: () => void): this;
+            removeListener(event: 'resume', listener: () => void): this;
+            removeListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
         }
         type TransformCallback = (error?: Error | null, data?: any) => void;
         interface TransformOptions extends DuplexOptions {
@@ -953,18 +1052,21 @@ declare module 'stream' {
          */
         class PassThrough extends Transform {}
         /**
+         * A stream to attach a signal to.
+         *
          * 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.
+         * Calling `abort` on the `AbortController` corresponding to the passed`AbortSignal` will behave the same way as calling `.destroy(new AbortError())`on the stream, and `controller.error(new
+         * AbortError())` for webstreams.
          *
          * ```js
-         * const fs = require('fs');
+         * const fs = require('node:fs');
          *
          * const controller = new AbortController();
          * const read = addAbortSignal(
          *   controller.signal,
-         *   fs.createReadStream(('object.json'))
+         *   fs.createReadStream(('object.json')),
          * );
          * // Later, abort the operation closing the stream
          * controller.abort();
@@ -977,7 +1079,7 @@ declare module 'stream' {
          * setTimeout(() => controller.abort(), 10_000); // set a timeout
          * const stream = addAbortSignal(
          *   controller.signal,
-         *   fs.createReadStream(('object.json'))
+         *   fs.createReadStream(('object.json')),
          * );
          * (async () => {
          *   try {
@@ -993,22 +1095,70 @@ declare module 'stream' {
          *   }
          * })();
          * ```
+         *
+         * Or using an `AbortSignal` with a ReadableStream:
+         *
+         * ```js
+         * const controller = new AbortController();
+         * const rs = new ReadableStream({
+         *   start(controller) {
+         *     controller.enqueue('hello');
+         *     controller.enqueue('world');
+         *     controller.close();
+         *   },
+         * });
+         *
+         * addAbortSignal(controller.signal, rs);
+         *
+         * finished(rs, (err) => {
+         *   if (err) {
+         *     if (err.name === 'AbortError') {
+         *       // The operation was cancelled
+         *     }
+         *   }
+         * });
+         *
+         * const reader = rs.getReader();
+         *
+         * reader.read().then(({ value, done }) => {
+         *   console.log(value); // hello
+         *   console.log(done); // false
+         *   controller.abort();
+         * });
+         * ```
          * @since v15.4.0
          * @param signal A signal representing possible cancellation
          * @param stream a stream to attach a signal to
          */
         function addAbortSignal<T extends Stream>(signal: AbortSignal, stream: T): T;
+        /**
+         * Returns the default highWaterMark used by streams.
+         * Defaults to `16384` (16 KiB), or `16` for `objectMode`.
+         * @since v19.9.0
+         * @param objectMode
+         */
+        function getDefaultHighWaterMark(objectMode: boolean): number;
+        /**
+         * Sets the default highWaterMark used by streams.
+         * @since v19.9.0
+         * @param objectMode
+         * @param value highWaterMark value
+         */
+        function setDefaultHighWaterMark(objectMode: boolean, value: number): void;
         interface FinishedOptions extends Abortable {
             error?: boolean | undefined;
             readable?: boolean | undefined;
             writable?: boolean | undefined;
         }
         /**
+         * A readable and/or writable stream/webstream.
+         *
          * A function to get notified when a stream is no longer readable, writable
          * or has experienced an error or a premature close event.
          *
          * ```js
-         * const { finished } = require('stream');
+         * const { finished } = require('node:stream');
+         * const fs = require('node:fs');
          *
          * const rs = fs.createReadStream('archive.tar');
          *
@@ -1026,21 +1176,7 @@ declare module 'stream' {
          * Especially useful in error handling scenarios where a stream is destroyed
          * prematurely (like an aborted HTTP request), and will not emit `'end'`or `'finish'`.
          *
-         * The `finished` API provides promise version:
-         *
-         * ```js
-         * const { finished } = require('stream/promises');
-         *
-         * const rs = fs.createReadStream('archive.tar');
-         *
-         * async function run() {
-         *   await finished(rs);
-         *   console.log('Stream is done reading.');
-         * }
-         *
-         * run().catch(console.error);
-         * rs.resume(); // Drain the stream.
-         * ```
+         * The `finished` API provides `promise version`.
          *
          * `stream.finished()` leaves dangling event listeners (in particular`'error'`, `'end'`, `'finish'` and `'close'`) after `callback` has been
          * invoked. The reason for this is so that unexpected `'error'` events (due to
@@ -1080,16 +1216,17 @@ declare module 'stream' {
             : (err: NodeJS.ErrnoException | null) => void;
         type PipelinePromise<S extends PipelineDestination<any, any>> = S extends PipelineDestinationPromiseFunction<any, infer P> ? Promise<P> : Promise<void>;
         interface PipelineOptions {
-            signal: AbortSignal;
+            signal?: AbortSignal | undefined;
+            end?: boolean | undefined;
         }
         /**
          * A module method to pipe between streams and generators forwarding errors and
          * properly cleaning up and provide a callback when the pipeline is complete.
          *
          * ```js
-         * const { pipeline } = require('stream');
-         * const fs = require('fs');
-         * const zlib = require('zlib');
+         * const { pipeline } = require('node:stream');
+         * const fs = require('node:fs');
+         * const zlib = require('node:zlib');
          *
          * // Use the pipeline API to easily pipe a series of streams
          * // together and get notified when the pipeline is fully done.
@@ -1106,95 +1243,11 @@ declare module 'stream' {
          *     } else {
          *       console.log('Pipeline succeeded.');
          *     }
-         *   }
+         *   },
          * );
          * ```
          *
-         * The `pipeline` API provides a promise version, which can also
-         * receive an options argument as the last parameter with a`signal` `AbortSignal` property. When the signal is aborted,`destroy` will be called on the underlying pipeline, with
-         * an`AbortError`.
-         *
-         * ```js
-         * const { pipeline } = require('stream/promises');
-         *
-         * async function run() {
-         *   await pipeline(
-         *     fs.createReadStream('archive.tar'),
-         *     zlib.createGzip(),
-         *     fs.createWriteStream('archive.tar.gz')
-         *   );
-         *   console.log('Pipeline succeeded.');
-         * }
-         *
-         * run().catch(console.error);
-         * ```
-         *
-         * To use an `AbortSignal`, pass it inside an options object,
-         * as the last argument:
-         *
-         * ```js
-         * const { pipeline } = require('stream/promises');
-         *
-         * async function run() {
-         *   const ac = new AbortController();
-         *   const signal = ac.signal;
-         *
-         *   setTimeout(() => ac.abort(), 1);
-         *   await pipeline(
-         *     fs.createReadStream('archive.tar'),
-         *     zlib.createGzip(),
-         *     fs.createWriteStream('archive.tar.gz'),
-         *     { signal },
-         *   );
-         * }
-         *
-         * run().catch(console.error); // AbortError
-         * ```
-         *
-         * The `pipeline` API also supports async generators:
-         *
-         * ```js
-         * const { pipeline } = require('stream/promises');
-         * const fs = require('fs');
-         *
-         * async function run() {
-         *   await pipeline(
-         *     fs.createReadStream('lowercase.txt'),
-         *     async function* (source, { signal }) {
-         *       source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.
-         *       for await (const chunk of source) {
-         *         yield await processChunk(chunk, { signal });
-         *       }
-         *     },
-         *     fs.createWriteStream('uppercase.txt')
-         *   );
-         *   console.log('Pipeline succeeded.');
-         * }
-         *
-         * run().catch(console.error);
-         * ```
-         *
-         * Remember to handle the `signal` argument passed into the async generator.
-         * Especially in the case where the async generator is the source for the
-         * pipeline (i.e. first argument) or the pipeline will never complete.
-         *
-         * ```js
-         * const { pipeline } = require('stream/promises');
-         * const fs = require('fs');
-         *
-         * async function run() {
-         *   await pipeline(
-         *     async function* ({ signal }) {
-         *       await someLongRunningfn({ signal });
-         *       yield 'asd';
-         *     },
-         *     fs.createWriteStream('uppercase.txt')
-         *   );
-         *   console.log('Pipeline succeeded.');
-         * }
-         *
-         * run().catch(console.error);
-         * ```
+         * The `pipeline` API provides a `promise version`.
          *
          * `stream.pipeline()` will call `stream.destroy(err)` on all streams except:
          *
@@ -1213,9 +1266,9 @@ declare module 'stream' {
          * See the example below:
          *
          * ```js
-         * const fs = require('fs');
-         * const http = require('http');
-         * const { pipeline } = require('stream');
+         * const fs = require('node:fs');
+         * const http = require('node:http');
+         * const { pipeline } = require('node:stream');
          *
          * const server = http.createServer((req, res) => {
          *   const fileStream = fs.createReadStream('./fileNotExist.txt');
@@ -1316,19 +1369,18 @@ declare module 'stream' {
             ref(): void;
             unref(): void;
         }
-
         /**
          * Returns whether the stream has encountered an error.
-         * @since v17.3.0
+         * @since v17.3.0, v16.14.0
+         * @experimental
          */
         function isErrored(stream: Readable | Writable | NodeJS.ReadableStream | NodeJS.WritableStream): boolean;
-
         /**
          * Returns whether the stream is readable.
-         * @since v17.4.0
+         * @since v17.4.0, v16.14.0
+         * @experimental
          */
         function isReadable(stream: Readable | NodeJS.ReadableStream): boolean;
-
         const promises: typeof streamPromises;
         const consumers: typeof streamConsumers;
     }