@types/node 18.17.18 → 18.18.0

{node v18.17 → node v18.18}/stream.d.ts

@@ -16,12 +16,12 @@
  * 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)
  */
-declare module 'stream' {
-    import { EventEmitter, Abortable } from 'node:events';
+declare module "stream" {
+    import { Abortable, EventEmitter } from "node:events";
     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';
+    import * as streamPromises from "node:stream/promises";
+    import * as streamConsumers from "node:stream/consumers";
+    import * as streamWeb from "node:stream/web";
 
     type ComposeFnParam = (source: any) => void;
 
@@ -30,9 +30,12 @@ declare module 'stream' {
             destination: T,
             options?: {
                 end?: boolean | undefined;
-            }
+            },
+        ): T;
+        compose<T extends NodeJS.ReadableStream>(
+            stream: T | ComposeFnParam | Iterable<T> | AsyncIterable<T>,
+            options?: { signal: AbortSignal },
         ): T;
-        compose<T extends NodeJS.ReadableStream>(stream: T | ComposeFnParam | Iterable<T> | AsyncIterable<T>, options?: { signal: AbortSignal }): T;
     }
     namespace internal {
         class Stream extends internal {
@@ -69,7 +72,10 @@ declare module 'stream' {
              * @since v17.0.0
              * @experimental
              */
-            static fromWeb(readableStream: streamWeb.ReadableStream, options?: Pick<ReadableOptions, 'encoding' | 'highWaterMark' | 'objectMode' | 'signal'>): Readable;
+            static fromWeb(
+                readableStream: streamWeb.ReadableStream,
+                options?: Pick<ReadableOptions, "encoding" | "highWaterMark" | "objectMode" | "signal">,
+            ): Readable;
             /**
              * Returns whether the stream has been read from or cancelled.
              * @since v16.8.0
@@ -439,7 +445,7 @@ declare module 'stream' {
              * or exiting a `for await...of` iteration using a `break`, `return`, or `throw` will not destroy the stream.
              * **Default: `true`**.
              */
-            iterator(options?: {destroyOnReturn?: boolean}): AsyncIterableIterator<any>;
+            iterator(options?: { destroyOnReturn?: boolean }): AsyncIterableIterator<any>;
             /**
              * This method allows mapping over the stream. The *fn* function will be called for every chunk in the stream.
              * If the *fn* function returns a promise - that promise will be `await`ed before being passed to the result stream.
@@ -456,7 +462,10 @@ declare module 'stream' {
              * @param fn a function to filter chunks from the stream. Async or not.
              * @returns a stream filtered with the predicate *fn*.
              */
-            filter(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, options?: ArrayOptions): Readable;
+            filter(
+                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
+                options?: ArrayOptions,
+            ): Readable;
             /**
              * This method allows iterating a stream. For each chunk in the stream the *fn* function will be called.
              * If the *fn* function returns a promise - that promise will be `await`ed.
@@ -472,7 +481,10 @@ declare module 'stream' {
              * @param fn a function to call on each chunk of the stream. Async or not.
              * @returns a promise for when the stream has finished.
              */
-            forEach(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => void | Promise<void>, options?: ArrayOptions): Promise<void>;
+            forEach(
+                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => void | Promise<void>,
+                options?: ArrayOptions,
+            ): Promise<void>;
             /**
              * This method allows easily obtaining the contents of a stream.
              *
@@ -491,7 +503,10 @@ declare module 'stream' {
              * @param fn a function to call on each chunk of the stream. Async or not.
              * @returns a promise evaluating to `true` if *fn* returned a truthy value for at least one of the chunks.
              */
-            some(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, options?: ArrayOptions): Promise<boolean>;
+            some(
+                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
+                options?: ArrayOptions,
+            ): Promise<boolean>;
             /**
              * This method is similar to `Array.prototype.find` and calls *fn* on each chunk in the stream
              * to find a chunk with a truthy value for *fn*. Once an *fn* call's awaited return value is truthy,
@@ -502,8 +517,14 @@ declare module 'stream' {
              * @returns a promise evaluating to the first chunk for which *fn* evaluated with a truthy value,
              * or `undefined` if no element was found.
              */
-            find<T>(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => data is T, options?: ArrayOptions): Promise<T | undefined>;
-            find(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, options?: ArrayOptions): Promise<any>;
+            find<T>(
+                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => data is T,
+                options?: ArrayOptions,
+            ): Promise<T | undefined>;
+            find(
+                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
+                options?: ArrayOptions,
+            ): Promise<any>;
             /**
              * This method is similar to `Array.prototype.every` and calls *fn* on each chunk in the stream
              * to check if all awaited return values are truthy value for *fn*. Once an *fn* call on a chunk
@@ -513,7 +534,10 @@ declare module 'stream' {
              * @param fn a function to call on each chunk of the stream. Async or not.
              * @returns a promise evaluating to `true` if *fn* returned a truthy value for every one of the chunks.
              */
-            every(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>, options?: ArrayOptions): Promise<boolean>;
+            every(
+                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
+                options?: ArrayOptions,
+            ): Promise<boolean>;
             /**
              * This method returns a new stream by applying the given callback to each chunk of the stream
              * and then flattening the result.
@@ -560,8 +584,16 @@ declare module 'stream' {
              * @param initial the initial value to use in the reduction.
              * @returns a promise for the final value of the reduction.
              */
-            reduce<T = any>(fn: (previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T, initial?: undefined, options?: Pick<ArrayOptions, "signal">): Promise<T>;
-            reduce<T = any>(fn: (previous: T, data: any, options?: Pick<ArrayOptions, "signal">) => T, initial: T, options?: Pick<ArrayOptions, "signal">): Promise<T>;
+            reduce<T = any>(
+                fn: (previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T,
+                initial?: undefined,
+                options?: Pick<ArrayOptions, "signal">,
+            ): Promise<T>;
+            reduce<T = any>(
+                fn: (previous: T, data: any, options?: Pick<ArrayOptions, "signal">) => T,
+                initial: T,
+                options?: Pick<ArrayOptions, "signal">,
+            ): Promise<T>;
             _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
             /**
              * Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'`event (unless `emitClose` is set to `false`). After this call, the readable
@@ -586,75 +618,85 @@ declare module 'stream' {
              * 6. readable
              * 7. resume
              */
-            addListener(event: 'close', listener: () => void): this;
-            addListener(event: 'data', listener: (chunk: any) => void): this;
-            addListener(event: 'end', listener: () => void): this;
-            addListener(event: 'error', listener: (err: Error) => void): this;
-            addListener(event: 'pause', listener: () => void): this;
-            addListener(event: 'readable', listener: () => void): this;
-            addListener(event: 'resume', listener: () => void): this;
+            addListener(event: "close", listener: () => void): this;
+            addListener(event: "data", listener: (chunk: any) => void): this;
+            addListener(event: "end", listener: () => void): this;
+            addListener(event: "error", listener: (err: Error) => void): this;
+            addListener(event: "pause", listener: () => void): this;
+            addListener(event: "readable", listener: () => void): this;
+            addListener(event: "resume", listener: () => void): this;
             addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-            emit(event: 'close'): boolean;
-            emit(event: 'data', chunk: any): boolean;
-            emit(event: 'end'): boolean;
-            emit(event: 'error', err: Error): boolean;
-            emit(event: 'pause'): boolean;
-            emit(event: 'readable'): boolean;
-            emit(event: 'resume'): boolean;
+            emit(event: "close"): boolean;
+            emit(event: "data", chunk: any): boolean;
+            emit(event: "end"): boolean;
+            emit(event: "error", err: Error): boolean;
+            emit(event: "pause"): boolean;
+            emit(event: "readable"): boolean;
+            emit(event: "resume"): boolean;
             emit(event: string | symbol, ...args: any[]): boolean;
-            on(event: 'close', listener: () => void): this;
-            on(event: 'data', listener: (chunk: any) => void): this;
-            on(event: 'end', listener: () => void): this;
-            on(event: 'error', listener: (err: Error) => void): this;
-            on(event: 'pause', listener: () => void): this;
-            on(event: 'readable', listener: () => void): this;
-            on(event: 'resume', listener: () => void): this;
+            on(event: "close", listener: () => void): this;
+            on(event: "data", listener: (chunk: any) => void): this;
+            on(event: "end", listener: () => void): this;
+            on(event: "error", listener: (err: Error) => void): this;
+            on(event: "pause", listener: () => void): this;
+            on(event: "readable", listener: () => void): this;
+            on(event: "resume", listener: () => 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: 'end', listener: () => void): this;
-            once(event: 'error', listener: (err: Error) => void): this;
-            once(event: 'pause', listener: () => void): this;
-            once(event: 'readable', listener: () => void): this;
-            once(event: 'resume', listener: () => void): this;
+            once(event: "close", listener: () => void): this;
+            once(event: "data", listener: (chunk: any) => void): this;
+            once(event: "end", listener: () => void): this;
+            once(event: "error", listener: (err: Error) => void): this;
+            once(event: "pause", listener: () => void): this;
+            once(event: "readable", listener: () => void): this;
+            once(event: "resume", listener: () => 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: 'end', listener: () => void): this;
-            prependListener(event: 'error', listener: (err: Error) => void): this;
-            prependListener(event: 'pause', listener: () => void): this;
-            prependListener(event: 'readable', listener: () => void): this;
-            prependListener(event: 'resume', listener: () => void): this;
+            prependListener(event: "close", listener: () => void): this;
+            prependListener(event: "data", listener: (chunk: any) => void): this;
+            prependListener(event: "end", listener: () => void): this;
+            prependListener(event: "error", listener: (err: Error) => void): this;
+            prependListener(event: "pause", listener: () => void): this;
+            prependListener(event: "readable", listener: () => void): this;
+            prependListener(event: "resume", listener: () => 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: 'end', listener: () => void): this;
-            prependOnceListener(event: 'error', listener: (err: Error) => void): this;
-            prependOnceListener(event: 'pause', listener: () => void): this;
-            prependOnceListener(event: 'readable', listener: () => void): this;
-            prependOnceListener(event: 'resume', listener: () => void): this;
+            prependOnceListener(event: "close", listener: () => void): this;
+            prependOnceListener(event: "data", listener: (chunk: any) => void): this;
+            prependOnceListener(event: "end", listener: () => void): this;
+            prependOnceListener(event: "error", listener: (err: Error) => void): this;
+            prependOnceListener(event: "pause", listener: () => void): this;
+            prependOnceListener(event: "readable", listener: () => void): this;
+            prependOnceListener(event: "resume", listener: () => 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: 'end', listener: () => void): this;
-            removeListener(event: 'error', listener: (err: Error) => void): this;
-            removeListener(event: 'pause', listener: () => void): this;
-            removeListener(event: 'readable', listener: () => void): this;
-            removeListener(event: 'resume', listener: () => void): this;
+            removeListener(event: "close", listener: () => void): this;
+            removeListener(event: "data", listener: (chunk: any) => void): this;
+            removeListener(event: "end", listener: () => void): this;
+            removeListener(event: "error", listener: (err: Error) => void): this;
+            removeListener(event: "pause", listener: () => void): this;
+            removeListener(event: "readable", listener: () => void): this;
+            removeListener(event: "resume", listener: () => void): this;
             removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
             [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+            /**
+             * Calls `readable.destroy()` with an `AbortError` and returns a promise that fulfills when the stream is finished.
+             * @since v18.18.0
+             */
+            [Symbol.asyncDispose](): Promise<void>;
         }
         interface WritableOptions extends StreamOptions<Writable> {
             decodeStrings?: boolean | undefined;
             defaultEncoding?: BufferEncoding | undefined;
-            write?(this: Writable, chunk: any, encoding: BufferEncoding, 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
+                callback: (error?: Error | null) => void,
             ): void;
             final?(this: Writable, callback: (error?: Error | null) => void): void;
         }
@@ -667,7 +709,10 @@ declare module 'stream' {
              * @since v17.0.0
              * @experimental
              */
-            static fromWeb(writableStream: streamWeb.WritableStream, options?: Pick<WritableOptions, 'decodeStrings' | 'highWaterMark' | 'objectMode' | 'signal'>): Writable;
+            static fromWeb(
+                writableStream: streamWeb.WritableStream,
+                options?: Pick<WritableOptions, "decodeStrings" | "highWaterMark" | "objectMode" | "signal">,
+            ): Writable;
             /**
              * A utility method for creating a web `WritableStream` from a `Writable`.
              * @since v17.0.0
@@ -741,7 +786,7 @@ declare module 'stream' {
                     chunk: any;
                     encoding: BufferEncoding;
                 }>,
-                callback: (error?: Error | null) => void
+                callback: (error?: Error | null) => void,
             ): void;
             _construct?(callback: (error?: Error | null) => void): void;
             _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
@@ -911,54 +956,54 @@ declare module 'stream' {
              * 5. pipe
              * 6. unpipe
              */
-            addListener(event: 'close', listener: () => void): this;
-            addListener(event: 'drain', listener: () => void): this;
-            addListener(event: 'error', listener: (err: Error) => void): this;
-            addListener(event: 'finish', listener: () => void): this;
-            addListener(event: 'pipe', listener: (src: Readable) => void): this;
-            addListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            addListener(event: "close", listener: () => void): this;
+            addListener(event: "drain", listener: () => void): this;
+            addListener(event: "error", listener: (err: Error) => void): this;
+            addListener(event: "finish", listener: () => void): this;
+            addListener(event: "pipe", listener: (src: Readable) => 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: 'drain'): boolean;
-            emit(event: 'error', err: Error): boolean;
-            emit(event: 'finish'): boolean;
-            emit(event: 'pipe', src: Readable): boolean;
-            emit(event: 'unpipe', src: Readable): boolean;
+            emit(event: "close"): boolean;
+            emit(event: "drain"): boolean;
+            emit(event: "error", err: Error): boolean;
+            emit(event: "finish"): boolean;
+            emit(event: "pipe", src: Readable): boolean;
+            emit(event: "unpipe", src: Readable): boolean;
             emit(event: string | symbol, ...args: any[]): boolean;
-            on(event: 'close', listener: () => void): this;
-            on(event: 'drain', listener: () => void): this;
-            on(event: 'error', listener: (err: Error) => void): this;
-            on(event: 'finish', listener: () => void): this;
-            on(event: 'pipe', listener: (src: Readable) => void): this;
-            on(event: 'unpipe', listener: (src: Readable) => void): this;
+            on(event: "close", listener: () => void): this;
+            on(event: "drain", listener: () => void): this;
+            on(event: "error", listener: (err: Error) => void): this;
+            on(event: "finish", listener: () => void): this;
+            on(event: "pipe", listener: (src: Readable) => 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: 'drain', listener: () => void): this;
-            once(event: 'error', listener: (err: Error) => void): this;
-            once(event: 'finish', listener: () => void): this;
-            once(event: 'pipe', listener: (src: Readable) => void): this;
-            once(event: 'unpipe', listener: (src: Readable) => void): this;
+            once(event: "close", listener: () => void): this;
+            once(event: "drain", listener: () => void): this;
+            once(event: "error", listener: (err: Error) => void): this;
+            once(event: "finish", listener: () => void): this;
+            once(event: "pipe", listener: (src: Readable) => 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: 'drain', listener: () => void): this;
-            prependListener(event: 'error', listener: (err: Error) => void): this;
-            prependListener(event: 'finish', listener: () => void): this;
-            prependListener(event: 'pipe', listener: (src: Readable) => void): this;
-            prependListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            prependListener(event: "close", listener: () => void): this;
+            prependListener(event: "drain", listener: () => void): this;
+            prependListener(event: "error", listener: (err: Error) => void): this;
+            prependListener(event: "finish", listener: () => void): this;
+            prependListener(event: "pipe", listener: (src: Readable) => 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: 'drain', listener: () => void): this;
-            prependOnceListener(event: 'error', listener: (err: Error) => void): this;
-            prependOnceListener(event: 'finish', listener: () => void): this;
-            prependOnceListener(event: 'pipe', listener: (src: Readable) => void): this;
-            prependOnceListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            prependOnceListener(event: "close", listener: () => void): this;
+            prependOnceListener(event: "drain", listener: () => void): this;
+            prependOnceListener(event: "error", listener: (err: Error) => void): this;
+            prependOnceListener(event: "finish", listener: () => void): this;
+            prependOnceListener(event: "pipe", listener: (src: Readable) => 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: 'drain', listener: () => void): this;
-            removeListener(event: 'error', listener: (err: Error) => void): this;
-            removeListener(event: 'finish', listener: () => void): this;
-            removeListener(event: 'pipe', listener: (src: Readable) => void): this;
-            removeListener(event: 'unpipe', listener: (src: Readable) => void): this;
+            removeListener(event: "close", listener: () => void): this;
+            removeListener(event: "drain", listener: () => void): this;
+            removeListener(event: "error", listener: (err: Error) => void): this;
+            removeListener(event: "finish", listener: () => void): this;
+            removeListener(event: "pipe", listener: (src: Readable) => void): this;
+            removeListener(event: "unpipe", listener: (src: Readable) => void): this;
             removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
         }
         interface DuplexOptions extends ReadableOptions, WritableOptions {
@@ -977,7 +1022,7 @@ declare module 'stream' {
                     chunk: any;
                     encoding: BufferEncoding;
                 }>,
-                callback: (error?: Error | null) => void
+                callback: (error?: Error | null) => void,
             ): void;
             final?(this: Duplex, callback: (error?: Error | null) => void): void;
             destroy?(this: Duplex, error: Error | null, callback: (error: Error | null) => void): void;
@@ -1035,14 +1080,25 @@ declare module 'stream' {
              *
              * @since v16.8.0
              */
-            static from(src: Stream | NodeBlob | ArrayBuffer | string | Iterable<any> | AsyncIterable<any> | AsyncGeneratorFunction | Promise<any> | Object): Duplex;
+            static from(
+                src:
+                    | Stream
+                    | NodeBlob
+                    | ArrayBuffer
+                    | string
+                    | Iterable<any>
+                    | AsyncIterable<any>
+                    | AsyncGeneratorFunction
+                    | Promise<any>
+                    | Object,
+            ): Duplex;
             _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
             _writev?(
                 chunks: Array<{
                     chunk: any;
                     encoding: BufferEncoding;
                 }>,
-                callback: (error?: Error | null) => void
+                callback: (error?: Error | null) => void,
             ): void;
             _destroy(error: Error | null, callback: (error: Error | null) => void): void;
             _final(callback: (error?: Error | null) => void): void;
@@ -1069,103 +1125,108 @@ declare module 'stream' {
              * 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: "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: "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: "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: "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: "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: "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: "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 {
             construct?(this: Transform, callback: (error?: Error | null) => void): void;
             read?(this: Transform, size: number): void;
-            write?(this: Transform, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+            write?(
+                this: Transform,
+                chunk: any,
+                encoding: BufferEncoding,
+                callback: (error?: Error | null) => void,
+            ): void;
             writev?(
                 this: Transform,
                 chunks: Array<{
                     chunk: any;
                     encoding: BufferEncoding;
                 }>,
-                callback: (error?: Error | null) => void
+                callback: (error?: Error | null) => void,
             ): void;
             final?(this: Transform, callback: (error?: Error | null) => void): void;
             destroy?(this: Transform, error: Error | null, callback: (error: Error | null) => void): void;
@@ -1314,26 +1375,43 @@ declare module 'stream' {
          * @param callback A callback function that takes an optional error argument.
          * @return A cleanup function which removes all registered listeners.
          */
-        function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, options: FinishedOptions, callback: (err?: NodeJS.ErrnoException | null) => void): () => void;
-        function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, callback: (err?: NodeJS.ErrnoException | null) => void): () => void;
+        function finished(
+            stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
+            options: FinishedOptions,
+            callback: (err?: NodeJS.ErrnoException | null) => void,
+        ): () => void;
+        function finished(
+            stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
+            callback: (err?: NodeJS.ErrnoException | null) => void,
+        ): () => void;
         namespace finished {
-            function __promisify__(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, options?: FinishedOptions): Promise<void>;
+            function __promisify__(
+                stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
+                options?: FinishedOptions,
+            ): Promise<void>;
         }
         type PipelineSourceFunction<T> = () => Iterable<T> | AsyncIterable<T>;
         type PipelineSource<T> = Iterable<T> | AsyncIterable<T> | NodeJS.ReadableStream | PipelineSourceFunction<T>;
         type PipelineTransform<S extends PipelineTransformSource<any>, U> =
             | NodeJS.ReadWriteStream
-            | ((source: S extends (...args: any[]) => Iterable<infer ST> | AsyncIterable<infer ST> ? AsyncIterable<ST> : S) => AsyncIterable<U>);
+            | ((
+                source: S extends (...args: any[]) => Iterable<infer ST> | AsyncIterable<infer ST> ? AsyncIterable<ST>
+                    : S,
+            ) => AsyncIterable<U>);
         type PipelineTransformSource<T> = PipelineSource<T> | PipelineTransform<any, T>;
         type PipelineDestinationIterableFunction<T> = (source: AsyncIterable<T>) => AsyncIterable<any>;
         type PipelineDestinationPromiseFunction<T, P> = (source: AsyncIterable<T>) => Promise<P>;
-        type PipelineDestination<S extends PipelineTransformSource<any>, P> = S extends PipelineTransformSource<infer ST>
-            ? NodeJS.WritableStream | PipelineDestinationIterableFunction<ST> | PipelineDestinationPromiseFunction<ST, P>
+        type PipelineDestination<S extends PipelineTransformSource<any>, P> = S extends
+            PipelineTransformSource<infer ST> ?
+                | NodeJS.WritableStream
+                | PipelineDestinationIterableFunction<ST>
+                | PipelineDestinationPromiseFunction<ST, P>
             : never;
-        type PipelineCallback<S extends PipelineDestination<any, any>> = S extends PipelineDestinationPromiseFunction<any, infer P>
-            ? (err: NodeJS.ErrnoException | null, value: P) => void
+        type PipelineCallback<S extends PipelineDestination<any, any>> = S extends
+            PipelineDestinationPromiseFunction<any, infer P> ? (err: NodeJS.ErrnoException | null, value: P) => void
             : (err: NodeJS.ErrnoException | null) => void;
-        type PipelinePromise<S extends PipelineDestination<any, any>> = S extends PipelineDestinationPromiseFunction<any, infer P> ? Promise<P> : Promise<void>;
+        type PipelinePromise<S extends PipelineDestination<any, any>> = S extends
+            PipelineDestinationPromiseFunction<any, infer P> ? Promise<P> : Promise<void>;
         interface PipelineOptions {
             signal?: AbortSignal | undefined;
             end?: boolean | undefined;
@@ -1490,76 +1568,133 @@ declare module 'stream' {
         function pipeline<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(
             source: A,
             destination: B,
-            callback?: PipelineCallback<B>
+            callback?: PipelineCallback<B>,
         ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
-        function pipeline<A extends PipelineSource<any>, T1 extends PipelineTransform<A, any>, B extends PipelineDestination<T1, any>>(
+        function pipeline<
+            A extends PipelineSource<any>,
+            T1 extends PipelineTransform<A, any>,
+            B extends PipelineDestination<T1, any>,
+        >(
             source: A,
             transform1: T1,
             destination: B,
-            callback?: PipelineCallback<B>
+            callback?: PipelineCallback<B>,
         ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
-        function pipeline<A extends PipelineSource<any>, T1 extends PipelineTransform<A, any>, T2 extends PipelineTransform<T1, any>, B extends PipelineDestination<T2, any>>(
+        function pipeline<
+            A extends PipelineSource<any>,
+            T1 extends PipelineTransform<A, any>,
+            T2 extends PipelineTransform<T1, any>,
+            B extends PipelineDestination<T2, any>,
+        >(
             source: A,
             transform1: T1,
             transform2: T2,
             destination: B,
-            callback?: PipelineCallback<B>
+            callback?: PipelineCallback<B>,
         ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
         function pipeline<
             A extends PipelineSource<any>,
             T1 extends PipelineTransform<A, any>,
             T2 extends PipelineTransform<T1, any>,
             T3 extends PipelineTransform<T2, any>,
-            B extends PipelineDestination<T3, any>
-        >(source: A, transform1: T1, transform2: T2, transform3: T3, destination: B, callback?: PipelineCallback<B>): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
+            B extends PipelineDestination<T3, any>,
+        >(
+            source: A,
+            transform1: T1,
+            transform2: T2,
+            transform3: T3,
+            destination: B,
+            callback?: PipelineCallback<B>,
+        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
         function pipeline<
             A extends PipelineSource<any>,
             T1 extends PipelineTransform<A, any>,
             T2 extends PipelineTransform<T1, any>,
             T3 extends PipelineTransform<T2, any>,
             T4 extends PipelineTransform<T3, any>,
-            B extends PipelineDestination<T4, any>
-        >(source: A, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: B, callback?: PipelineCallback<B>): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
+            B extends PipelineDestination<T4, any>,
+        >(
+            source: A,
+            transform1: T1,
+            transform2: T2,
+            transform3: T3,
+            transform4: T4,
+            destination: B,
+            callback?: PipelineCallback<B>,
+        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
         function pipeline(
             streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,
-            callback?: (err: NodeJS.ErrnoException | null) => void
+            callback?: (err: NodeJS.ErrnoException | null) => void,
         ): NodeJS.WritableStream;
         function pipeline(
             stream1: NodeJS.ReadableStream,
             stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
-            ...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | ((err: NodeJS.ErrnoException | null) => void)>
+            ...streams: Array<
+                NodeJS.ReadWriteStream | NodeJS.WritableStream | ((err: NodeJS.ErrnoException | null) => void)
+            >
         ): NodeJS.WritableStream;
         namespace pipeline {
-            function __promisify__<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(source: A, destination: B, options?: PipelineOptions): PipelinePromise<B>;
-            function __promisify__<A extends PipelineSource<any>, T1 extends PipelineTransform<A, any>, B extends PipelineDestination<T1, any>>(
+            function __promisify__<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(
+                source: A,
+                destination: B,
+                options?: PipelineOptions,
+            ): PipelinePromise<B>;
+            function __promisify__<
+                A extends PipelineSource<any>,
+                T1 extends PipelineTransform<A, any>,
+                B extends PipelineDestination<T1, any>,
+            >(
                 source: A,
                 transform1: T1,
                 destination: B,
-                options?: PipelineOptions
+                options?: PipelineOptions,
             ): PipelinePromise<B>;
-            function __promisify__<A extends PipelineSource<any>, T1 extends PipelineTransform<A, any>, T2 extends PipelineTransform<T1, any>, B extends PipelineDestination<T2, any>>(
+            function __promisify__<
+                A extends PipelineSource<any>,
+                T1 extends PipelineTransform<A, any>,
+                T2 extends PipelineTransform<T1, any>,
+                B extends PipelineDestination<T2, any>,
+            >(
                 source: A,
                 transform1: T1,
                 transform2: T2,
                 destination: B,
-                options?: PipelineOptions
+                options?: PipelineOptions,
             ): PipelinePromise<B>;
             function __promisify__<
                 A extends PipelineSource<any>,
                 T1 extends PipelineTransform<A, any>,
                 T2 extends PipelineTransform<T1, any>,
                 T3 extends PipelineTransform<T2, any>,
-                B extends PipelineDestination<T3, any>
-            >(source: A, transform1: T1, transform2: T2, transform3: T3, destination: B, options?: PipelineOptions): PipelinePromise<B>;
+                B extends PipelineDestination<T3, any>,
+            >(
+                source: A,
+                transform1: T1,
+                transform2: T2,
+                transform3: T3,
+                destination: B,
+                options?: PipelineOptions,
+            ): PipelinePromise<B>;
             function __promisify__<
                 A extends PipelineSource<any>,
                 T1 extends PipelineTransform<A, any>,
                 T2 extends PipelineTransform<T1, any>,
                 T3 extends PipelineTransform<T2, any>,
                 T4 extends PipelineTransform<T3, any>,
-                B extends PipelineDestination<T4, any>
-            >(source: A, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: B, options?: PipelineOptions): PipelinePromise<B>;
-            function __promisify__(streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>, options?: PipelineOptions): Promise<void>;
+                B extends PipelineDestination<T4, any>,
+            >(
+                source: A,
+                transform1: T1,
+                transform2: T2,
+                transform3: T3,
+                transform4: T4,
+                destination: B,
+                options?: PipelineOptions,
+            ): PipelinePromise<B>;
+            function __promisify__(
+                streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,
+                options?: PipelineOptions,
+            ): Promise<void>;
             function __promisify__(
                 stream1: NodeJS.ReadableStream,
                 stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
@@ -1590,7 +1725,7 @@ declare module 'stream' {
     }
     export = internal;
 }
-declare module 'node:stream' {
-    import stream = require('stream');
+declare module "node:stream" {
+    import stream = require("stream");
     export = stream;
 }