@tothalex/cloud 0.0.40 → 0.0.44

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@tothalex/cloud",
-  "version": "0.0.40",
+  "version": "0.0.44",
   "main": "",
   "types": "./src/index.d.ts",
   "files": [
-    "src/*.d.ts"
+    "src/**/*.d.ts"
   ],
   "scripts": {
     "build": "tsc",

package/src/cloud/cache.d.ts

@@ -0,0 +1,12 @@
+declare module 'cloud/cache' {
+  import { Buffer } from 'buffer'
+
+  type CacheValue = number | string | boolean | Buffer | Record<string, unknown>
+  type Cache = {
+    set: (key: string, value: CacheValue) => Promise<void>
+    get: (key: string) => Promise<CacheValue>
+    remove: (key: string) => Promise<void>
+    has: (key: string) => boolean
+  }
+  export const cache: Cache
+}

package/src/cloud/event.d.ts

@@ -0,0 +1,3 @@
+declare module 'cloud/event' {
+  export function send(eventName: string, payload: unknown): Promise<void>
+}

package/src/cloud/got.d.ts

@@ -0,0 +1,64 @@
+declare module 'cloud/got' {
+  export interface GotOptions {
+    /** Request timeout in milliseconds */
+    timeout?: number
+    /** HTTP headers */
+    headers?: Record<string, string>
+    /** HTTP method (GET, POST, PUT, DELETE, PATCH, HEAD) */
+    method?: string
+    /** JSON body (automatically sets Content-Type: application/json) */
+    json?: unknown
+    /** Raw body string */
+    body?: string
+    /** Response type: 'json' (default) or 'text' */
+    responseType?: 'json' | 'text'
+  }
+
+  export interface GotResponse {
+    body: string
+    statusCode: number
+    headers: Record<string, string>
+  }
+
+  /**
+   * Make a GET request and return parsed JSON
+   * @param url The URL to request
+   * @param options Request options
+   * @returns Parsed JSON response (when responseType is 'json') or GotResponse object
+   */
+  export function get<T = unknown>(url: string, options?: GotOptions): Promise<T>
+
+  /**
+   * Make a POST request and return parsed JSON
+   * @param url The URL to request
+   * @param options Request options
+   * @returns Parsed JSON response (when responseType is 'json') or GotResponse object
+   */
+  export function post<T = unknown>(url: string, options?: GotOptions): Promise<T>
+
+  /**
+   * Make a PUT request and return parsed JSON
+   * @param url The URL to request
+   * @param options Request options
+   * @returns Parsed JSON response (when responseType is 'json') or GotResponse object
+   */
+  export function put<T = unknown>(url: string, options?: GotOptions): Promise<T>
+
+  /**
+   * Make a DELETE request and return parsed JSON
+   * @param url The URL to request
+   * @param options Request options
+   * @returns Parsed JSON response (when responseType is 'json') or GotResponse object
+   */
+  function _delete<T = unknown>(url: string, options?: GotOptions): Promise<T>
+  export { _delete as delete }
+
+  const got: {
+    get: typeof get
+    post: typeof post
+    put: typeof put
+    delete: typeof _delete
+  }
+
+  export default got
+}

package/src/cloud/index.d.ts

@@ -0,0 +1,10 @@
+declare module 'cloud' {
+  export type HttpRequest<T = string> = {
+    id?: string
+    path: string
+    headers: Record<string, string>
+    query_params: Record<string, string>
+    params: Record<string, string>
+    body: T
+  }
+}

package/src/cloud/postgres.d.ts

@@ -0,0 +1,27 @@
+declare module 'cloud/postgres' {
+  export type SQLTag = <T = unknown>(
+    strings: TemplateStringsArray,
+    ...values: unknown[]
+  ) => Promise<Array<T>>
+  export type DatabaseTransaction = {
+    sql: SQLTag
+  }
+  export type DatabaseQueryBuilder = {
+    push: (value: string) => DatabaseQueryBuilder
+    pushBind: (value: unknown) => DatabaseQueryBuilder
+    build: () => string
+    fetchAll: <T = unknown>() => Promise<Array<T>>
+    fetchOne: <T = unknown>() => Promise<T>
+    execute: () => Promise<number>
+    getQuery: () => string
+  }
+  export type Database = {
+    sql: SQLTag
+    fetchAll: <T = unknown>(query: string, values: unknown[]) => Promise<Array<T>>
+    fetchOne: <T = unknown>(query: string, values: unknown[]) => Promise<T>
+    execute: (query: string, values: unknown[]) => Promise<number>
+    query: (query: string) => DatabaseQueryBuilder
+    transaction: <T = void>(tx: (transaction: DatabaseTransaction) => Promise<T>) => Promise<T>
+  }
+  export function pg(url: string): Promise<Database>
+}

package/src/cloud/secret.d.ts

@@ -0,0 +1,15 @@
+declare module 'cloud/secret' {
+  type Secret = {
+    store: (key: string, value: string) => Promise<void>
+    get: (key: string) => Promise<string>
+    hash: (value: string) => string
+    verify_hash: (plain: string, hashed: string) => boolean
+  }
+  export const secret: Secret
+
+  type JWT = {
+    sign: (claims: Record<string, string>) => Promise<string>
+    verify: (token: string) => Promise<Record<string, string>>
+  }
+  export const jwt: JWT
+}

package/src/cloud/uuid.d.ts

@@ -0,0 +1,6 @@
+declare module 'cloud/uuid' {
+  type UUID = {
+    toString(): string
+  }
+  export function uuid(id?: string): UUID
+}

package/src/index.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="./cloud/cache.d.ts" />
 /// <reference types="./cloud/event.d.ts" />
+/// <reference types="./cloud/got.d.ts" />
 /// <reference types="./cloud/index.d.ts" />
 /// <reference types="./cloud/postgres.d.ts" />
 /// <reference types="./cloud/secret.d.ts" />

package/src/stream/web.d.ts

@@ -0,0 +1,526 @@
+type _ByteLengthQueuingStrategy = typeof globalThis extends { onmessage: any }
+  ? {}
+  : import("stream/web").ByteLengthQueuingStrategy;
+type _CountQueuingStrategy = typeof globalThis extends { onmessage: any }
+  ? {}
+  : import("stream/web").CountQueuingStrategy;
+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 _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
+  interface ReadableWritablePair<R = any, W = any> {
+    readable: ReadableStream<R>;
+    /**
+     * Provides a convenient, chainable way of piping this readable stream
+     * through a transform stream (or any other { writable, readable }
+     * pair). It simply pipes the stream into the writable side of the
+     * supplied pair, and returns the readable side for further use.
+     *
+     * Piping a stream will lock it for the duration of the pipe, preventing
+     * any other consumer from acquiring a reader.
+     */
+    writable: WritableStream<W>;
+  }
+  interface StreamPipeOptions {
+    preventAbort?: boolean;
+    preventCancel?: boolean;
+    /**
+     * Pipes this readable stream to a given writable stream destination.
+     * The way in which the piping process behaves under various error
+     * conditions can be customized with a number of passed options. It
+     * returns a promise that fulfills when the piping process completes
+     * successfully, or rejects if any errors were encountered.
+     *
+     * Piping a stream will lock it for the duration of the pipe, preventing
+     * any other consumer from acquiring a reader.
+     *
+     * Errors and closures of the source and destination streams propagate
+     * as follows:
+     *
+     * An error in this source readable stream will abort destination,
+     * unless preventAbort is truthy. The returned promise will be rejected
+     * with the source's error, or with any error that occurs during
+     * aborting the destination.
+     *
+     * An error in destination will cancel this source readable stream,
+     * unless preventCancel is truthy. The returned promise will be rejected
+     * with the destination's error, or with any error that occurs during
+     * canceling the source.
+     *
+     * When this source readable stream closes, destination will be closed,
+     * unless preventClose is truthy. The returned promise will be fulfilled
+     * once this process completes, unless an error is encountered while
+     * closing the destination, in which case it will be rejected with that
+     * error.
+     *
+     * If destination starts out closed or closing, this source readable
+     * stream will be canceled, unless preventCancel is true. The returned
+     * promise will be rejected with an error indicating piping to a closed
+     * stream failed, or with any error that occurs during canceling the
+     * source.
+     *
+     * The signal option can be set to an AbortSignal to allow aborting an
+     * ongoing pipe operation via the corresponding AbortController. In this
+     * case, this source readable stream will be canceled, and destination
+     * aborted, unless the respective options preventCancel or preventAbort
+     * are set.
+     */
+    preventClose?: boolean;
+    signal?: AbortSignal;
+  }
+  interface ReadableStreamGenericReader {
+    readonly closed: Promise<undefined>;
+    cancel(reason?: any): Promise<void>;
+  }
+  type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
+  interface ReadableStreamReadValueResult<T> {
+    done: false;
+    value: T;
+  }
+  interface ReadableStreamReadDoneResult<T> {
+    done: true;
+    value?: T;
+  }
+  type ReadableStreamReadResult<T> =
+    | ReadableStreamReadValueResult<T>
+    | ReadableStreamReadDoneResult<T>;
+  interface ReadableByteStreamControllerCallback {
+    (controller: ReadableByteStreamController): void | PromiseLike<void>;
+  }
+  interface UnderlyingSinkAbortCallback {
+    (reason?: any): void | PromiseLike<void>;
+  }
+  interface UnderlyingSinkCloseCallback {
+    (): void | PromiseLike<void>;
+  }
+  interface UnderlyingSinkStartCallback {
+    (controller: WritableStreamDefaultController): any;
+  }
+  interface UnderlyingSinkWriteCallback<W> {
+    (
+      chunk: W,
+      controller: WritableStreamDefaultController
+    ): void | PromiseLike<void>;
+  }
+  interface UnderlyingSourceCancelCallback {
+    (reason?: any): void | PromiseLike<void>;
+  }
+  interface UnderlyingSourcePullCallback<R> {
+    (controller: ReadableStreamController<R>): void | PromiseLike<void>;
+  }
+  interface UnderlyingSourceStartCallback<R> {
+    (controller: ReadableStreamController<R>): any;
+  }
+  interface UnderlyingByteSource {
+    autoAllocateChunkSize?: number;
+    cancel?: ReadableStreamErrorCallback;
+    pull?: ReadableByteStreamControllerCallback;
+    start?: ReadableByteStreamControllerCallback;
+    type: "bytes";
+  }
+  interface UnderlyingSource<R = any> {
+    cancel?: UnderlyingSourceCancelCallback;
+    pull?: UnderlyingSourcePullCallback<R>;
+    start?: UnderlyingSourceStartCallback<R>;
+    type?: undefined;
+  }
+  interface UnderlyingSink<W = any> {
+    abort?: UnderlyingSinkAbortCallback;
+    close?: UnderlyingSinkCloseCallback;
+    start?: UnderlyingSinkStartCallback;
+    type?: undefined;
+    write?: UnderlyingSinkWriteCallback<W>;
+  }
+  interface ReadableStreamErrorCallback {
+    (reason: any): void | PromiseLike<void>;
+  }
+  interface ReadableStreamAsyncIterator<T> extends AsyncIterableIterator<T> {
+    [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>;
+    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>;
+  }
+  const ReadableStream: {
+    prototype: ReadableStream;
+    from<T>(iterable: Iterable<T> | AsyncIterable<T>): ReadableStream<T>;
+    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>>;
+    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
+    ): Promise<ReadableStreamReadResult<T>>;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/releaseLock) */
+    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;
+  };
+  interface ReadableByteStreamController {
+    readonly byobRequest: undefined;
+    readonly desiredSize: number | null;
+    close(): void;
+    enqueue(chunk: ArrayBufferView): void;
+    error(error?: any): void;
+  }
+  const ReadableByteStreamController: {
+    prototype: ReadableByteStreamController;
+    new (): ReadableByteStreamController;
+  };
+  interface ReadableStreamDefaultController<R = any> {
+    readonly desiredSize: number | null;
+    close(): void;
+    enqueue(chunk?: R): void;
+    error(e?: any): void;
+  }
+  const ReadableStreamDefaultController: {
+    prototype: ReadableStreamDefaultController;
+    new (): ReadableStreamDefaultController;
+  };
+  /**
+   * This Streams API interface provides a standard abstraction for writing
+   * streaming data to a destination, known as a sink. This object comes with
+   * built-in back pressure and queuing.
+   */
+  interface WritableStream<W = any> {
+    readonly locked: boolean;
+    abort(reason?: any): Promise<void>;
+    close(): Promise<void>;
+    getWriter(): WritableStreamDefaultWriter<W>;
+  }
+  const WritableStream: {
+    prototype: WritableStream;
+    new <W = any>(
+      underlyingSink?: UnderlyingSink<W>,
+      strategy?: QueuingStrategy<W>
+    ): WritableStream<W>;
+  };
+  /**
+   * This Streams API interface is the object returned by
+   * WritableStream.getWriter() and once created locks the < writer to the
+   * WritableStream ensuring that no other streams can write to the underlying
+   * sink.
+   */
+  interface WritableStreamDefaultWriter<W = any> {
+    readonly closed: Promise<undefined>;
+    readonly desiredSize: number | null;
+    readonly ready: Promise<undefined>;
+    abort(reason?: any): Promise<void>;
+    close(): Promise<void>;
+    releaseLock(): void;
+    write(chunk?: W): Promise<void>;
+  }
+  const WritableStreamDefaultWriter: {
+    prototype: WritableStreamDefaultWriter;
+    new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
+  };
+  /**
+   * This Streams API interface represents a controller allowing control of a
+   * WritableStream's state. When constructing a WritableStream, the
+   * underlying sink is given a corresponding WritableStreamDefaultController
+   * instance to manipulate.
+   */
+  interface WritableStreamDefaultController {
+    error(e?: any): void;
+  }
+  const WritableStreamDefaultController: {
+    prototype: WritableStreamDefaultController;
+    new (): WritableStreamDefaultController;
+  };
+  interface QueuingStrategy<T = any> {
+    highWaterMark?: number;
+    size?: QueuingStrategySize<T>;
+  }
+  interface QueuingStrategySize<T = any> {
+    (chunk?: T): number;
+  }
+  interface QueuingStrategyInit {
+    /**
+     * Creates a new ByteLengthQueuingStrategy with the provided high water
+     * mark.
+     *
+     * Note that the provided high water mark will not be validated ahead of
+     * time. Instead, if it is negative, NaN, or not a number, the resulting
+     * ByteLengthQueuingStrategy will cause the corresponding stream
+     * constructor to throw.
+     */
+    highWaterMark: number;
+  }
+  /**
+   * This Streams API interface provides a built-in byte length queuing
+   * strategy that can be used when constructing streams.
+   */
+  interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
+    readonly highWaterMark: number;
+    readonly size: QueuingStrategySize<ArrayBufferView>;
+  }
+  const ByteLengthQueuingStrategy: {
+    prototype: ByteLengthQueuingStrategy;
+    new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
+  };
+  /**
+   * This Streams API interface provides a built-in byte length queuing
+   * strategy that can be used when constructing streams.
+   */
+  interface CountQueuingStrategy extends QueuingStrategy {
+    readonly highWaterMark: number;
+    readonly size: QueuingStrategySize;
+  }
+  const CountQueuingStrategy: {
+    prototype: CountQueuingStrategy;
+    new (init: QueuingStrategyInit): CountQueuingStrategy;
+  };
+
+  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 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 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 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";
+}