@venos-inc/venos 0.1.14 → 0.1.15

package/etc/mcp-server/node_modules/@types/node/stream/web.d.ts

@@ -1,40 +1,3 @@
-type _ByteLengthQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").ByteLengthQueuingStrategy;
-type _CompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}
-    : import("stream/web").CompressionStream;
-type _CountQueuingStrategy = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").CountQueuingStrategy;
-type _DecompressionStream = typeof globalThis extends { onmessage: any; ReportingObserver: any } ? {}
-    : import("stream/web").DecompressionStream;
-type _QueuingStrategy<T = any> = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").QueuingStrategy<T>;
-type _ReadableByteStreamController = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").ReadableByteStreamController;
-type _ReadableStream<R = any> = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").ReadableStream<R>;
-type _ReadableStreamBYOBReader = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").ReadableStreamBYOBReader;
-type _ReadableStreamBYOBRequest = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").ReadableStreamBYOBRequest;
-type _ReadableStreamDefaultController<R = any> = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").ReadableStreamDefaultController<R>;
-type _ReadableStreamDefaultReader<R = any> = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").ReadableStreamDefaultReader<R>;
-type _TextDecoderStream = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").TextDecoderStream;
-type _TextEncoderStream = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").TextEncoderStream;
-type _TransformStream<I = any, O = any> = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").TransformStream<I, O>;
-type _TransformStreamDefaultController<O = any> = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").TransformStreamDefaultController<O>;
-type _WritableStream<W = any> = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").WritableStream<W>;
-type _WritableStreamDefaultController = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").WritableStreamDefaultController;
-type _WritableStreamDefaultWriter<W = any> = typeof globalThis extends { onmessage: any } ? {}
-    : import("stream/web").WritableStreamDefaultWriter<W>;
-
 declare module "stream/web" {
     // stub module, pending copy&paste from .d.ts or manual impl
     // copy from lib.dom.d.ts
@@ -99,17 +62,28 @@ declare module "stream/web" {
         signal?: AbortSignal;
     }
     interface ReadableStreamGenericReader {
-        readonly closed: Promise<void>;
+        readonly closed: Promise<undefined>;
         cancel(reason?: any): Promise<void>;
     }
+    interface ReadableStreamDefaultReadValueResult<T> {
+        done: false;
+        value: T;
+    }
+    interface ReadableStreamDefaultReadDoneResult {
+        done: true;
+        value?: undefined;
+    }
     type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
+    type ReadableStreamDefaultReadResult<T> =
+        | ReadableStreamDefaultReadValueResult<T>
+        | ReadableStreamDefaultReadDoneResult;
     interface ReadableStreamReadValueResult<T> {
         done: false;
         value: T;
     }
     interface ReadableStreamReadDoneResult<T> {
         done: true;
-        value: T | undefined;
+        value?: T;
     }
     type ReadableStreamReadResult<T> = ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>;
     interface ReadableByteStreamControllerCallback {
@@ -145,9 +119,6 @@ declare module "stream/web" {
     interface TransformerTransformCallback<I, O> {
         (chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
     }
-    interface TransformerCancelCallback {
-        (reason: any): void | PromiseLike<void>;
-    }
     interface UnderlyingByteSource {
         autoAllocateChunkSize?: number;
         cancel?: ReadableStreamErrorCallback;
@@ -171,21 +142,17 @@ declare module "stream/web" {
     interface ReadableStreamErrorCallback {
         (reason: any): void | PromiseLike<void>;
     }
-    interface ReadableStreamAsyncIterator<T> extends NodeJS.AsyncIterator<T, NodeJS.BuiltinIteratorReturn, unknown> {
-        [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;
-    }
     /** This Streams API interface represents a readable stream of byte data. */
     interface ReadableStream<R = any> {
         readonly locked: boolean;
         cancel(reason?: any): Promise<void>;
-        getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
         getReader(): ReadableStreamDefaultReader<R>;
-        getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamReader<R>;
+        getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
         pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
         pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
         tee(): [ReadableStream<R>, ReadableStream<R>];
-        values(options?: { preventCancel?: boolean }): ReadableStreamAsyncIterator<R>;
-        [Symbol.asyncIterator](): ReadableStreamAsyncIterator<R>;
+        values(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
+        [Symbol.asyncIterator](): AsyncIterableIterator<R>;
     }
     const ReadableStream: {
         prototype: ReadableStream;
@@ -193,55 +160,22 @@ declare module "stream/web" {
         new(underlyingSource: UnderlyingByteSource, strategy?: QueuingStrategy<Uint8Array>): ReadableStream<Uint8Array>;
         new<R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
     };
-    type ReadableStreamReaderMode = "byob";
-    interface ReadableStreamGetReaderOptions {
-        /**
-         * Creates a ReadableStreamBYOBReader and locks the stream to the new reader.
-         *
-         * 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.
-         */
-        mode?: ReadableStreamReaderMode;
-    }
-    type ReadableStreamReader<T> = ReadableStreamDefaultReader<T> | ReadableStreamBYOBReader;
     interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
-        read(): Promise<ReadableStreamReadResult<R>>;
+        read(): Promise<ReadableStreamDefaultReadResult<R>>;
         releaseLock(): void;
     }
-    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader) */
     interface ReadableStreamBYOBReader extends ReadableStreamGenericReader {
-        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/read) */
-        read<T extends ArrayBufferView>(
-            view: T,
-            options?: {
-                min?: number;
-            },
-        ): Promise<ReadableStreamReadResult<T>>;
-        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/releaseLock) */
+        read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamReadResult<T>>;
         releaseLock(): void;
     }
     const ReadableStreamDefaultReader: {
         prototype: ReadableStreamDefaultReader;
         new<R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
     };
-    const ReadableStreamBYOBReader: {
-        prototype: ReadableStreamBYOBReader;
-        new(stream: ReadableStream): ReadableStreamBYOBReader;
-    };
-    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest) */
-    interface ReadableStreamBYOBRequest {
-        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/view) */
-        readonly view: ArrayBufferView | null;
-        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respond) */
-        respond(bytesWritten: number): void;
-        /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respondWithNewView) */
-        respondWithNewView(view: ArrayBufferView): void;
-    }
-    const ReadableStreamBYOBRequest: {
-        prototype: ReadableStreamBYOBRequest;
-        new(): ReadableStreamBYOBRequest;
-    };
+    const ReadableStreamBYOBReader: any;
+    const ReadableStreamBYOBRequest: any;
     interface ReadableByteStreamController {
-        readonly byobRequest: ReadableStreamBYOBRequest | null;
+        readonly byobRequest: undefined;
         readonly desiredSize: number | null;
         close(): void;
         enqueue(chunk: ArrayBufferView): void;
@@ -254,7 +188,7 @@ declare module "stream/web" {
     interface ReadableStreamDefaultController<R = any> {
         readonly desiredSize: number | null;
         close(): void;
-        enqueue(chunk: R): void;
+        enqueue(chunk?: R): void;
         error(e?: any): void;
     }
     const ReadableStreamDefaultController: {
@@ -266,7 +200,6 @@ declare module "stream/web" {
         readableType?: undefined;
         start?: TransformerStartCallback<O>;
         transform?: TransformerTransformCallback<I, O>;
-        cancel?: TransformerCancelCallback;
         writableType?: undefined;
     }
     interface TransformStream<I = any, O = any> {
@@ -283,7 +216,7 @@ declare module "stream/web" {
     };
     interface TransformStreamDefaultController<O = any> {
         readonly desiredSize: number | null;
-        enqueue(chunk: O): void;
+        enqueue(chunk?: O): void;
         error(reason?: any): void;
         terminate(): void;
     }
@@ -313,13 +246,13 @@ declare module "stream/web" {
      * sink.
      */
     interface WritableStreamDefaultWriter<W = any> {
-        readonly closed: Promise<void>;
+        readonly closed: Promise<undefined>;
         readonly desiredSize: number | null;
-        readonly ready: Promise<void>;
+        readonly ready: Promise<undefined>;
         abort(reason?: any): Promise<void>;
         close(): Promise<void>;
         releaseLock(): void;
-        write(chunk: W): Promise<void>;
+        write(chunk?: W): Promise<void>;
     }
     const WritableStreamDefaultWriter: {
         prototype: WritableStreamDefaultWriter;
@@ -343,7 +276,7 @@ declare module "stream/web" {
         size?: QueuingStrategySize<T>;
     }
     interface QueuingStrategySize<T = any> {
-        (chunk: T): number;
+        (chunk?: T): number;
     }
     interface QueuingStrategyInit {
         /**
@@ -412,210 +345,22 @@ declare module "stream/web" {
         prototype: TextDecoderStream;
         new(encoding?: string, options?: TextDecoderOptions): TextDecoderStream;
     };
-    interface CompressionStream {
-        readonly readable: ReadableStream;
-        readonly writable: WritableStream;
+    interface CompressionStream<R = any, W = any> {
+        readonly readable: ReadableStream<R>;
+        readonly writable: WritableStream<W>;
     }
     const CompressionStream: {
         prototype: CompressionStream;
-        new(format: "deflate" | "deflate-raw" | "gzip"): CompressionStream;
+        new<R = any, W = any>(format: "deflate" | "deflate-raw" | "gzip"): CompressionStream<R, W>;
     };
-    interface DecompressionStream {
-        readonly writable: WritableStream;
-        readonly readable: ReadableStream;
+    interface DecompressionStream<R = any, W = any> {
+        readonly readable: ReadableStream<R>;
+        readonly writable: WritableStream<W>;
     }
     const DecompressionStream: {
         prototype: DecompressionStream;
-        new(format: "deflate" | "deflate-raw" | "gzip"): DecompressionStream;
+        new<R = any, W = any>(format: "deflate" | "deflate-raw" | "gzip"): DecompressionStream<R, W>;
     };
-
-    global {
-        interface ByteLengthQueuingStrategy extends _ByteLengthQueuingStrategy {}
-        /**
-         * `ByteLengthQueuingStrategy` class is a global reference for `import { ByteLengthQueuingStrategy } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-bytelengthqueuingstrategy
-         * @since v18.0.0
-         */
-        var ByteLengthQueuingStrategy: typeof globalThis extends { onmessage: any; ByteLengthQueuingStrategy: infer T }
-            ? T
-            : typeof import("stream/web").ByteLengthQueuingStrategy;
-
-        interface CompressionStream extends _CompressionStream {}
-        /**
-         * `CompressionStream` class is a global reference for `import { CompressionStream } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-compressionstream
-         * @since v18.0.0
-         */
-        var CompressionStream: typeof globalThis extends {
-            onmessage: any;
-            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.
-            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts
-            ReportingObserver: any;
-            CompressionStream: infer T;
-        } ? T
-            // TS 4.8, 4.9, 5.0
-            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {
-                    prototype: T;
-                    new(format: "deflate" | "deflate-raw" | "gzip"): T;
-                }
-            : typeof import("stream/web").CompressionStream;
-
-        interface CountQueuingStrategy extends _CountQueuingStrategy {}
-        /**
-         * `CountQueuingStrategy` class is a global reference for `import { CountQueuingStrategy } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-countqueuingstrategy
-         * @since v18.0.0
-         */
-        var CountQueuingStrategy: typeof globalThis extends { onmessage: any; CountQueuingStrategy: infer T } ? T
-            : typeof import("stream/web").CountQueuingStrategy;
-
-        interface DecompressionStream extends _DecompressionStream {}
-        /**
-         * `DecompressionStream` class is a global reference for `import { DecompressionStream } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-decompressionstream
-         * @since v18.0.0
-         */
-        var DecompressionStream: typeof globalThis extends {
-            onmessage: any;
-            // CompressionStream, DecompressionStream and ReportingObserver was introduced in the same commit.
-            // If ReportingObserver check is removed, the type here will form a circular reference in TS5.0+lib.dom.d.ts
-            ReportingObserver: any;
-            DecompressionStream: infer T extends object;
-        } ? T
-            // TS 4.8, 4.9, 5.0
-            : typeof globalThis extends { onmessage: any; TransformStream: { prototype: infer T } } ? {
-                    prototype: T;
-                    new(format: "deflate" | "deflate-raw" | "gzip"): T;
-                }
-            : typeof import("stream/web").DecompressionStream;
-
-        interface QueuingStrategy<T = any> extends _QueuingStrategy<T> {}
-
-        interface ReadableByteStreamController extends _ReadableByteStreamController {}
-        /**
-         * `ReadableByteStreamController` class is a global reference for `import { ReadableByteStreamController } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-readablebytestreamcontroller
-         * @since v18.0.0
-         */
-        var ReadableByteStreamController: typeof globalThis extends
-            { onmessage: any; ReadableByteStreamController: infer T } ? T
-            : typeof import("stream/web").ReadableByteStreamController;
-
-        interface ReadableStream<R = any> extends _ReadableStream<R> {}
-        /**
-         * `ReadableStream` class is a global reference for `import { ReadableStream } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-readablestream
-         * @since v18.0.0
-         */
-        var ReadableStream: typeof globalThis extends { onmessage: any; ReadableStream: infer T } ? T
-            : typeof import("stream/web").ReadableStream;
-
-        interface ReadableStreamBYOBReader extends _ReadableStreamBYOBReader {}
-        /**
-         * `ReadableStreamBYOBReader` class is a global reference for `import { ReadableStreamBYOBReader } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-readablestreambyobreader
-         * @since v18.0.0
-         */
-        var ReadableStreamBYOBReader: typeof globalThis extends { onmessage: any; ReadableStreamBYOBReader: infer T }
-            ? T
-            : typeof import("stream/web").ReadableStreamBYOBReader;
-
-        interface ReadableStreamBYOBRequest extends _ReadableStreamBYOBRequest {}
-        /**
-         * `ReadableStreamBYOBRequest` class is a global reference for `import { ReadableStreamBYOBRequest } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-readablestreambyobrequest
-         * @since v18.0.0
-         */
-        var ReadableStreamBYOBRequest: typeof globalThis extends { onmessage: any; ReadableStreamBYOBRequest: infer T }
-            ? T
-            : typeof import("stream/web").ReadableStreamBYOBRequest;
-
-        interface ReadableStreamDefaultController<R = any> extends _ReadableStreamDefaultController<R> {}
-        /**
-         * `ReadableStreamDefaultController` class is a global reference for `import { ReadableStreamDefaultController } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-readablestreamdefaultcontroller
-         * @since v18.0.0
-         */
-        var ReadableStreamDefaultController: typeof globalThis extends
-            { onmessage: any; ReadableStreamDefaultController: infer T } ? T
-            : typeof import("stream/web").ReadableStreamDefaultController;
-
-        interface ReadableStreamDefaultReader<R = any> extends _ReadableStreamDefaultReader<R> {}
-        /**
-         * `ReadableStreamDefaultReader` class is a global reference for `import { ReadableStreamDefaultReader } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-readablestreamdefaultreader
-         * @since v18.0.0
-         */
-        var ReadableStreamDefaultReader: typeof globalThis extends
-            { onmessage: any; ReadableStreamDefaultReader: infer T } ? T
-            : typeof import("stream/web").ReadableStreamDefaultReader;
-
-        interface TextDecoderStream extends _TextDecoderStream {}
-        /**
-         * `TextDecoderStream` class is a global reference for `import { TextDecoderStream } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-textdecoderstream
-         * @since v18.0.0
-         */
-        var TextDecoderStream: typeof globalThis extends { onmessage: any; TextDecoderStream: infer T } ? T
-            : typeof import("stream/web").TextDecoderStream;
-
-        interface TextEncoderStream extends _TextEncoderStream {}
-        /**
-         * `TextEncoderStream` class is a global reference for `import { TextEncoderStream } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-textencoderstream
-         * @since v18.0.0
-         */
-        var TextEncoderStream: typeof globalThis extends { onmessage: any; TextEncoderStream: infer T } ? T
-            : typeof import("stream/web").TextEncoderStream;
-
-        interface TransformStream<I = any, O = any> extends _TransformStream<I, O> {}
-        /**
-         * `TransformStream` class is a global reference for `import { TransformStream } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-transformstream
-         * @since v18.0.0
-         */
-        var TransformStream: typeof globalThis extends { onmessage: any; TransformStream: infer T } ? T
-            : typeof import("stream/web").TransformStream;
-
-        interface TransformStreamDefaultController<O = any> extends _TransformStreamDefaultController<O> {}
-        /**
-         * `TransformStreamDefaultController` class is a global reference for `import { TransformStreamDefaultController } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-transformstreamdefaultcontroller
-         * @since v18.0.0
-         */
-        var TransformStreamDefaultController: typeof globalThis extends
-            { onmessage: any; TransformStreamDefaultController: infer T } ? T
-            : typeof import("stream/web").TransformStreamDefaultController;
-
-        interface WritableStream<W = any> extends _WritableStream<W> {}
-        /**
-         * `WritableStream` class is a global reference for `import { WritableStream } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-writablestream
-         * @since v18.0.0
-         */
-        var WritableStream: typeof globalThis extends { onmessage: any; WritableStream: infer T } ? T
-            : typeof import("stream/web").WritableStream;
-
-        interface WritableStreamDefaultController extends _WritableStreamDefaultController {}
-        /**
-         * `WritableStreamDefaultController` class is a global reference for `import { WritableStreamDefaultController } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-writablestreamdefaultcontroller
-         * @since v18.0.0
-         */
-        var WritableStreamDefaultController: typeof globalThis extends
-            { onmessage: any; WritableStreamDefaultController: infer T } ? T
-            : typeof import("stream/web").WritableStreamDefaultController;
-
-        interface WritableStreamDefaultWriter<W = any> extends _WritableStreamDefaultWriter<W> {}
-        /**
-         * `WritableStreamDefaultWriter` class is a global reference for `import { WritableStreamDefaultWriter } from 'node:stream/web'`.
-         * https://nodejs.org/api/globals.html#class-writablestreamdefaultwriter
-         * @since v18.0.0
-         */
-        var WritableStreamDefaultWriter: typeof globalThis extends
-            { onmessage: any; WritableStreamDefaultWriter: infer T } ? T
-            : typeof import("stream/web").WritableStreamDefaultWriter;
-    }
 }
 declare module "node:stream/web" {
     export * from "stream/web";