@runlith/tagma 0.0.0-stage → 0.2.3

package/types/node/readline/promises.d.ts

@@ -0,0 +1,28 @@
+declare module "node:readline/promises" {
+    import { Abortable } from "node:events";
+    import { CompleterResult, Direction, Interface as _Interface, ReadLineOptions as _ReadLineOptions, } from "node:readline";
+    class Interface extends _Interface {
+        question(query: string): Promise<string>;
+        question(query: string, options: Abortable): Promise<string>;
+    }
+    class Readline {
+        constructor(stream: NodeJS.WritableStream, options?: {
+            autoCommit?: boolean | undefined;
+        });
+        clearLine(dir: Direction): this;
+        clearScreenDown(): this;
+        commit(): Promise<void>;
+        cursorTo(x: number, y?: number): this;
+        moveCursor(dx: number, dy: number): this;
+        rollback(): this;
+    }
+    type Completer = (line: string) => CompleterResult | Promise<CompleterResult>;
+    interface ReadLineOptions extends Omit<_ReadLineOptions, "completer"> {
+        completer?: Completer | undefined;
+    }
+    function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer, terminal?: boolean): Interface;
+    function createInterface(options: ReadLineOptions): Interface;
+}
+declare module "readline/promises" {
+    export * from "node:readline/promises";
+}

package/types/node/readline.d.ts

@@ -0,0 +1,94 @@
+declare module "node:readline" {
+    import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
+    interface Key {
+        sequence?: string | undefined;
+        name?: string | undefined;
+        ctrl?: boolean | undefined;
+        meta?: boolean | undefined;
+        shift?: boolean | undefined;
+    }
+    interface InterfaceEventMap {
+        "close": [
+        ];
+        "error": [
+            error: Error
+        ];
+        "history": [
+            history: string[]
+        ];
+        "line": [
+            input: string
+        ];
+        "pause": [
+        ];
+        "resume": [
+        ];
+        "SIGCONT": [
+        ];
+        "SIGINT": [
+        ];
+        "SIGTSTP": [
+        ];
+    }
+    class Interface implements EventEmitter, Disposable {
+        protected constructor(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean);
+        protected constructor(options: ReadLineOptions);
+        readonly terminal: boolean;
+        readonly line: string;
+        readonly cursor: number;
+        getPrompt(): string;
+        setPrompt(prompt: string): void;
+        prompt(preserveCursor?: boolean): void;
+        question(query: string, callback: (answer: string) => void): void;
+        question(query: string, options: Abortable, callback: (answer: string) => void): void;
+        pause(): this;
+        resume(): this;
+        close(): void;
+        [Symbol.dispose](): void;
+        write(data: string | Buffer, key?: Key): void;
+        write(data: undefined | null | string | Buffer, key: Key): void;
+        getCursorPos(): CursorPos;
+        [Symbol.asyncIterator](): NodeJS.AsyncIterator<string>;
+    }
+    interface Interface extends InternalEventEmitter<InterfaceEventMap> {
+    }
+    type ReadLine = Interface;
+    type Completer = (line: string) => CompleterResult;
+    type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => void;
+    type CompleterResult = [
+        string[],
+        string
+    ];
+    interface ReadLineOptions {
+        input: NodeJS.ReadableStream;
+        output?: NodeJS.WritableStream | undefined;
+        completer?: Completer | AsyncCompleter | undefined;
+        terminal?: boolean | undefined;
+        history?: string[] | undefined;
+        historySize?: number | undefined;
+        removeHistoryDuplicates?: boolean | undefined;
+        prompt?: string | undefined;
+        crlfDelay?: number | undefined;
+        escapeCodeTimeout?: number | undefined;
+        tabSize?: number | undefined;
+        signal?: AbortSignal | undefined;
+    }
+    function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
+    function createInterface(options: ReadLineOptions): Interface;
+    function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
+    type Direction = -1 | 0 | 1;
+    interface CursorPos {
+        rows: number;
+        cols: number;
+    }
+    function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
+    function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
+    function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
+    function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
+}
+declare module "node:readline" {
+    export * as promises from "node:readline/promises";
+}
+declare module "readline" {
+    export * from "node:readline";
+}

package/types/node/repl.d.ts

