Pinsave/counterstrike

1type _ByteLengthQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}2    : import("stream/web").ByteLengthQueuingStrategy;3type _CompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}4    : import("stream/web").CompressionStream;5type _CountQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}6    : import("stream/web").CountQueuingStrategy;7type _DecompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}8    : import("stream/web").DecompressionStream;9type _ReadableByteStreamController = typeof globalThis extends { onmessage: any } ? {}10    : import("stream/web").ReadableByteStreamController;11type _ReadableStream<R = any> = typeof globalThis extends { onmessage: any } ? {}12    : import("stream/web").ReadableStream<R>;13type _ReadableStreamBYOBReader = typeof globalThis extends { onmessage: any } ? {}14    : import("stream/web").ReadableStreamBYOBReader;15type _ReadableStreamBYOBRequest = typeof globalThis extends { onmessage: any } ? {}16    : import("stream/web").ReadableStreamBYOBRequest;17type _ReadableStreamDefaultController<R = any> = typeof globalThis extends { onmessage: any } ? {}18    : import("stream/web").ReadableStreamDefaultController<R>;19type _ReadableStreamDefaultReader<R = any> = typeof globalThis extends { onmessage: any } ? {}20    : import("stream/web").ReadableStreamDefaultReader<R>;21type _TextDecoderStream = typeof globalThis extends { onmessage: any } ? {}22    : import("stream/web").TextDecoderStream;23type _TextEncoderStream = typeof globalThis extends { onmessage: any } ? {}24    : import("stream/web").TextEncoderStream;25type _TransformStream<I = any, O = any> = typeof globalThis extends { onmessage: any } ? {}26    : import("stream/web").TransformStream<I, O>;27type _TransformStreamDefaultController<O = any> = typeof globalThis extends { onmessage: any } ? {}28    : import("stream/web").TransformStreamDefaultController<O>;29type _WritableStream<W = any> = typeof globalThis extends { onmessage: any } ? {}30    : import("stream/web").WritableStream<W>;31type _WritableStreamDefaultController = typeof globalThis extends { onmessage: any } ? {}32    : import("stream/web").WritableStreamDefaultController;33type _WritableStreamDefaultWriter<W = any> = typeof globalThis extends { onmessage: any } ? {}34    : import("stream/web").WritableStreamDefaultWriter<W>;35 36declare module "stream/web" {37    // stub module, pending copy&paste from .d.ts or manual impl38    // copy from lib.dom.d.ts39    interface ReadableWritablePair<R = any, W = any> {40        readable: ReadableStream<R>;41        /**42         * Provides a convenient, chainable way of piping this readable stream43         * through a transform stream (or any other { writable, readable }44         * pair). It simply pipes the stream into the writable side of the45         * supplied pair, and returns the readable side for further use.46         *47         * Piping a stream will lock it for the duration of the pipe, preventing48         * any other consumer from acquiring a reader.49         */50        writable: WritableStream<W>;51    }52    interface StreamPipeOptions {53        preventAbort?: boolean;54        preventCancel?: boolean;55        /**56         * Pipes this readable stream to a given writable stream destination.57         * The way in which the piping process behaves under various error58         * conditions can be customized with a number of passed options. It59         * returns a promise that fulfills when the piping process completes60         * successfully, or rejects if any errors were encountered.61         *62         * Piping a stream will lock it for the duration of the pipe, preventing63         * any other consumer from acquiring a reader.64         *65         * Errors and closures of the source and destination streams propagate66         * as follows:67         *68         * An error in this source readable stream will abort destination,69         * unless preventAbort is truthy. The returned promise will be rejected70         * with the source's error, or with any error that occurs during71         * aborting the destination.72         *73         * An error in destination will cancel this source readable stream,74         * unless preventCancel is truthy. The returned promise will be rejected75         * with the destination's error, or with any error that occurs during76         * canceling the source.77         *78         * When this source readable stream closes, destination will be closed,79         * unless preventClose is truthy. The returned promise will be fulfilled80         * once this process completes, unless an error is encountered while81         * closing the destination, in which case it will be rejected with that82         * error.83         *84         * If destination starts out closed or closing, this source readable85         * stream will be canceled, unless preventCancel is true. The returned86         * promise will be rejected with an error indicating piping to a closed87         * stream failed, or with any error that occurs during canceling the88         * source.89         *90         * The signal option can be set to an AbortSignal to allow aborting an91         * ongoing pipe operation via the corresponding AbortController. In this92         * case, this source readable stream will be canceled, and destination93         * aborted, unless the respective options preventCancel or preventAbort94         * are set.95         */96        preventClose?: boolean;97        signal?: AbortSignal;98    }99    interface ReadableStreamGenericReader {100        readonly closed: Promise<void>;101        cancel(reason?: any): Promise<void>;102    }103    type ReadableStreamController<T> = ReadableStreamDefaultController<T>;104    interface ReadableStreamReadValueResult<T> {105        done: false;106        value: T;107    }108    interface ReadableStreamReadDoneResult<T> {109        done: true;110        value?: T;111    }112    type ReadableStreamReadResult<T> = ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>;113    interface ReadableByteStreamControllerCallback {114        (controller: ReadableByteStreamController): void | PromiseLike<void>;115    }116    interface UnderlyingSinkAbortCallback {117        (reason?: any): void | PromiseLike<void>;118    }119    interface UnderlyingSinkCloseCallback {120        (): void | PromiseLike<void>;121    }122    interface UnderlyingSinkStartCallback {123        (controller: WritableStreamDefaultController): any;124    }125    interface UnderlyingSinkWriteCallback<W> {126        (chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;127    }128    interface UnderlyingSourceCancelCallback {129        (reason?: any): void | PromiseLike<void>;130    }131    interface UnderlyingSourcePullCallback<R> {132        (controller: ReadableStreamController<R>): void | PromiseLike<void>;133    }134    interface UnderlyingSourceStartCallback<R> {135        (controller: ReadableStreamController<R>): any;136    }137    interface TransformerFlushCallback<O> {138        (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;139    }140    interface TransformerStartCallback<O> {141        (controller: TransformStreamDefaultController<O>): any;142    }143    interface TransformerTransformCallback<I, O> {144        (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;145    }146    interface TransformerCancelCallback {147        (reason: any): void | PromiseLike<void>;148    }149    interface UnderlyingByteSource {150        autoAllocateChunkSize?: number;151        cancel?: ReadableStreamErrorCallback;152        pull?: ReadableByteStreamControllerCallback;153        start?: ReadableByteStreamControllerCallback;154        type: "bytes";155    }156    interface UnderlyingSource<R = any> {157        cancel?: UnderlyingSourceCancelCallback;158        pull?: UnderlyingSourcePullCallback<R>;159        start?: UnderlyingSourceStartCallback<R>;160        type?: undefined;161    }162    interface UnderlyingSink<W = any> {163        abort?: UnderlyingSinkAbortCallback;164        close?: UnderlyingSinkCloseCallback;165        start?: UnderlyingSinkStartCallback;166        type?: undefined;167        write?: UnderlyingSinkWriteCallback<W>;168    }169    interface ReadableStreamErrorCallback {170        (reason: any): void | PromiseLike<void>;171    }172    interface ReadableStreamAsyncIterator<T> extends NodeJS.AsyncIterator<T, NodeJS.BuiltinIteratorReturn, unknown> {173        [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;174    }175    /** This Streams API interface represents a readable stream of byte data. */176    interface ReadableStream<R = any> {177        readonly locked: boolean;178        cancel(reason?: any): Promise<void>;179        getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;180        getReader(): ReadableStreamDefaultReader<R>;181        getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader<R>;182        pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;183        pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;184        tee(): [ReadableStream<R>, ReadableStream<R>];185        values(options?: { preventCancel?: boolean }): ReadableStreamAsyncIterator<R>;186        [Symbol.asyncIterator](): ReadableStreamAsyncIterator<R>;187    }188    const ReadableStream: {189        prototype: ReadableStream;190        from<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStream<T>;191        new(underlyingSource: UnderlyingByteSource, strategy?: QueuingStrategy<Uint8Array>): ReadableStream<Uint8Array>;192        new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;193    };194    type ReadableStreamReaderMode = "byob";195    interface ReadableStreamGetReaderOptions {196        /**197         * Creates a ReadableStreamBYOBReader and locks the stream to the new reader.198         *199         * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation.200         */201        mode?: ReadableStreamReaderMode;202    }203    type ReadableStreamReader<T> = ReadableStreamDefaultReader<T> | ReadableStreamBYOBReader;204    interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {205        read(): Promise<ReadableStreamReadResult<R>>;206        releaseLock(): void;207    }208    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader) */209    interface ReadableStreamBYOBReader extends ReadableStreamGenericReader {210        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/read) */211        read<T extends ArrayBufferView>(212            view: T,213            options?: {214                min?: number;215            },216        ): Promise<ReadableStreamReadResult<T>>;217        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/releaseLock) */218        releaseLock(): void;219    }220    const ReadableStreamDefaultReader: {221        prototype: ReadableStreamDefaultReader;222        new<R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;223    };224    const ReadableStreamBYOBReader: {225        prototype: ReadableStreamBYOBReader;226        new(stream: ReadableStream): ReadableStreamBYOBReader;227    };228    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest) */229    interface ReadableStreamBYOBRequest {230        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/view) */231        readonly view: ArrayBufferView | null;232        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respond) */233        respond(bytesWritten: number): void;234        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respondWithNewView) */235        respondWithNewView(view: ArrayBufferView): void;236    }237    const ReadableStreamBYOBRequest: {238        prototype: ReadableStreamBYOBRequest;239        new(): ReadableStreamBYOBRequest;240    };241    interface ReadableByteStreamController {242        readonly byobRequest: undefined;243        readonly desiredSize: number | null;244        close(): void;245        enqueue(chunk: ArrayBufferView): void;246        error(error?: any): void;247    }248    const ReadableByteStreamController: {249        prototype: ReadableByteStreamController;250        new(): ReadableByteStreamController;251    };252    interface ReadableStreamDefaultController<R = any> {253        readonly desiredSize: number | null;254        close(): void;255        enqueue(chunk?: R): void;256        error(e?: any): void;257    }258    const ReadableStreamDefaultController: {259        prototype: ReadableStreamDefaultController;260        new(): ReadableStreamDefaultController;261    };262    interface Transformer<I = any, O = any> {263        flush?: TransformerFlushCallback<O>;264        readableType?: undefined;265        start?: TransformerStartCallback<O>;266        transform?: TransformerTransformCallback<I, O>;267        cancel?: TransformerCancelCallback;268        writableType?: undefined;269    }270    interface TransformStream<I = any, O = any> {271        readonly readable: ReadableStream<O>;272        readonly writable: WritableStream<I>;273    }274    const TransformStream: {275        prototype: TransformStream;276        new<I = any, O = any>(277            transformer?: Transformer<I, O>,278            writableStrategy?: QueuingStrategy<I>,279            readableStrategy?: QueuingStrategy<O>,280        ): TransformStream<I, O>;281    };282    interface TransformStreamDefaultController<O = any> {283        readonly desiredSize: number | null;284        enqueue(chunk?: O): void;285        error(reason?: any): void;286        terminate(): void;287    }288    const TransformStreamDefaultController: {289        prototype: TransformStreamDefaultController;290        new(): TransformStreamDefaultController;291    };292    /**293     * This Streams API interface provides a standard abstraction for writing294     * streaming data to a destination, known as a sink. This object comes with295     * built-in back pressure and queuing.296     */297    interface WritableStream<W = any> {298        readonly locked: boolean;299        abort(reason?: any): Promise<void>;300        close(): Promise<void>;301        getWriter(): WritableStreamDefaultWriter<W>;302    }303    const WritableStream: {304        prototype: WritableStream;305        new<W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;306    };307    /**308     * This Streams API interface is the object returned by309     * WritableStream.getWriter() and once created locks the < writer to the310     * WritableStream ensuring that no other streams can write to the underlying311     * sink.312     */313    interface WritableStreamDefaultWriter<W = any> {314        readonly closed: Promise<void>;315        readonly desiredSize: number | null;316        readonly ready: Promise<void>;317        abort(reason?: any): Promise<void>;318        close(): Promise<void>;319        releaseLock(): void;320        write(chunk?: W): Promise<void>;321    }322    const WritableStreamDefaultWriter: {323        prototype: WritableStreamDefaultWriter;324        new<W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;325    };326    /**327     * This Streams API interface represents a controller allowing control of a328     * WritableStream's state. When constructing a WritableStream, the329     * underlying sink is given a corresponding WritableStreamDefaultController330     * instance to manipulate.331     */332    interface WritableStreamDefaultController {333        error(e?: any): void;334    }335    const WritableStreamDefaultController: {336        prototype: WritableStreamDefaultController;337        new(): WritableStreamDefaultController;338    };339    interface QueuingStrategy<T = any> {340        highWaterMark?: number;341        size?: QueuingStrategySize<T>;342    }343    interface QueuingStrategySize<T = any> {344        (chunk?: T): number;345    }346    interface QueuingStrategyInit {347        /**348         * Creates a new ByteLengthQueuingStrategy with the provided high water349         * mark.350         *351         * Note that the provided high water mark will not be validated ahead of352         * time. Instead, if it is negative, NaN, or not a number, the resulting353         * ByteLengthQueuingStrategy will cause the corresponding stream354         * constructor to throw.355         */356        highWaterMark: number;357    }358    /**359     * This Streams API interface provides a built-in byte length queuing360     * strategy that can be used when constructing streams.361     */362    interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {363        readonly highWaterMark: number;364        readonly size: QueuingStrategySize<ArrayBufferView>;365    }366    const ByteLengthQueuingStrategy: {367        prototype: ByteLengthQueuingStrategy;368        new(init: QueuingStrategyInit): ByteLengthQueuingStrategy;369    };370    /**371     * This Streams API interface provides a built-in byte length queuing372     * strategy that can be used when constructing streams.373     */374    interface CountQueuingStrategy extends QueuingStrategy {375        readonly highWaterMark: number;376        readonly size: QueuingStrategySize;377    }378    const CountQueuingStrategy: {379        prototype: CountQueuingStrategy;380        new(init: QueuingStrategyInit): CountQueuingStrategy;381    };382    interface TextEncoderStream {383        /** Returns "utf-8". */384        readonly encoding: "utf-8";385        readonly readable: ReadableStream<Uint8Array>;386        readonly writable: WritableStream<string>;387        readonly [Symbol.toStringTag]: string;388    }389    const TextEncoderStream: {390        prototype: TextEncoderStream;391        new(): TextEncoderStream;392    };393    interface TextDecoderOptions {394        fatal?: boolean;395        ignoreBOM?: boolean;396    }397    type BufferSource = ArrayBufferView | ArrayBuffer;398    interface TextDecoderStream {399        /** Returns encoding's name, lower cased. */400        readonly encoding: string;401        /** Returns `true` if error mode is "fatal", and `false` otherwise. */402        readonly fatal: boolean;403        /** Returns `true` if ignore BOM flag is set, and `false` otherwise. */404        readonly ignoreBOM: boolean;405        readonly readable: ReadableStream<string>;406        readonly writable: WritableStream<BufferSource>;407        readonly [Symbol.toStringTag]: string;408    }409    const TextDecoderStream: {410        prototype: TextDecoderStream;411        new(encoding?: string, options?: TextDecoderOptions): TextDecoderStream;412    };413    interface CompressionStream {414        readonly readable: ReadableStream;415        readonly writable: WritableStream;416    }417    const CompressionStream: {418        prototype: CompressionStream;419        new(format: "deflate" | "deflate-raw" | "gzip"): CompressionStream;420    };421    interface DecompressionStream {422        readonly writable: WritableStream;423        readonly readable: ReadableStream;424    }425    const DecompressionStream: {426        prototype: DecompressionStream;427        new(format: "deflate" | "deflate-raw" | "gzip"): DecompressionStream;428    };429 430    global {431        interface ByteLengthQueuingStrategy extends _ByteLengthQueuingStrategy {}432        /**433         * `ByteLengthQueuingStrategy` class is a global reference for `import { ByteLengthQueuingStrategy } from 'node:stream/web'`.434         * https://nodejs.org/api/globals.html#class-bytelengthqueuingstrategy435         * @since v18.0.0436         */437        var ByteLengthQueuingStrategy: typeof globalThis extends { onmessage: any; ByteLengthQueuingStrategy: infer T }438            ? T439            : typeof import("stream/web").ByteLengthQueuingStrategy;440 441        interface CompressionStream extends _CompressionStream {}442        /**443         * `CompressionStream` class is a global reference for `import { CompressionStream } from 'node:stream/web'`.444         * https://nodejs.org/api/globals.html#class-compressionstream445         * @since v18.0.0446         */447        var CompressionStream: typeof globalThis extends {448            onmessage: any;449            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.450            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts451            ReportingObserver: any;452            CompressionStream: infer T;453        } ? T454            // TS 4.8, 4.9, 5.0455            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {456                    prototype: T;457                    new(format: "deflate" | "deflate-raw" | "gzip"): T;458                }459            : typeof import("stream/web").CompressionStream;460 461        interface CountQueuingStrategy extends _CountQueuingStrategy {}462        /**463         * `CountQueuingStrategy` class is a global reference for `import { CountQueuingStrategy } from 'node:stream/web'`.464         * https://nodejs.org/api/globals.html#class-countqueuingstrategy465         * @since v18.0.0466         */467        var CountQueuingStrategy: typeof globalThis extends { onmessage: any; CountQueuingStrategy: infer T } ? T468            : typeof import("stream/web").CountQueuingStrategy;469 470        interface DecompressionStream extends _DecompressionStream {}471        /**472         * `DecompressionStream` class is a global reference for `import { DecompressionStream } from 'node:stream/web'`.473         * https://nodejs.org/api/globals.html#class-decompressionstream474         * @since v18.0.0475         */476        var DecompressionStream: typeof globalThis extends {477            onmessage: any;478            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.479            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts480            ReportingObserver: any;481            DecompressionStream: infer T extends object;482        } ? T483            // TS 4.8, 4.9, 5.0484            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {485                    prototype: T;486                    new(format: "deflate" | "deflate-raw" | "gzip"): T;487                }488            : typeof import("stream/web").DecompressionStream;489 490        interface ReadableByteStreamController extends _ReadableByteStreamController {}491        /**492         * `ReadableByteStreamController` class is a global reference for `import { ReadableByteStreamController } from 'node:stream/web'`.493         * https://nodejs.org/api/globals.html#class-readablebytestreamcontroller494         * @since v18.0.0495         */496        var ReadableByteStreamController: typeof globalThis extends497            { onmessage: any; ReadableByteStreamController: infer T } ? T498            : typeof import("stream/web").ReadableByteStreamController;499 500        interface ReadableStream<R = any> extends _ReadableStream<R> {}501        /**502         * `ReadableStream` class is a global reference for `import { ReadableStream } from 'node:stream/web'`.503         * https://nodejs.org/api/globals.html#class-readablestream504         * @since v18.0.0505         */506        var ReadableStream: typeof globalThis extends { onmessage: any; ReadableStream: infer T } ? T507            : typeof import("stream/web").ReadableStream;508 509        interface ReadableStreamBYOBReader extends _ReadableStreamBYOBReader {}510        /**511         * `ReadableStreamBYOBReader` class is a global reference for `import { ReadableStreamBYOBReader } from 'node:stream/web'`.512         * https://nodejs.org/api/globals.html#class-readablestreambyobreader513         * @since v18.0.0514         */515        var ReadableStreamBYOBReader: typeof globalThis extends { onmessage: any; ReadableStreamBYOBReader: infer T }516            ? T517            : typeof import("stream/web").ReadableStreamBYOBReader;518 519        interface ReadableStreamBYOBRequest extends _ReadableStreamBYOBRequest {}520        /**521         * `ReadableStreamBYOBRequest` class is a global reference for `import { ReadableStreamBYOBRequest } from 'node:stream/web'`.522         * https://nodejs.org/api/globals.html#class-readablestreambyobrequest523         * @since v18.0.0524         */525        var ReadableStreamBYOBRequest: typeof globalThis extends { onmessage: any; ReadableStreamBYOBRequest: infer T }526            ? T527            : typeof import("stream/web").ReadableStreamBYOBRequest;528 529        interface ReadableStreamDefaultController<R = any> extends _ReadableStreamDefaultController<R> {}530        /**531         * `ReadableStreamDefaultController` class is a global reference for `import { ReadableStreamDefaultController } from 'node:stream/web'`.532         * https://nodejs.org/api/globals.html#class-readablestreamdefaultcontroller533         * @since v18.0.0534         */535        var ReadableStreamDefaultController: typeof globalThis extends536            { onmessage: any; ReadableStreamDefaultController: infer T } ? T537            : typeof import("stream/web").ReadableStreamDefaultController;538 539        interface ReadableStreamDefaultReader<R = any> extends _ReadableStreamDefaultReader<R> {}540        /**541         * `ReadableStreamDefaultReader` class is a global reference for `import { ReadableStreamDefaultReader } from 'node:stream/web'`.542         * https://nodejs.org/api/globals.html#class-readablestreamdefaultreader543         * @since v18.0.0544         */545        var ReadableStreamDefaultReader: typeof globalThis extends546            { onmessage: any; ReadableStreamDefaultReader: infer T } ? T547            : typeof import("stream/web").ReadableStreamDefaultReader;548 549        interface TextDecoderStream extends _TextDecoderStream {}550        /**551         * `TextDecoderStream` class is a global reference for `import { TextDecoderStream } from 'node:stream/web'`.552         * https://nodejs.org/api/globals.html#class-textdecoderstream553         * @since v18.0.0554         */555        var TextDecoderStream: typeof globalThis extends { onmessage: any; TextDecoderStream: infer T } ? T556            : typeof import("stream/web").TextDecoderStream;557 558        interface TextEncoderStream extends _TextEncoderStream {}559        /**560         * `TextEncoderStream` class is a global reference for `import { TextEncoderStream } from 'node:stream/web'`.561         * https://nodejs.org/api/globals.html#class-textencoderstream562         * @since v18.0.0563         */564        var TextEncoderStream: typeof globalThis extends { onmessage: any; TextEncoderStream: infer T } ? T565            : typeof import("stream/web").TextEncoderStream;566 567        interface TransformStream<I = any, O = any> extends _TransformStream<I, O> {}568        /**569         * `TransformStream` class is a global reference for `import { TransformStream } from 'node:stream/web'`.570         * https://nodejs.org/api/globals.html#class-transformstream571         * @since v18.0.0572         */573        var TransformStream: typeof globalThis extends { onmessage: any; TransformStream: infer T } ? T574            : typeof import("stream/web").TransformStream;575 576        interface TransformStreamDefaultController<O = any> extends _TransformStreamDefaultController<O> {}577        /**578         * `TransformStreamDefaultController` class is a global reference for `import { TransformStreamDefaultController } from 'node:stream/web'`.579         * https://nodejs.org/api/globals.html#class-transformstreamdefaultcontroller580         * @since v18.0.0581         */582        var TransformStreamDefaultController: typeof globalThis extends583            { onmessage: any; TransformStreamDefaultController: infer T } ? T584            : typeof import("stream/web").TransformStreamDefaultController;585 586        interface WritableStream<W = any> extends _WritableStream<W> {}587        /**588         * `WritableStream` class is a global reference for `import { WritableStream } from 'node:stream/web'`.589         * https://nodejs.org/api/globals.html#class-writablestream590         * @since v18.0.0591         */592        var WritableStream: typeof globalThis extends { onmessage: any; WritableStream: infer T } ? T593            : typeof import("stream/web").WritableStream;594 595        interface WritableStreamDefaultController extends _WritableStreamDefaultController {}596        /**597         * `WritableStreamDefaultController` class is a global reference for `import { WritableStreamDefaultController } from 'node:stream/web'`.598         * https://nodejs.org/api/globals.html#class-writablestreamdefaultcontroller599         * @since v18.0.0600         */601        var WritableStreamDefaultController: typeof globalThis extends602            { onmessage: any; WritableStreamDefaultController: infer T } ? T603            : typeof import("stream/web").WritableStreamDefaultController;604 605        interface WritableStreamDefaultWriter<W = any> extends _WritableStreamDefaultWriter<W> {}606        /**607         * `WritableStreamDefaultWriter` class is a global reference for `import { WritableStreamDefaultWriter } from 'node:stream/web'`.608         * https://nodejs.org/api/globals.html#class-writablestreamdefaultwriter609         * @since v18.0.0610         */611        var WritableStreamDefaultWriter: typeof globalThis extends612            { onmessage: any; WritableStreamDefaultWriter: infer T } ? T613            : typeof import("stream/web").WritableStreamDefaultWriter;614    }615}616declare module "node:stream/web" {617    export * from "stream/web";618}619