@runlith/tagma 0.0.0-stage → 0.2.3

package/types/node/stream.d.ts

@@ -0,0 +1,378 @@
+declare module "node:stream" {
+    import { Blob } from "node:buffer";
+    import { Abortable, EventEmitter } from "node:events";
+    import * as promises from "node:stream/promises";
+    import * as web from "node:stream/web";
+    class Stream extends EventEmitter {
+        pipe<T extends NodeJS.WritableStream>(destination: T, options?: Stream.PipeOptions): T;
+    }
+    namespace Stream {
+        export { promises, Stream };
+    }
+    namespace Stream {
+        interface PipeOptions {
+            end?: boolean | undefined;
+        }
+        interface StreamOptions<T extends Stream> extends Abortable {
+            emitClose?: boolean | undefined;
+            highWaterMark?: number | undefined;
+            objectMode?: boolean | undefined;
+            construct?: ((this: T, callback: (error?: Error | null) => void) => void) | undefined;
+            destroy?: ((this: T, error: Error | null, callback: (error?: Error | null) => void) => void) | undefined;
+            autoDestroy?: boolean | undefined;
+        }
+        interface ReadableOptions<T extends Readable = Readable> extends StreamOptions<T> {
+            encoding?: BufferEncoding | undefined;
+            read?: ((this: T, size: number) => void) | undefined;
+        }
+        interface ReadableIteratorOptions {
+            destroyOnReturn?: boolean | undefined;
+        }
+        interface ReadableOperatorOptions extends Abortable {
+            concurrency?: number | undefined;
+            highWaterMark?: number | undefined;
+        }
+        interface ArrayOptions extends ReadableOperatorOptions {
+        }
+        interface ReadableToWebOptions {
+            strategy?: web.QueuingStrategy | undefined;
+            type?: web.ReadableStreamType | undefined;
+        }
+        interface ReadableEventMap {
+            "close": [
+            ];
+            "data": [
+                chunk: any
+            ];
+            "end": [
+            ];
+            "error": [
+                err: Error
+            ];
+            "pause": [
+            ];
+            "readable": [
+            ];
+            "resume": [
+            ];
+        }
+        class Readable extends Stream implements NodeJS.ReadableStream {
+            constructor(options?: ReadableOptions);
+            static from(iterable: Iterable<any> | AsyncIterable<any>, options?: ReadableOptions): Readable;
+            static fromWeb(readableStream: web.ReadableStream, options?: Pick<ReadableOptions, "encoding" | "highWaterMark" | "objectMode" | "signal">): Readable;
+            static toWeb(streamReadable: NodeJS.ReadableStream, options?: ReadableToWebOptions): web.ReadableStream;
+            static isDisturbed(stream: NodeJS.ReadableStream | web.ReadableStream): boolean;
+            readonly readableAborted: boolean;
+            readable: boolean;
+            readonly readableDidRead: boolean;
+            readonly readableEncoding: BufferEncoding | null;
+            readonly readableEnded: boolean;
+            readableFlowing: boolean | null;
+            readonly readableHighWaterMark: number;
+            readonly readableLength: number;
+            readonly readableObjectMode: boolean;
+            destroyed: boolean;
+            readonly closed: boolean;
+            readonly errored: Error | null;
+            _construct?(callback: (error?: Error | null) => void): void;
+            _read(size: number): void;
+            read(size?: number): any;
+            setEncoding(encoding: BufferEncoding): this;
+            pause(): this;
+            resume(): this;
+            isPaused(): boolean;
+            unpipe(destination?: NodeJS.WritableStream): this;
+            unshift(chunk: any, encoding?: BufferEncoding): void;
+            wrap(stream: NodeJS.ReadableStream): this;
+            push(chunk: any, encoding?: BufferEncoding): boolean;
+            compose(stream: NodeJS.WritableStream | web.WritableStream | web.TransformStream | ((source: any) => void), options?: Abortable): Duplex;
+            iterator(options?: ReadableIteratorOptions): NodeJS.AsyncIterator<any>;
+            map(fn: (data: any, options?: Abortable) => any, options?: ReadableOperatorOptions): Readable;
+            filter(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: ReadableOperatorOptions): Readable;
+            forEach(fn: (data: any, options?: Abortable) => void | Promise<void>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<void>;
+            toArray(options?: Abortable): Promise<any[]>;
+            some(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>;
+            find<T>(fn: (data: any, options?: Abortable) => data is T, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<T | undefined>;
+            find(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<any>;
+            every(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>;
+            flatMap(fn: (data: any, options?: Abortable) => any, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Readable;
+            drop(limit: number, options?: Abortable): Readable;
+            take(limit: number, options?: Abortable): Readable;
+            reduce<T>(fn: (previous: any, data: any, options?: Abortable) => T): Promise<T>;
+            reduce<T>(fn: (previous: T, data: any, options?: Abortable) => T, initial: T, options?: Abortable): Promise<T>;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            destroy(error?: Error): this;
+            [Symbol.asyncIterator](): NodeJS.AsyncIterator<any>;
+            [Symbol.asyncDispose](): Promise<void>;
+            addListener<E extends keyof ReadableEventMap>(eventName: E, listener: (...args: ReadableEventMap[E]) => void): this;
+            addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            emit<E extends keyof ReadableEventMap>(eventName: E, ...args: ReadableEventMap[E]): boolean;
+            emit(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<E extends keyof ReadableEventMap>(eventName: E, listener?: (...args: ReadableEventMap[E]) => void): number;
+            listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+            listeners<E extends keyof ReadableEventMap>(eventName: E): ((...args: ReadableEventMap[E]) => void)[];
+            listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            off<E extends keyof ReadableEventMap>(eventName: E, listener: (...args: ReadableEventMap[E]) => void): this;
+            off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            on<E extends keyof ReadableEventMap>(eventName: E, listener: (...args: ReadableEventMap[E]) => void): this;
+            on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            once<E extends keyof ReadableEventMap>(eventName: E, listener: (...args: ReadableEventMap[E]) => void): this;
+            once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener<E extends keyof ReadableEventMap>(eventName: E, listener: (...args: ReadableEventMap[E]) => void): this;
+            prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener<E extends keyof ReadableEventMap>(eventName: E, listener: (...args: ReadableEventMap[E]) => void): this;
+            prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            rawListeners<E extends keyof ReadableEventMap>(eventName: E): ((...args: ReadableEventMap[E]) => void)[];
+            rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            removeAllListeners<E extends keyof ReadableEventMap>(eventName?: E): this;
+            removeAllListeners(eventName?: string | symbol): this;
+            removeListener<E extends keyof ReadableEventMap>(eventName: E, listener: (...args: ReadableEventMap[E]) => void): this;
+            removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        }
+        interface WritableOptions<T extends Writable = Writable> extends StreamOptions<T> {
+            decodeStrings?: boolean | undefined;
+            defaultEncoding?: BufferEncoding | undefined;
+            write?: ((this: T, chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void) => void) | undefined;
+            writev?: ((this: T, chunks: {
+                chunk: any;
+                encoding: BufferEncoding;
+            }[], callback: (error?: Error | null) => void) => void) | undefined;
+            final?: ((this: T, callback: (error?: Error | null) => void) => void) | undefined;
+        }
+        interface WritableEventMap {
+            "close": [
+            ];
+            "drain": [
+            ];
+            "error": [
+                err: Error
+            ];
+            "finish": [
+            ];
+            "pipe": [
+                src: Readable
+            ];
+            "unpipe": [
+                src: Readable
+            ];
+        }
+        class Writable extends Stream implements NodeJS.WritableStream {
+            constructor(options?: WritableOptions);
+            static fromWeb(writableStream: web.WritableStream, options?: Pick<WritableOptions, "decodeStrings" | "highWaterMark" | "objectMode" | "signal">): Writable;
+            static toWeb(streamWritable: NodeJS.WritableStream): web.WritableStream;
+            writable: boolean;
+            readonly writableAborted: boolean;
+            readonly writableEnded: boolean;
+            readonly writableFinished: boolean;
+            readonly writableHighWaterMark: number;
+            readonly writableLength: number;
+            readonly writableObjectMode: boolean;
+            readonly writableCorked: number;
+            destroyed: boolean;
+            readonly closed: boolean;
+            readonly errored: Error | null;
+            readonly writableNeedDrain: boolean;
+            _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+            _writev?(chunks: {
+                chunk: any;
+                encoding: BufferEncoding;
+            }[], callback: (error?: Error | null) => void): void;
+            _construct?(callback: (error?: Error | null) => void): void;
+            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+            _final(callback: (error?: Error | null) => void): void;
+            write(chunk: any, callback?: (error: Error | null | undefined) => void): boolean;
+            write(chunk: any, encoding: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean;
+            setDefaultEncoding(encoding: BufferEncoding): this;
+            end(cb?: () => void): this;
+            end(chunk: any, cb?: () => void): this;
+            end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
+            cork(): void;
+            uncork(): void;
+            destroy(error?: Error): this;
+            [Symbol.asyncDispose](): Promise<void>;
+            addListener<E extends keyof WritableEventMap>(eventName: E, listener: (...args: WritableEventMap[E]) => void): this;
+            addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            emit<E extends keyof WritableEventMap>(eventName: E, ...args: WritableEventMap[E]): boolean;
+            emit(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<E extends keyof WritableEventMap>(eventName: E, listener?: (...args: WritableEventMap[E]) => void): number;
+            listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+            listeners<E extends keyof WritableEventMap>(eventName: E): ((...args: WritableEventMap[E]) => void)[];
+            listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            off<E extends keyof WritableEventMap>(eventName: E, listener: (...args: WritableEventMap[E]) => void): this;
+            off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            on<E extends keyof WritableEventMap>(eventName: E, listener: (...args: WritableEventMap[E]) => void): this;
+            on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            once<E extends keyof WritableEventMap>(eventName: E, listener: (...args: WritableEventMap[E]) => void): this;
+            once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener<E extends keyof WritableEventMap>(eventName: E, listener: (...args: WritableEventMap[E]) => void): this;
+            prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener<E extends keyof WritableEventMap>(eventName: E, listener: (...args: WritableEventMap[E]) => void): this;
+            prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            rawListeners<E extends keyof WritableEventMap>(eventName: E): ((...args: WritableEventMap[E]) => void)[];
+            rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            removeAllListeners<E extends keyof WritableEventMap>(eventName?: E): this;
+            removeAllListeners(eventName?: string | symbol): this;
+            removeListener<E extends keyof WritableEventMap>(eventName: E, listener: (...args: WritableEventMap[E]) => void): this;
+            removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        }
+        interface DuplexOptions<T extends Duplex = Duplex> extends ReadableOptions<T>, WritableOptions<T> {
+            allowHalfOpen?: boolean | undefined;
+            readableObjectMode?: boolean | undefined;
+            writableObjectMode?: boolean | undefined;
+            readableHighWaterMark?: number | undefined;
+            writableHighWaterMark?: number | undefined;
+            writableCorked?: number | undefined;
+        }
+        interface DuplexToWebOptions {
+            readableType?: web.ReadableStreamType | undefined;
+        }
+        interface DuplexEventMap extends ReadableEventMap, WritableEventMap {
+        }
+        class Duplex extends Stream implements NodeJS.ReadWriteStream {
+            constructor(options?: DuplexOptions);
+            static from(src: NodeJS.ReadableStream | NodeJS.WritableStream | Blob | string | Iterable<any> | AsyncIterable<any> | ((source: AsyncIterable<any>) => AsyncIterable<any>) | ((source: AsyncIterable<any>) => Promise<void>) | Promise<any> | web.ReadableWritablePair | web.ReadableStream | web.WritableStream): Duplex;
+            static toWeb(streamDuplex: NodeJS.ReadWriteStream, options?: DuplexToWebOptions): web.ReadableWritablePair;
+            static fromWeb(duplexStream: web.ReadableWritablePair, options?: Pick<DuplexOptions, "allowHalfOpen" | "decodeStrings" | "encoding" | "highWaterMark" | "objectMode" | "signal">): Duplex;
+            allowHalfOpen: boolean;
+            addListener<E extends keyof DuplexEventMap>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this;
+            addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            emit<E extends keyof DuplexEventMap>(eventName: E, ...args: DuplexEventMap[E]): boolean;
+            emit(eventName: string | symbol, ...args: any[]): boolean;
+            listenerCount<E extends keyof DuplexEventMap>(eventName: E, listener?: (...args: DuplexEventMap[E]) => void): number;
+            listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+            listeners<E extends keyof DuplexEventMap>(eventName: E): ((...args: DuplexEventMap[E]) => void)[];
+            listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            off<E extends keyof DuplexEventMap>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this;
+            off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            on<E extends keyof DuplexEventMap>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this;
+            on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            once<E extends keyof DuplexEventMap>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this;
+            once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependListener<E extends keyof DuplexEventMap>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this;
+            prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            prependOnceListener<E extends keyof DuplexEventMap>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this;
+            prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            rawListeners<E extends keyof DuplexEventMap>(eventName: E): ((...args: DuplexEventMap[E]) => void)[];
+            rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+            removeAllListeners<E extends keyof DuplexEventMap>(eventName?: E): this;
+            removeAllListeners(eventName?: string | symbol): this;
+            removeListener<E extends keyof DuplexEventMap>(eventName: E, listener: (...args: DuplexEventMap[E]) => void): this;
+            removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        }
+        interface Duplex extends Readable, Writable {
+        }
+        function duplexPair(options?: DuplexOptions): [
+            Duplex,
+            Duplex
+        ];
+        type TransformCallback = (error?: Error | null, data?: any) => void;
+        interface TransformOptions<T extends Transform = Transform> extends DuplexOptions<T> {
+            transform?: ((this: T, chunk: any, encoding: BufferEncoding, callback: TransformCallback) => void) | undefined;
+            flush?: ((this: T, callback: TransformCallback) => void) | undefined;
+        }
+        class Transform extends Duplex {
+            constructor(options?: TransformOptions);
+            _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
+            _flush(callback: TransformCallback): void;
+        }
+        class PassThrough extends Transform {
+        }
+        function addAbortSignal<T extends NodeJS.ReadableStream | NodeJS.WritableStream | web.ReadableStream | web.WritableStream>(signal: AbortSignal, stream: T): T;
+        function getDefaultHighWaterMark(objectMode: boolean): number;
+        function setDefaultHighWaterMark(objectMode: boolean, value: number): void;
+        interface FinishedOptions extends Abortable {
+            error?: boolean | undefined;
+            readable?: boolean | undefined;
+            writable?: boolean | undefined;
+        }
+        function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | web.ReadableStream | web.WritableStream, options: FinishedOptions, callback: (err?: NodeJS.ErrnoException | null) => void): () => void;
+        function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | web.ReadableStream | web.WritableStream, callback: (err?: NodeJS.ErrnoException | null) => void): () => void;
+        namespace finished {
+            import __promisify__ = promises.finished;
+            export { __promisify__ };
+        }
+        type PipelineSourceFunction<O> = (options?: Abortable) => Iterable<O> | AsyncIterable<O>;
+        type PipelineSource<O> = NodeJS.ReadableStream | web.ReadableStream<O> | web.TransformStream<any, O> | Iterable<O> | AsyncIterable<O> | PipelineSourceFunction<O>;
+        type PipelineSourceArgument<T> = (T extends (...args: any[]) => infer R ? R : T) extends infer S ? S extends web.TransformStream<any, infer O> ? web.ReadableStream<O> : S : never;
+        type PipelineTransformGenerator<S extends PipelineTransformSource<any>, O> = (source: PipelineSourceArgument<S>, options?: Abortable) => AsyncIterable<O>;
+        type PipelineTransformStreams<I, O> = NodeJS.ReadWriteStream | web.TransformStream<I, O>;
+        type PipelineTransform<S extends PipelineTransformSource<any>, O> = S extends PipelineSource<infer I> | PipelineTransformStreams<any, infer I> | ((...args: any[]) => infer I) ? PipelineTransformStreams<I, O> | PipelineTransformGenerator<S, O> : never;
+        type PipelineTransformSource<O> = PipelineSource<O> | PipelineTransform<any, O>;
+        type PipelineDestinationFunction<S extends PipelineTransformSource<any>, R> = (source: PipelineSourceArgument<S>, options?: Abortable) => R;
+        type PipelineDestination<S extends PipelineTransformSource<any>, R> = S extends PipelineSource<infer I> | PipelineTransform<any, infer I> ? NodeJS.WritableStream | web.WritableStream<I> | web.TransformStream<I, any> | PipelineDestinationFunction<S, R> : never;
+        type PipelineCallback<S extends PipelineDestination<any, any>> = (err: NodeJS.ErrnoException | null, value: S extends (...args: any[]) => PromiseLike<infer R> ? R : undefined) => void;
+        type PipelineResult<S extends PipelineDestination<any, any>> = S extends NodeJS.WritableStream ? S : Duplex;
+        function pipeline<S extends PipelineSource<any>, D extends PipelineDestination<S, any>>(source: S, destination: D, callback: PipelineCallback<D>): PipelineResult<D>;
+        function pipeline<S extends PipelineSource<any>, T extends PipelineTransform<S, any>, D extends PipelineDestination<T, any>>(source: S, transform: T, destination: D, callback: PipelineCallback<D>): PipelineResult<D>;
+        function pipeline<S extends PipelineSource<any>, T1 extends PipelineTransform<S, any>, T2 extends PipelineTransform<T1, any>, D extends PipelineDestination<T2, any>>(source: S, transform1: T1, transform2: T2, destination: D, callback: PipelineCallback<D>): PipelineResult<D>;
+        function pipeline<S extends PipelineSource<any>, T1 extends PipelineTransform<S, any>, T2 extends PipelineTransform<T1, any>, T3 extends PipelineTransform<T2, any>, D extends PipelineDestination<T3, any>>(source: S, transform1: T1, transform2: T2, transform3: T3, destination: D, callback: PipelineCallback<D>): PipelineResult<D>;
+        function pipeline<S extends PipelineSource<any>, T1 extends PipelineTransform<S, any>, T2 extends PipelineTransform<T1, any>, T3 extends PipelineTransform<T2, any>, T4 extends PipelineTransform<T3, any>, D extends PipelineDestination<T4, any>>(source: S, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: D, callback: PipelineCallback<D>): PipelineResult<D>;
+        function pipeline(streams: ReadonlyArray<PipelineSource<any> | PipelineTransform<any, any> | PipelineDestination<any, any>>, callback: (err: NodeJS.ErrnoException | null) => void): NodeJS.WritableStream;
+        function pipeline(...streams: [
+            ...[
+                PipelineSource<any>,
+                ...PipelineTransform<any, any>[],
+                PipelineDestination<any, any>
+            ],
+            callback: ((err: NodeJS.ErrnoException | null) => void)
+        ]): NodeJS.WritableStream;
+        namespace pipeline {
+            import __promisify__ = promises.pipeline;
+            export { __promisify__ };
+        }
+        type ComposeSource<O> = NodeJS.ReadableStream | web.ReadableStream<O> | Iterable<O> | AsyncIterable<O> | (() => AsyncIterable<O>);
+        type ComposeTransformStreams<I, O> = NodeJS.ReadWriteStream | web.TransformStream<I, O>;
+        type ComposeTransformGenerator<I, O> = (source: AsyncIterable<I>) => AsyncIterable<O>;
+        type ComposeTransform<S extends ComposeTransformSource<any>, O> = S extends ComposeSource<infer I> | ComposeTransformStreams<any, infer I> | ComposeTransformGenerator<any, infer I> ? ComposeTransformStreams<I, O> | ComposeTransformGenerator<I, O> : never;
+        type ComposeTransformSource<O> = ComposeSource<O> | ComposeTransform<any, O>;
+        type ComposeDestination<S extends ComposeTransformSource<any>> = S extends ComposeTransformSource<infer I> ? NodeJS.WritableStream | web.WritableStream<I> | web.TransformStream<I, any> | ((source: AsyncIterable<I>) => void) : never;
+        function compose(stream: ComposeSource<any> | ComposeDestination<any>): Duplex;
+        function compose<S extends ComposeSource<any> | ComposeTransform<any, any>, D extends ComposeTransform<S, any> | ComposeDestination<S>>(source: S, destination: D): Duplex;
+        function compose<S extends ComposeSource<any> | ComposeTransform<any, any>, T extends ComposeTransform<S, any>, D extends ComposeTransform<T, any> | ComposeDestination<T>>(source: S, transform: T, destination: D): Duplex;
+        function compose<S extends ComposeSource<any> | ComposeTransform<any, any>, T1 extends ComposeTransform<S, any>, T2 extends ComposeTransform<T1, any>, D extends ComposeTransform<T2, any> | ComposeDestination<T2>>(source: S, transform1: T1, transform2: T2, destination: D): Duplex;
+        function compose<S extends ComposeSource<any> | ComposeTransform<any, any>, T1 extends ComposeTransform<S, any>, T2 extends ComposeTransform<T1, any>, T3 extends ComposeTransform<T2, any>, D extends ComposeTransform<T3, any> | ComposeDestination<T3>>(source: S, transform1: T1, transform2: T2, transform3: T3, destination: D): Duplex;
+        function compose<S extends ComposeSource<any> | ComposeTransform<any, any>, T1 extends ComposeTransform<S, any>, T2 extends ComposeTransform<T1, any>, T3 extends ComposeTransform<T2, any>, T4 extends ComposeTransform<T3, any>, D extends ComposeTransform<T4, any> | ComposeDestination<T4>>(source: S, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: D): Duplex;
+        function compose(...streams: [
+            ComposeSource<any>,
+            ...ComposeTransform<any, any>[],
+            ComposeDestination<any>
+        ]): Duplex;
+        function isErrored(stream: NodeJS.ReadableStream | NodeJS.WritableStream | web.ReadableStream | web.WritableStream): boolean;
+        function isReadable(stream: NodeJS.ReadableStream | web.ReadableStream): boolean | null;
+        function isWritable(stream: NodeJS.WritableStream | web.WritableStream): boolean | null;
+    }
+    global {
+        namespace NodeJS {
+            interface ReadableStream extends EventEmitter {
+                readable: boolean;
+                read(size?: number): string | Buffer;
+                setEncoding(encoding: BufferEncoding): this;
+                pause(): this;
+                resume(): this;
+                isPaused(): boolean;
+                pipe<T extends WritableStream>(destination: T, options?: {
+                    end?: boolean | undefined;
+                }): T;
+                unpipe(destination?: WritableStream): this;
+                unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
+                wrap(oldStream: ReadableStream): this;
+                [Symbol.asyncIterator](): AsyncIterableIterator<string | Buffer>;
+            }
+            interface WritableStream extends EventEmitter {
+                writable: boolean;
+                write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+                write(str: string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+                end(cb?: () => void): this;
+                end(data: string | Uint8Array, cb?: () => void): this;
+                end(str: string, encoding?: BufferEncoding, cb?: () => void): this;
+            }
+            interface ReadWriteStream extends ReadableStream, WritableStream {
+            }
+        }
+    }
+    export = Stream;
+}
+declare module "stream" {
+    import stream = require("node:stream");
+    export = stream;
+}

package/types/node/string_decoder.d.ts

@@ -0,0 +1,10 @@
+declare module "node:string_decoder" {
+    class StringDecoder {
+        constructor(encoding?: BufferEncoding);
+        write(buffer: string | NodeJS.ArrayBufferView): string;
+        end(buffer?: string | NodeJS.ArrayBufferView): string;
+    }
+}
+declare module "string_decoder" {
+    export * from "node:string_decoder";
+}

package/types/node/test/reporters.d.ts

@@ -0,0 +1,66 @@
+declare module "node:test/reporters" {
+    import { Transform, TransformOptions } from "node:stream";
+    import { EventData } from "node:test";
+    type TestEvent = {
+        type: "test:coverage";
+        data: EventData.TestCoverage;
+    } | {
+        type: "test:complete";
+        data: EventData.TestComplete;
+    } | {
+        type: "test:dequeue";
+        data: EventData.TestDequeue;
+    } | {
+        type: "test:diagnostic";
+        data: EventData.TestDiagnostic;
+    } | {
+        type: "test:enqueue";
+        data: EventData.TestEnqueue;
+    } | {
+        type: "test:fail";
+        data: EventData.TestFail;
+    } | {
+        type: "test:interrupted";
+        data: EventData.TestInterrupted;
+    } | {
+        type: "test:pass";
+        data: EventData.TestPass;
+    } | {
+        type: "test:plan";
+        data: EventData.TestPlan;
+    } | {
+        type: "test:start";
+        data: EventData.TestStart;
+    } | {
+        type: "test:stderr";
+        data: EventData.TestStderr;
+    } | {
+        type: "test:stdout";
+        data: EventData.TestStdout;
+    } | {
+        type: "test:summary";
+        data: EventData.TestSummary;
+    } | {
+        type: "test:watch:drained";
+        data: undefined;
+    } | {
+        type: "test:watch:restarted";
+        data: undefined;
+    };
+    interface ReporterConstructorWrapper<T extends new (...args: any[]) => Transform> {
+        new (...args: ConstructorParameters<T>): InstanceType<T>;
+        (...args: ConstructorParameters<T>): InstanceType<T>;
+    }
+    function dot(source: AsyncIterable<TestEvent>): NodeJS.AsyncIterator<string>;
+    function tap(source: AsyncIterable<TestEvent>): NodeJS.AsyncIterator<string>;
+    class SpecReporter extends Transform {
+        constructor();
+    }
+    const spec: ReporterConstructorWrapper<typeof SpecReporter>;
+    function junit(source: AsyncIterable<TestEvent>): NodeJS.AsyncIterator<string>;
+    class LcovReporter extends Transform {
+        constructor(options?: Omit<TransformOptions, "writableObjectMode">);
+    }
+    const lcov: ReporterConstructorWrapper<typeof LcovReporter>;
+    export { dot, junit, lcov, spec, tap, TestEvent };
+}