@@ -0,0 +1,104 @@
+declare module "node:repl" {
+    import { AsyncCompleter, Completer, Interface, InterfaceEventMap } from "node:readline";
+    import { InspectOptions } from "node:util";
+    import { Context } from "node:vm";
+    interface ReplOptions {
+        prompt?: string | undefined;
+        input?: NodeJS.ReadableStream | undefined;
+        output?: NodeJS.WritableStream | undefined;
+        terminal?: boolean | undefined;
+        eval?: REPLEval | undefined;
+        preview?: boolean | undefined;
+        useColors?: boolean | undefined;
+        useGlobal?: boolean | undefined;
+        ignoreUndefined?: boolean | undefined;
+        writer?: REPLWriter | undefined;
+        completer?: Completer | AsyncCompleter | undefined;
+        replMode?: typeof REPL_MODE_SLOPPY | typeof REPL_MODE_STRICT | undefined;
+        breakEvalOnSigint?: boolean | undefined;
+        handleError?: ((err: unknown) => "print" | "ignore" | "unhandled") | undefined;
+    }
+    type REPLEval = (this: REPLServer, evalCmd: string, context: Context, file: string, cb: (err: Error | null, result: any) => void) => void;
+    type REPLWriter = (this: REPLServer, obj: any) => string;
+    const writer: REPLWriter & {
+        options: InspectOptions;
+    };
+    type REPLCommandAction = (this: REPLServer, text: string) => void;
+    interface REPLCommand {
+        help?: string | undefined;
+        action: REPLCommandAction;
+    }
+    interface REPLServerSetupHistoryOptions {
+        filePath?: string | undefined;
+        size?: number | undefined;
+        removeHistoryDuplicates?: boolean | undefined;
+        onHistoryFileLoaded?: ((err: Error | null, repl: REPLServer) => void) | undefined;
+    }
+    interface REPLServerEventMap extends InterfaceEventMap {
+        "exit": [
+        ];
+        "reset": [
+            context: Context
+        ];
+    }
+    class REPLServer extends Interface {
+        private constructor();
+        readonly context: Context;
+        readonly inputStream: NodeJS.ReadableStream;
+        readonly outputStream: NodeJS.WritableStream;
+        readonly input: NodeJS.ReadableStream;
+        readonly output: NodeJS.WritableStream;
+        readonly commands: NodeJS.ReadOnlyDict<REPLCommand>;
+        readonly editorMode: boolean;
+        readonly underscoreAssigned: boolean;
+        readonly last: any;
+        readonly underscoreErrAssigned: boolean;
+        readonly lastError: any;
+        readonly eval: REPLEval;
+        readonly useColors: boolean;
+        readonly useGlobal: boolean;
+        readonly ignoreUndefined: boolean;
+        readonly writer: REPLWriter;
+        readonly completer: Completer | AsyncCompleter;
+        readonly replMode: typeof REPL_MODE_SLOPPY | typeof REPL_MODE_STRICT;
+        defineCommand(keyword: string, cmd: REPLCommandAction | REPLCommand): void;
+        displayPrompt(preserveCursor?: boolean): void;
+        clearBufferedCommand(): void;
+        setupHistory(historyPath: string, callback: (err: Error | null, repl: this) => void): void;
+        setupHistory(historyConfig?: REPLServerSetupHistoryOptions, callback?: (err: Error | null, repl: this) => void): void;
+        addListener<E extends keyof REPLServerEventMap>(eventName: E, listener: (...args: REPLServerEventMap[E]) => void): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof REPLServerEventMap>(eventName: E, ...args: REPLServerEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof REPLServerEventMap>(eventName: E, listener?: (...args: REPLServerEventMap[E]) => void): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof REPLServerEventMap>(eventName: E): ((...args: REPLServerEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof REPLServerEventMap>(eventName: E, listener: (...args: REPLServerEventMap[E]) => void): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof REPLServerEventMap>(eventName: E, listener: (...args: REPLServerEventMap[E]) => void): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof REPLServerEventMap>(eventName: E, listener: (...args: REPLServerEventMap[E]) => void): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof REPLServerEventMap>(eventName: E, listener: (...args: REPLServerEventMap[E]) => void): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof REPLServerEventMap>(eventName: E, listener: (...args: REPLServerEventMap[E]) => void): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof REPLServerEventMap>(eventName: E): ((...args: REPLServerEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        removeAllListeners<E extends keyof REPLServerEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof REPLServerEventMap>(eventName: E, listener: (...args: REPLServerEventMap[E]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    }
+    const REPL_MODE_SLOPPY: unique symbol;
+    const REPL_MODE_STRICT: unique symbol;
+    function start(options?: string | ReplOptions): REPLServer;
+    class Recoverable extends SyntaxError {
+        err: Error;
+        constructor(err: Error);
+    }
+}
+declare module "repl" {
+    export * from "node:repl";
+}

package/types/node/sea.d.ts

@@ -0,0 +1,11 @@
+declare module "node:sea" {
+    type AssetKey = string;
+    function isSea(): boolean;
+    function getAsset(key: AssetKey): ArrayBuffer;
+    function getAsset(key: AssetKey, encoding: string): string;
+    function getAssetAsBlob(key: AssetKey, options?: {
+        type: string;
+    }): Blob;
+    function getRawAsset(key: AssetKey): ArrayBuffer;
+    function getAssetKeys(): string[];
+}

package/types/node/sqlite.d.ts

@@ -0,0 +1,183 @@
+declare module "node:sqlite" {
+    import { PathLike } from "node:fs";
+    type SQLInputValue = null | number | bigint | string | NodeJS.ArrayBufferView;
+    type SQLOutputValue = null | number | bigint | string | NodeJS.NonSharedUint8Array;
+    interface DatabaseSyncOptions {
+        open?: boolean | undefined;
+        enableForeignKeyConstraints?: boolean | undefined;
+        enableDoubleQuotedStringLiterals?: boolean | undefined;
+        readOnly?: boolean | undefined;
+        allowExtension?: boolean | undefined;
+        timeout?: number | undefined;
+        readBigInts?: boolean | undefined;
+        returnArrays?: boolean | undefined;
+        allowBareNamedParameters?: boolean | undefined;
+        allowUnknownNamedParameters?: boolean | undefined;
+        defensive?: boolean | undefined;
+        limits?: NodeJS.PartialOptions<DatabaseLimits> | undefined;
+    }
+    interface DatabaseLimits {
+        length: number;
+        sqlLength: number;
+        column: number;
+        exprDepth: number;
+        compoundSelect: number;
+        vdbeOp: number;
+        functionArg: number;
+        attach: number;
+        likePatternLength: number;
+        variableNumber: number;
+        triggerDepth: number;
+    }
+    interface CreateSessionOptions {
+        table?: string | undefined;
+        db?: string | undefined;
+    }
+    interface ApplyChangesetOptions {
+        filter?: ((tableName: string) => boolean) | undefined;
+        onConflict?: ((conflictType: number) => number) | undefined;
+    }
+    interface FunctionOptions {
+        deterministic?: boolean | undefined;
+        directOnly?: boolean | undefined;
+        useBigIntArguments?: boolean | undefined;
+        varargs?: boolean | undefined;
+    }
+    interface AggregateOptions<T extends SQLInputValue = SQLInputValue> extends FunctionOptions {
+        start: T | (() => T);
+        step: (accumulator: T, ...args: SQLOutputValue[]) => T;
+        result?: ((accumulator: T) => SQLInputValue) | undefined;
+        inverse?: ((accumulator: T, ...args: SQLOutputValue[]) => T) | undefined;
+    }
+    interface PrepareOptions {
+        readBigInts?: boolean | undefined;
+        returnArrays?: boolean | undefined;
+        allowBareNamedParameters?: boolean | undefined;
+        allowUnknownNamedParameters?: boolean | undefined;
+    }
+    class DatabaseSync implements Disposable {
+        constructor(path: PathLike, options?: DatabaseSyncOptions);
+        aggregate(name: string, options: AggregateOptions): void;
+        aggregate<T extends SQLInputValue>(name: string, options: AggregateOptions<T>): void;
+        close(): void;
+        loadExtension(path: string): void;
+        enableLoadExtension(allow: boolean): void;
+        enableDefensive(active: boolean): void;
+        location(dbName?: string): string | null;
+        exec(sql: string): void;
+        function(name: string, options: FunctionOptions, fn: (...args: SQLOutputValue[]) => SQLInputValue): void;
+        function(name: string, fn: (...args: SQLOutputValue[]) => SQLInputValue): void;
+        setAuthorizer(callback: ((actionCode: number, arg1: string | null, arg2: string | null, dbName: string | null, triggerOrView: string | null) => number) | null): void;
+        readonly isOpen: boolean;
+        readonly isTransaction: boolean;
+        readonly limits: DatabaseLimits;
+        open(): void;
+        prepare(sql: string, options?: PrepareOptions): StatementSync;
+        createTagStore(maxSize?: number): SQLTagStore;
+        createSession(options?: CreateSessionOptions): Session;
+        applyChangeset(changeset: Uint8Array, options?: ApplyChangesetOptions): boolean;
+        [Symbol.dispose](): void;
+    }
+    interface Session {
+        changeset(): NodeJS.NonSharedUint8Array;
+        patchset(): NodeJS.NonSharedUint8Array;
+        close(): void;
+        [Symbol.dispose](): void;
+    }
+    interface SQLTagStore {
+        all(stringElements: TemplateStringsArray, ...boundParameters: SQLInputValue[]): Record<string, SQLOutputValue>[];
+        get(stringElements: TemplateStringsArray, ...boundParameters: SQLInputValue[]): Record<string, SQLOutputValue> | undefined;
+        iterate(stringElements: TemplateStringsArray, ...boundParameters: SQLInputValue[]): NodeJS.Iterator<Record<string, SQLOutputValue>>;
+        run(stringElements: TemplateStringsArray, ...boundParameters: SQLInputValue[]): StatementResultingChanges;
+        readonly size: number;
+        readonly capacity: number;
+        readonly db: DatabaseSync;
+        clear(): void;
+    }
+    interface StatementColumnMetadata {
+        column: string | null;
+        database: string | null;
+        name: string;
+        table: string | null;
+        type: string | null;
+    }
+    interface StatementResultingChanges {
+        changes: number | bigint;
+        lastInsertRowid: number | bigint;
+    }
+    class StatementSync {
+        private constructor();
+        all(...anonymousParameters: SQLInputValue[]): Record<string, SQLOutputValue>[];
+        all(namedParameters: Record<string, SQLInputValue>, ...anonymousParameters: SQLInputValue[]): Record<string, SQLOutputValue>[];
+        columns(): StatementColumnMetadata[];
+        readonly expandedSQL: string;
+        get(...anonymousParameters: SQLInputValue[]): Record<string, SQLOutputValue> | undefined;
+        get(namedParameters: Record<string, SQLInputValue>, ...anonymousParameters: SQLInputValue[]): Record<string, SQLOutputValue> | undefined;
+        iterate(...anonymousParameters: SQLInputValue[]): NodeJS.Iterator<Record<string, SQLOutputValue>>;
+        iterate(namedParameters: Record<string, SQLInputValue>, ...anonymousParameters: SQLInputValue[]): NodeJS.Iterator<Record<string, SQLOutputValue>>;
+        run(...anonymousParameters: SQLInputValue[]): StatementResultingChanges;
+        run(namedParameters: Record<string, SQLInputValue>, ...anonymousParameters: SQLInputValue[]): StatementResultingChanges;
+        setAllowBareNamedParameters(enabled: boolean): void;
+        setAllowUnknownNamedParameters(enabled: boolean): void;
+        setReturnArrays(enabled: boolean): void;
+        setReadBigInts(enabled: boolean): void;
+        readonly sourceSQL: string;
+    }
+    interface BackupOptions {
+        source?: string | undefined;
+        target?: string | undefined;
+        rate?: number | undefined;
+        progress?: ((progressInfo: BackupProgressInfo) => void) | undefined;
+    }
+    interface BackupProgressInfo {
+        totalPages: number;
+        remainingPages: number;
+    }
+    function backup(sourceDb: DatabaseSync, path: PathLike, options?: BackupOptions): Promise<number>;
+    namespace constants {
+        const SQLITE_CHANGESET_DATA: number;
+        const SQLITE_CHANGESET_NOTFOUND: number;
+        const SQLITE_CHANGESET_CONFLICT: number;
+        const SQLITE_CHANGESET_FOREIGN_KEY: number;
+        const SQLITE_CHANGESET_OMIT: number;
+        const SQLITE_CHANGESET_REPLACE: number;
+        const SQLITE_CHANGESET_ABORT: number;
+        const SQLITE_DENY: number;
+        const SQLITE_IGNORE: number;
+        const SQLITE_OK: number;
+        const SQLITE_CREATE_INDEX: number;
+        const SQLITE_CREATE_TABLE: number;
+        const SQLITE_CREATE_TEMP_INDEX: number;
+        const SQLITE_CREATE_TEMP_TABLE: number;
+        const SQLITE_CREATE_TEMP_TRIGGER: number;
+        const SQLITE_CREATE_TEMP_VIEW: number;
+        const SQLITE_CREATE_TRIGGER: number;
+        const SQLITE_CREATE_VIEW: number;
+        const SQLITE_DELETE: number;
+        const SQLITE_DROP_INDEX: number;
+        const SQLITE_DROP_TABLE: number;
+        const SQLITE_DROP_TEMP_INDEX: number;
+        const SQLITE_DROP_TEMP_TABLE: number;
+        const SQLITE_DROP_TEMP_TRIGGER: number;
+        const SQLITE_DROP_TEMP_VIEW: number;
+        const SQLITE_DROP_TRIGGER: number;
+        const SQLITE_DROP_VIEW: number;
+        const SQLITE_INSERT: number;
+        const SQLITE_PRAGMA: number;
+        const SQLITE_READ: number;
+        const SQLITE_SELECT: number;
+        const SQLITE_TRANSACTION: number;
+        const SQLITE_UPDATE: number;
+        const SQLITE_ATTACH: number;
+        const SQLITE_DETACH: number;
+        const SQLITE_ALTER_TABLE: number;
+        const SQLITE_REINDEX: number;
+        const SQLITE_ANALYZE: number;
+        const SQLITE_CREATE_VTABLE: number;
+        const SQLITE_DROP_VTABLE: number;
+        const SQLITE_FUNCTION: number;
+        const SQLITE_SAVEPOINT: number;
+        const SQLITE_COPY: number;
+        const SQLITE_RECURSIVE: number;
+    }
+}

package/types/node/stream/consumers.d.ts

@@ -0,0 +1,13 @@
+declare module "node:stream/consumers" {
+    import { Blob, NonSharedBuffer } from "node:buffer";
+    import { ReadableStream } from "node:stream/web";
+    function arrayBuffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<ArrayBuffer>;
+    function blob(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<Blob>;
+    function buffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NonSharedBuffer>;
+    function bytes(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NodeJS.NonSharedUint8Array>;
+    function json(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<unknown>;
+    function text(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<string>;
+}
+declare module "stream/consumers" {
+    export * from "node:stream/consumers";
+}

package/types/node/stream/iter.d.ts

@@ -0,0 +1,240 @@
+declare module "node:stream/iter" {
+    const broadcastProtocol: unique symbol;
+    const drainableProtocol: unique symbol;
+    const shareProtocol: unique symbol;
+    const shareSyncProtocol: unique symbol;
+    const toAsyncStreamable: unique symbol;
+    const toStreamable: unique symbol;
+    type Source = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncSource> | AsyncIterable<Source> | Streamable | AsyncStreamable;
+    type SyncSource = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncSource> | Streamable;
+    type Transform = StatelessTransformFn | StatefulTransform;
+    type SyncTransform = SyncStatelessTransformFn | SyncStatefulTransform;
+    type TransformResult = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncTransformResult> | AsyncIterable<TransformResult>;
+    type SyncTransformResult = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncTransformResult>;
+    interface AsyncStreamable {
+        [toAsyncStreamable](): Source;
+    }
+    interface Broadcastable {
+        [broadcastProtocol](options: BroadcastOptions): Broadcast;
+    }
+    interface Drainable {
+        [drainableProtocol](): Promise<boolean> | null;
+    }
+    interface Shareable {
+        [shareProtocol](options: ShareOptions): Share;
+    }
+    interface Streamable {
+        [toStreamable](): SyncSource;
+    }
+    interface SyncShareable {
+        [shareSyncProtocol](options: ShareSyncOptions): SyncShare;
+    }
+    type BackpressurePolicy = "strict" | "block" | "drop-oldest" | "drop-newest";
+    type ByteReadableStream = AsyncIterable<Uint8Array[]>;
+    type SyncByteReadableStream = Iterable<Uint8Array[]>;
+    interface WriteOptions {
+        signal?: AbortSignal;
+    }
+    interface PushStreamOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        signal?: AbortSignal;
+    }
+    interface PullOptions {
+        signal?: AbortSignal;
+    }
+    interface PipeToOptions {
+        signal?: AbortSignal;
+        preventClose?: boolean;
+        preventFail?: boolean;
+    }
+    interface PipeToSyncOptions {
+        preventClose?: boolean;
+        preventFail?: boolean;
+    }
+    interface ConsumeOptions {
+        signal?: AbortSignal;
+        limit?: number;
+    }
+    interface ConsumeSyncOptions {
+        limit?: number;
+    }
+    interface TextConsumeOptions extends ConsumeOptions {
+        encoding?: string;
+    }
+    interface TextConsumeSyncOptions extends ConsumeSyncOptions {
+        encoding?: string;
+    }
+    interface MergeOptions {
+        signal?: AbortSignal;
+    }
+    interface BroadcastOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        signal?: AbortSignal;
+    }
+    interface ShareOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        signal?: AbortSignal;
+    }
+    interface ShareSyncOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+    }
+    interface DuplexDirectionOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+    }
+    interface DuplexOptions {
+        highWaterMark?: number;
+        backpressure?: BackpressurePolicy;
+        a?: DuplexDirectionOptions;
+        b?: DuplexDirectionOptions;
+        signal?: AbortSignal;
+    }
+    interface TransformCallbackOptions {
+        signal: AbortSignal;
+    }
+    interface StatelessTransformFn {
+        (chunks: Uint8Array[] | null, options: TransformCallbackOptions): Promise<TransformResult | null> | TransformResult | null;
+    }
+    interface SyncStatelessTransformFn {
+        (chunks: Uint8Array[] | null): SyncTransformResult | null;
+    }
+    interface StatefulTransform {
+        transform(source: AsyncIterable<Uint8Array[] | null>, options: TransformCallbackOptions): AsyncIterable<TransformResult>;
+    }
+    interface SyncStatefulTransform {
+        transform(source: Iterable<Uint8Array[] | null>): Iterable<SyncTransformResult>;
+    }
+    interface PushWriter extends Writer, Drainable {
+    }
+    interface PushStreamResult {
+        writer: PushWriter;
+        readable: ByteReadableStream;
+    }
+    interface BroadcastWriter extends Writer, Drainable {
+    }
+    interface BroadcastResult {
+        writer: BroadcastWriter;
+        broadcast: Broadcast;
+    }
+    interface Writer extends Disposable, AsyncDisposable {
+        readonly desiredSize: number | null;
+        write(chunk: Uint8Array | string, options?: WriteOptions): Promise<void>;
+        writev(chunks: Array<Uint8Array | string>, options?: WriteOptions): Promise<void>;
+        writeSync(chunk: Uint8Array | string): boolean;
+        writevSync(chunks: Array<Uint8Array | string>): boolean;
+        end(options?: WriteOptions): Promise<number>;
+        endSync(): number;
+        fail(reason?: any): void;
+    }
+    interface PartialWriter extends Partial<Writer> {
+        write(chunk: Uint8Array | string, options?: WriteOptions): Promise<void>;
+    }
+    interface SyncWriter extends Disposable {
+        readonly desiredSize: number | null;
+        writeSync(chunk: Uint8Array | string): number;
+        writevSync(chunks: Array<Uint8Array | string>): number;
+        endSync(): number;
+        fail(reason?: any): void;
+    }
+    interface PartialSyncWriter extends Partial<SyncWriter> {
+        writeSync(chunk: Uint8Array | string): number;
+    }
+    interface Broadcast extends Disposable {
+        readonly consumerCount: number;
+        readonly bufferSize: number;
+        push(...args: any[]): ByteReadableStream;
+        cancel(reason?: any): void;
+    }
+    interface Share extends Disposable {
+        readonly consumerCount: number;
+        readonly bufferSize: number;
+        pull(...args: any[]): ByteReadableStream;
+        cancel(reason?: any): void;
+    }
+    interface SyncShare extends Disposable {
+        readonly consumerCount: number;
+        readonly bufferSize: number;
+        pull(...args: any): SyncByteReadableStream;
+        cancel(reason?: any): void;
+    }
+    interface DuplexChannel extends AsyncDisposable {
+        readonly writer: Writer;
+        readonly readable: ByteReadableStream;
+        close(): Promise<void>;
+    }
+    function push(...transforms: Transform[]): PushStreamResult;
+    function push(...args: [
+        ...transforms: Transform[],
+        options: PushStreamOptions
+    ]): PushStreamResult;
+    function from(input: Source): ByteReadableStream;
+    function fromSync(input: SyncSource): SyncByteReadableStream;
+    function pull(source: Source, ...transforms: Transform[]): ByteReadableStream;
+    function pull(source: Source, ...args: [
+        ...transforms: Transform[],
+        options: PullOptions
+    ]): ByteReadableStream;
+    function pullSync(source: SyncSource, ...transforms: SyncTransform[]): SyncByteReadableStream;
+    function pipeTo(source: Source, writer: PartialWriter, options?: PipeToOptions): Promise<number>;
+    function pipeTo(source: Source, ...args: [
+        ...transforms: Transform[],
+        writer: PartialWriter
+    ]): Promise<number>;
+    function pipeTo(source: Source, ...args: [
+        ...transforms: Transform[],
+        writer: PartialWriter,
+        options: PipeToOptions
+    ]): Promise<number>;
+    function pipeToSync(source: SyncSource, writer: PartialSyncWriter, options?: PipeToSyncOptions): number;
+    function pipeToSync(source: SyncSource, ...args: [
+        ...transforms: SyncTransform[],
+        writer: PartialSyncWriter
+    ]): number;
+    function pipeToSync(source: SyncSource, ...args: [
+        ...transforms: SyncTransform[],
+        writer: PartialSyncWriter,
+        options: PipeToSyncOptions
+    ]): number;
+    function bytes(source: Source, options?: ConsumeOptions): Promise<Uint8Array>;
+    function bytesSync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array;
+    function text(source: Source, options?: TextConsumeOptions): Promise<string>;
+    function textSync(source: SyncSource, options?: TextConsumeSyncOptions): string;
+    function arrayBuffer(source: Source, options?: ConsumeOptions): Promise<ArrayBuffer>;
+    function arrayBufferSync(source: SyncSource, options?: ConsumeSyncOptions): ArrayBuffer;
+    function array(source: Source, options?: ConsumeOptions): Promise<Uint8Array[]>;
+    function arraySync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array[];
+    function tap(callback: StatelessTransformFn): StatelessTransformFn;
+    function tapSync(callback: SyncStatelessTransformFn): SyncStatelessTransformFn;
+    function merge(...sources: Source[]): ByteReadableStream;
+    function merge(...args: [
+        ...sources: Source[],
+        options: MergeOptions
+    ]): ByteReadableStream;
+    function ondrain(drainable: any): Promise<boolean> | null;
+    function broadcast(options?: BroadcastOptions): BroadcastResult;
+    function share(source: Source, options?: ShareOptions): Share;
+    function shareSync(source: SyncSource, options?: ShareSyncOptions): SyncShare;
+    function duplex(options?: DuplexOptions): [
+        DuplexChannel,
+        DuplexChannel
+    ];
+    namespace Broadcast {
+        function from(input: ByteReadableStream | SyncByteReadableStream | Broadcastable, options?: BroadcastOptions): BroadcastResult;
+    }
+    namespace Share {
+        function from(input: ByteReadableStream | SyncByteReadableStream | Shareable, options?: ShareOptions): Share;
+    }
+    namespace SyncShare {
+        function from(input: SyncByteReadableStream | SyncShareable, options?: ShareSyncOptions): SyncShare;
+    }
+    namespace Stream {
+        export { array, arrayBuffer, arrayBufferSync, arraySync, broadcast, broadcastProtocol, bytes, bytesSync, drainableProtocol, duplex, from, fromSync, merge, ondrain, pipeTo, pipeToSync, pull, pullSync, push, share, shareProtocol, shareSync, shareSyncProtocol, tap, tapSync, text, textSync, toAsyncStreamable, toStreamable, };
+    }
+}
+declare module "stream/iter" {
+    export * from "node:stream/iter";
+}