@types/node 20.19.25 → 24.10.3

{node v20.19 → node v24.10}/stream/web.d.ts

@@ -1,11 +1,7 @@
 type _ByteLengthQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
     : import("stream/web").ByteLengthQueuingStrategy;
-type _CompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}
-    : import("stream/web").CompressionStream;
 type _CountQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
     : import("stream/web").CountQueuingStrategy;
-type _DecompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}
-    : import("stream/web").DecompressionStream;
 type _QueuingStrategy<T = any> = typeof globalThis extends { onmessage: any } ? {}
     : import("stream/web").QueuingStrategy<T>;
 type _ReadableByteStreamController = typeof globalThis extends { onmessage: any } ? {}
@@ -145,6 +141,9 @@ declare module "stream/web" {
     interface TransformerTransformCallback<I, O> {
         (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
     }
+    interface TransformerCancelCallback {
+        (reason: any): void | PromiseLike<void>;
+    }
     interface UnderlyingByteSource {
         autoAllocateChunkSize?: number;
         cancel?: ReadableStreamErrorCallback;
@@ -263,6 +262,7 @@ declare module "stream/web" {
         readableType?: undefined;
         start?: TransformerStartCallback<O>;
         transform?: TransformerTransformCallback<I, O>;
+        cancel?: TransformerCancelCallback;
         writableType?: undefined;
     }
     interface TransformStream<I = any, O = any> {
@@ -408,121 +408,161 @@ declare module "stream/web" {
         prototype: TextDecoderStream;
         new(encoding?: string, options?: TextDecoderOptions): TextDecoderStream;
     };
-    interface CompressionStream {
+    type CompressionFormat = "brotli" | "deflate" | "deflate-raw" | "gzip";
+    class CompressionStream {
+        constructor(format: CompressionFormat);
         readonly readable: ReadableStream;
         readonly writable: WritableStream;
     }
-    const CompressionStream: {
-        prototype: CompressionStream;
-        new(format: "deflate" | "deflate-raw" | "gzip"): CompressionStream;
-    };
-    interface DecompressionStream {
-        readonly writable: WritableStream;
+    class DecompressionStream {
+        constructor(format: CompressionFormat);
         readonly readable: ReadableStream;
+        readonly writable: WritableStream;
     }
-    const DecompressionStream: {
-        prototype: DecompressionStream;
-        new(format: "deflate" | "deflate-raw" | "gzip"): DecompressionStream;
-    };
 
     global {
         interface ByteLengthQueuingStrategy extends _ByteLengthQueuingStrategy {}
+        /**
+         * `ByteLengthQueuingStrategy` class is a global reference for `import { ByteLengthQueuingStrategy } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-bytelengthqueuingstrategy
+         * @since v18.0.0
+         */
         var ByteLengthQueuingStrategy: typeof globalThis extends { onmessage: any; ByteLengthQueuingStrategy: infer T }
             ? T
             : typeof import("stream/web").ByteLengthQueuingStrategy;
 
-        interface CompressionStream extends _CompressionStream {}
-        var CompressionStream: typeof globalThis extends {
-            onmessage: any;
-            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.
-            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts
-            ReportingObserver: any;
-            CompressionStream: infer T;
-        } ? T
-            // TS 4.8, 4.9, 5.0
-            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {
-                    prototype: T;
-                    new(format: "deflate" | "deflate-raw" | "gzip"): T;
-                }
-            : typeof import("stream/web").CompressionStream;
-
         interface CountQueuingStrategy extends _CountQueuingStrategy {}
+        /**
+         * `CountQueuingStrategy` class is a global reference for `import { CountQueuingStrategy } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-countqueuingstrategy
+         * @since v18.0.0
+         */
         var CountQueuingStrategy: typeof globalThis extends { onmessage: any; CountQueuingStrategy: infer T } ? T
             : typeof import("stream/web").CountQueuingStrategy;
 
-        interface DecompressionStream extends _DecompressionStream {}
-        var DecompressionStream: typeof globalThis extends {
-            onmessage: any;
-            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.
-            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts
-            ReportingObserver: any;
-            DecompressionStream: infer T;
-        } ? T
-            // TS 4.8, 4.9, 5.0
-            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {
-                    prototype: T;
-                    new(format: "deflate" | "deflate-raw" | "gzip"): T;
-                }
-            : typeof import("stream/web").DecompressionStream;
-
         interface QueuingStrategy<T = any> extends _QueuingStrategy<T> {}
 
         interface ReadableByteStreamController extends _ReadableByteStreamController {}
+        /**
+         * `ReadableByteStreamController` class is a global reference for `import { ReadableByteStreamController } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-readablebytestreamcontroller
+         * @since v18.0.0
+         */
         var ReadableByteStreamController: typeof globalThis extends
             { onmessage: any; ReadableByteStreamController: infer T } ? T
             : typeof import("stream/web").ReadableByteStreamController;
 
         interface ReadableStream<R = any> extends _ReadableStream<R> {}
+        /**
+         * `ReadableStream` class is a global reference for `import { ReadableStream } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-readablestream
+         * @since v18.0.0
+         */
         var ReadableStream: typeof globalThis extends { onmessage: any; ReadableStream: infer T } ? T
             : typeof import("stream/web").ReadableStream;
 
         interface ReadableStreamBYOBReader extends _ReadableStreamBYOBReader {}
+        /**
+         * `ReadableStreamBYOBReader` class is a global reference for `import { ReadableStreamBYOBReader } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-readablestreambyobreader
+         * @since v18.0.0
+         */
         var ReadableStreamBYOBReader: typeof globalThis extends { onmessage: any; ReadableStreamBYOBReader: infer T }
             ? T
             : typeof import("stream/web").ReadableStreamBYOBReader;
 
         interface ReadableStreamBYOBRequest extends _ReadableStreamBYOBRequest {}
+        /**
+         * `ReadableStreamBYOBRequest` class is a global reference for `import { ReadableStreamBYOBRequest } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-readablestreambyobrequest
+         * @since v18.0.0
+         */
         var ReadableStreamBYOBRequest: typeof globalThis extends { onmessage: any; ReadableStreamBYOBRequest: infer T }
             ? T
             : typeof import("stream/web").ReadableStreamBYOBRequest;
 
         interface ReadableStreamDefaultController<R = any> extends _ReadableStreamDefaultController<R> {}
+        /**
+         * `ReadableStreamDefaultController` class is a global reference for `import { ReadableStreamDefaultController } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-readablestreamdefaultcontroller
+         * @since v18.0.0
+         */
         var ReadableStreamDefaultController: typeof globalThis extends
             { onmessage: any; ReadableStreamDefaultController: infer T } ? T
             : typeof import("stream/web").ReadableStreamDefaultController;
 
         interface ReadableStreamDefaultReader<R = any> extends _ReadableStreamDefaultReader<R> {}
+        /**
+         * `ReadableStreamDefaultReader` class is a global reference for `import { ReadableStreamDefaultReader } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-readablestreamdefaultreader
+         * @since v18.0.0
+         */
         var ReadableStreamDefaultReader: typeof globalThis extends
             { onmessage: any; ReadableStreamDefaultReader: infer T } ? T
             : typeof import("stream/web").ReadableStreamDefaultReader;
 
         interface TextDecoderStream extends _TextDecoderStream {}
+        /**
+         * `TextDecoderStream` class is a global reference for `import { TextDecoderStream } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-textdecoderstream
+         * @since v18.0.0
+         */
         var TextDecoderStream: typeof globalThis extends { onmessage: any; TextDecoderStream: infer T } ? T
             : typeof import("stream/web").TextDecoderStream;
 
         interface TextEncoderStream extends _TextEncoderStream {}
+        /**
+         * `TextEncoderStream` class is a global reference for `import { TextEncoderStream } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-textencoderstream
+         * @since v18.0.0
+         */
         var TextEncoderStream: typeof globalThis extends { onmessage: any; TextEncoderStream: infer T } ? T
             : typeof import("stream/web").TextEncoderStream;
 
         interface TransformStream<I = any, O = any> extends _TransformStream<I, O> {}
+        /**
+         * `TransformStream` class is a global reference for `import { TransformStream } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-transformstream
+         * @since v18.0.0
+         */
         var TransformStream: typeof globalThis extends { onmessage: any; TransformStream: infer T } ? T
             : typeof import("stream/web").TransformStream;
 
         interface TransformStreamDefaultController<O = any> extends _TransformStreamDefaultController<O> {}
+        /**
+         * `TransformStreamDefaultController` class is a global reference for `import { TransformStreamDefaultController } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-transformstreamdefaultcontroller
+         * @since v18.0.0
+         */
         var TransformStreamDefaultController: typeof globalThis extends
             { onmessage: any; TransformStreamDefaultController: infer T } ? T
             : typeof import("stream/web").TransformStreamDefaultController;
 
         interface WritableStream<W = any> extends _WritableStream<W> {}
+        /**
+         * `WritableStream` class is a global reference for `import { WritableStream } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-writablestream
+         * @since v18.0.0
+         */
         var WritableStream: typeof globalThis extends { onmessage: any; WritableStream: infer T } ? T
             : typeof import("stream/web").WritableStream;
 
         interface WritableStreamDefaultController extends _WritableStreamDefaultController {}
+        /**
+         * `WritableStreamDefaultController` class is a global reference for `import { WritableStreamDefaultController } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-writablestreamdefaultcontroller
+         * @since v18.0.0
+         */
         var WritableStreamDefaultController: typeof globalThis extends
             { onmessage: any; WritableStreamDefaultController: infer T } ? T
             : typeof import("stream/web").WritableStreamDefaultController;
 
         interface WritableStreamDefaultWriter<W = any> extends _WritableStreamDefaultWriter<W> {}
+        /**
+         * `WritableStreamDefaultWriter` class is a global reference for `import { WritableStreamDefaultWriter } from 'node:stream/web'`.
+         * https://nodejs.org/api/globals.html#class-writablestreamdefaultwriter
+         * @since v18.0.0
+         */
         var WritableStreamDefaultWriter: typeof globalThis extends
             { onmessage: any; WritableStreamDefaultWriter: infer T } ? T
             : typeof import("stream/web").WritableStreamDefaultWriter;

{node v20.19 → node v24.10}/stream.d.ts

@@ -2,10 +2,10 @@
  * A stream is an abstract interface for working with streaming data in Node.js.
  * 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](https://nodejs.org/docs/latest-v20.x/api/http.html#class-httpincomingmessage)
- * and [`process.stdout`](https://nodejs.org/docs/latest-v20.x/api/process.html#processstdout) are both stream instances.
+ * There are many stream objects provided by Node.js. For instance, a [request to an HTTP server](https://nodejs.org/docs/latest-v24.x/api/http.html#class-httpincomingmessage)
+ * and [`process.stdout`](https://nodejs.org/docs/latest-v24.x/api/process.html#processstdout) are both stream instances.
  *
- * Streams can be readable, writable, or both. All streams are instances of [`EventEmitter`](https://nodejs.org/docs/latest-v20.x/api/events.html#class-eventemitter).
+ * Streams can be readable, writable, or both. All streams are instances of [`EventEmitter`](https://nodejs.org/docs/latest-v24.x/api/events.html#class-eventemitter).
  *
  * To access the `node:stream` module:
  *
@@ -15,7 +15,7 @@
  *
  * 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.13.1/lib/stream.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/stream.js)
  */
 declare module "stream" {
     import { Abortable, EventEmitter } from "node:events";
@@ -76,7 +76,6 @@ declare module "stream" {
             /**
              * A utility method for creating a `Readable` from a web `ReadableStream`.
              * @since v17.0.0
-             * @experimental
              */
             static fromWeb(
                 readableStream: streamWeb.ReadableStream,
@@ -85,7 +84,6 @@ declare module "stream" {
             /**
              * A utility method for creating a web `ReadableStream` from a `Readable`.
              * @since v17.0.0
-             * @experimental
              */
             static toWeb(
                 streamReadable: Readable,
@@ -101,7 +99,6 @@ declare module "stream" {
             /**
              * Returns whether the stream was destroyed or errored before emitting `'end'`.
              * @since v16.8.0
-             * @experimental
              */
             readonly readableAborted: boolean;
             /**
@@ -113,7 +110,6 @@ declare module "stream" {
             /**
              * Returns whether `'data'` has been emitted.
              * @since v16.7.0, v14.18.0
-             * @experimental
              */
             readonly readableDidRead: boolean;
             /**
@@ -122,13 +118,13 @@ declare module "stream" {
              */
             readonly readableEncoding: BufferEncoding | null;
             /**
-             * Becomes `true` when [`'end'`](https://nodejs.org/docs/latest-v20.x/api/stream.html#event-end) event is emitted.
+             * Becomes `true` when [`'end'`](https://nodejs.org/docs/latest-v24.x/api/stream.html#event-end) event is emitted.
              * @since v12.9.0
              */
             readonly readableEnded: boolean;
             /**
              * This property reflects the current state of a `Readable` stream as described
-             * in the [Three states](https://nodejs.org/docs/latest-v20.x/api/stream.html#three-states) section.
+             * in the [Three states](https://nodejs.org/docs/latest-v24.x/api/stream.html#three-states) section.
              * @since v9.4.0
              */
             readonly readableFlowing: boolean | null;
@@ -619,6 +615,17 @@ declare module "stream" {
              * @param error Error which will be passed as payload in `'error'` event
              */
             destroy(error?: Error): this;
+            /**
+             * @returns `AsyncIterator` to fully consume the stream.
+             * @since v10.0.0
+             */
+            [Symbol.asyncIterator](): NodeJS.AsyncIterator<any>;
+            /**
+             * Calls `readable.destroy()` with an `AbortError` and returns
+             * a promise that fulfills when the stream is finished.
+             * @since v20.4.0
+             */
+            [Symbol.asyncDispose](): Promise<void>;
             /**
              * Event emitter
              * The defined events on documents including:
@@ -686,12 +693,6 @@ declare module "stream" {
             removeListener(event: "readable", listener: () => void): this;
             removeListener(event: "resume", listener: () => void): this;
             removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            [Symbol.asyncIterator](): NodeJS.AsyncIterator<any>;
-            /**
-             * Calls `readable.destroy()` with an `AbortError` and returns a promise that fulfills when the stream is finished.
-             * @since v20.4.0
-             */
-            [Symbol.asyncDispose](): Promise<void>;
         }
         interface WritableOptions<T extends Writable = Writable> extends StreamOptions<T> {
             decodeStrings?: boolean | undefined;
@@ -723,7 +724,6 @@ declare module "stream" {
             /**
              * A utility method for creating a `Writable` from a web `WritableStream`.
              * @since v17.0.0
-             * @experimental
              */
             static fromWeb(
                 writableStream: streamWeb.WritableStream,
@@ -732,7 +732,6 @@ declare module "stream" {
             /**
              * A utility method for creating a web `WritableStream` from a `Writable`.
              * @since v17.0.0
-             * @experimental
              */
             static toWeb(streamWritable: Writable): streamWeb.WritableStream;
             /**
@@ -744,7 +743,6 @@ declare module "stream" {
             /**
              * Returns whether the stream was destroyed or errored before emitting `'finish'`.
              * @since v18.0.0, v16.17.0
-             * @experimental
              */
             readonly writableAborted: boolean;
             /**
@@ -968,6 +966,12 @@ declare module "stream" {
              * @param error Optional, an error to emit with `'error'` event.
              */
             destroy(error?: Error): this;
+            /**
+             * Calls `writable.destroy()` with an `AbortError` and returns
+             * a promise that fulfills when the stream is finished.
+             * @since v22.4.0, v20.16.0
+             */
+            [Symbol.asyncDispose](): Promise<void>;
             /**
              * Event emitter
              * The defined events on documents including:
@@ -1094,7 +1098,6 @@ declare module "stream" {
             /**
              * A utility method for creating a web `ReadableStream` and `WritableStream` from a `Duplex`.
              * @since v17.0.0
-             * @experimental
              */
             static toWeb(streamDuplex: Duplex): {
                 readable: streamWeb.ReadableStream;
@@ -1103,7 +1106,6 @@ declare module "stream" {
             /**
              * A utility method for creating a `Duplex` from a web `ReadableStream` and `WritableStream`.
              * @since v17.0.0
-             * @experimental
              */
             static fromWeb(
                 duplexStream: {
@@ -1232,7 +1234,7 @@ declare module "stream" {
          * difference in behavior.
          * @param options A value to pass to both {@link Duplex} constructors,
          * to set options such as buffering.
-         * @since v20.17.0
+         * @since v22.6.0
          */
         function duplexPair(options?: DuplexOptions): [Duplex, Duplex];
         type TransformCallback = (error?: Error | null, data?: any) => void;
@@ -1345,7 +1347,7 @@ declare module "stream" {
         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`.
+         * Defaults to `65536` (64 KiB), or `16` for `objectMode`.
          * @since v19.9.0
          */
         function getDefaultHighWaterMark(objectMode: boolean): number;
@@ -1386,7 +1388,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`](https://nodejs.org/docs/latest-v20.x/api/stream.html#streamfinishedstream-options).
+         * The `finished` API provides [`promise version`](https://nodejs.org/docs/latest-v24.x/api/stream.html#streamfinishedstream-options).
          *
          * `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
@@ -1474,7 +1476,7 @@ declare module "stream" {
          * );
          * ```
          *
-         * The `pipeline` API provides a [`promise version`](https://nodejs.org/docs/latest-v20.x/api/stream.html#streampipelinesource-transforms-destination-options).
+         * The `pipeline` API provides a [`promise version`](https://nodejs.org/docs/latest-v24.x/api/stream.html#streampipelinesource-transforms-destination-options).
          *
          * `stream.pipeline()` will call `stream.destroy(err)` on all streams except:
          *
@@ -1654,18 +1656,24 @@ declare module "stream" {
             ref(): void;
             unref(): void;
         }
+        // TODO: these should all take webstream arguments
         /**
          * Returns whether the stream has encountered an error.
          * @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, v16.14.0
-         * @experimental
+         * @returns Only returns `null` if `stream` is not a valid `Readable`, `Duplex` or `ReadableStream`.
+         */
+        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean | null;
+        /**
+         * Returns whether the stream is writable.
+         * @since v20.0.0
+         * @returns Only returns `null` if `stream` is not a valid `Writable`, `Duplex` or `WritableStream`.
          */
-        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean;
+        function isWritable(stream: Writable | NodeJS.WritableStream): boolean | null;
     }
     export = Stream;
 }

{node v20.19 → node v24.10}/string_decoder.d.ts

@@ -36,7 +36,7 @@
  * decoder.write(Buffer.from([0x82]));
  * console.log(decoder.end(Buffer.from([0xAC]))); // Prints: €
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/string_decoder.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/string_decoder.js)
  */
 declare module "string_decoder" {
     class StringDecoder {