import { kState, kType } from './util.js';
import type { WritableStream } from './writable-stream.js';
declare const kCancel: unique symbol;
declare const kClose: unique symbol;
declare const kChunk: unique symbol;
declare const kError: unique symbol;
declare const kPull: unique symbol;
declare const kRelease: unique symbol;
/** A pull-into entry queued on a byte stream controller — produced by
 *  `readableByteStreamControllerPullInto` and consumed by the BYOB read
 *  machinery. Fields mirror Node's `PullIntoDescriptor` shape. */
interface PullIntoDescriptor {
    buffer: ArrayBufferLike;
    bufferByteLength?: number;
    byteOffset: number;
    byteLength: number;
    bytesFilled: number;
    minimumFill: number;
    elementSize: number;
    viewConstructor: ViewCtor;
    readerType: 'byob' | 'default' | 'none';
}
/** Constructor shape shared by every TypedArray ctor and `DataView`:
 *  `new (buffer, byteOffset?, length?)` producing an `ArrayBufferView`. */
type ViewCtor = new (buffer: ArrayBufferLike, byteOffset?: number, length?: number) => ArrayBufferView;
type PromiseAlgorithm = (...args: unknown[]) => Promise<unknown>;
type StartAlgorithm = (...args: unknown[]) => unknown;
type SizeAlgorithm = (chunk: unknown) => number;
/** A read request: the consumer-side sink that a controller fulfils via the
 *  `kChunk`/`kClose`/`kError` symbol callbacks. Default and BYOB read requests
 *  both satisfy this shape (BYOB passes an `ArrayBufferView`). */
interface ReadRequest {
    [kChunk](chunk: unknown): void;
    [kClose](value?: unknown): void;
    [kError](error: unknown): void;
}
interface CloseRecord {
    promise: Promise<void> | undefined;
    resolve: (() => void) | undefined;
    reject: ((reason?: unknown) => void) | undefined;
}
type AnyController = ReadableStreamDefaultController | ReadableByteStreamController;
type AnyReader = ReadableStreamDefaultReader | ReadableStreamBYOBReader;
type ReadableStreamStateName = 'readable' | 'closed' | 'errored';
interface ReadableStreamState {
    disturbed: boolean;
    reader: AnyReader | undefined;
    state: ReadableStreamStateName;
    storedError: unknown;
    controller: AnyController | undefined;
    closedPromise: PromiseWithResolvers<void>;
}
interface ReaderState {
    readRequests: ReadRequest[];
    readIntoRequests: ReadRequest[];
    stream: ReadableStream | undefined;
    close: CloseRecord;
}
interface DefaultControllerState {
    cancelAlgorithm: PromiseAlgorithm | undefined;
    closeRequested: boolean;
    highWaterMark: number;
    pullAgain: boolean;
    pullAlgorithm: PromiseAlgorithm | undefined;
    pulling: boolean;
    queue: {
        value: unknown;
        size: number;
    }[];
    queueTotalSize: number;
    started: boolean;
    sizeAlgorithm: SizeAlgorithm | undefined;
    stream: ReadableStream;
}
interface ByteQueueEntry {
    buffer: ArrayBufferLike;
    byteOffset: number;
    byteLength: number;
}
interface ByteControllerState {
    cancelAlgorithm: PromiseAlgorithm | undefined;
    closeRequested: boolean;
    highWaterMark: number;
    pullAgain: boolean;
    pullAlgorithm: PromiseAlgorithm | undefined;
    pulling: boolean;
    queue: ByteQueueEntry[];
    queueTotalSize: number;
    started: boolean;
    stream: ReadableStream;
    byobRequest: ReadableStreamBYOBRequest | null;
    pendingPullIntos: PullIntoDescriptor[];
    autoAllocateChunkSize: number | undefined;
}
interface BYOBRequestState {
    controller: ReadableByteStreamController | undefined;
    view: ArrayBufferView | null;
}
declare class ReadableStream {
    [kType]: string;
    [kState]: ReadableStreamState;
    constructor(source?: UnderlyingSource | null, strategy?: QueuingStrategy);
    get locked(): boolean;
    static from(iterable: unknown): ReadableStream;
    cancel(reason?: unknown): Promise<void>;
    getReader(options?: ReadableStreamGetReaderOptions): ReadableStreamDefaultReader | ReadableStreamBYOBReader;
    pipeThrough(transform: ReadableWritablePair, options?: StreamPipeOptions): ReadableStream;
    pipeTo(destination: WritableStream, options?: StreamPipeOptions): Promise<void>;
    tee(): [ReadableStream, ReadableStream];
    values(options?: ReadableStreamIteratorOptions): AsyncIterableIterator<unknown>;
    [Symbol.asyncIterator](): AsyncIterableIterator<unknown>;
    get [Symbol.toStringTag](): string;
}
declare class ReadableStreamDefaultReader {
    [kType]: string;
    [kState]: ReaderState;
    constructor(stream: ReadableStream);
    read(): Promise<{
        value: unknown;
        done: boolean;
    }>;
    releaseLock(): void;
    get closed(): Promise<void>;
    cancel(reason?: unknown): Promise<void>;
    get [Symbol.toStringTag](): string;
}
declare class ReadableStreamDefaultController {
    [kType]: string;
    [kState]: DefaultControllerState;
    constructor(skipThrowSymbol?: symbol);
    get desiredSize(): number | null;
    close(): void;
    enqueue(chunk?: unknown): void;
    error(error?: unknown): void;
    [kCancel](reason: unknown): Promise<unknown>;
    [kPull](readRequest: ReadRequest): void;
    [kRelease](): void;
    get [Symbol.toStringTag](): string;
}
declare const isReadableStream: (value: unknown) => value is ReadableStream;
declare const isReadableStreamDefaultController: (value: unknown) => value is ReadableStreamDefaultController;
declare const isReadableStreamDefaultReader: (value: unknown) => value is ReadableStreamDefaultReader;
declare function isReadableStreamLocked(stream: ReadableStream): boolean;
declare function readableStreamCancel(stream: ReadableStream, reason: unknown): Promise<void>;
declare function readableStreamClose(stream: ReadableStream): void;
declare function readableStreamError(stream: ReadableStream, error: unknown): void;
declare function readableStreamDefaultControllerClose(controller: ReadableStreamDefaultController): void;
declare function readableStreamDefaultControllerEnqueue(controller: ReadableStreamDefaultController, chunk: unknown): void;
declare function readableStreamDefaultControllerCanCloseOrEnqueue(controller: ReadableStreamDefaultController): boolean;
declare function readableStreamDefaultControllerGetDesiredSize(controller: ReadableStreamDefaultController): number | null;
declare function readableStreamDefaultControllerHasBackpressure(controller: ReadableStreamDefaultController): boolean;
declare function readableStreamDefaultControllerError(controller: ReadableStreamDefaultController, error: unknown): void;
declare function setupReadableStreamDefaultController(stream: ReadableStream, controller: ReadableStreamDefaultController, startAlgorithm: StartAlgorithm, pullAlgorithm: PromiseAlgorithm, cancelAlgorithm: PromiseAlgorithm, highWaterMark: number, sizeAlgorithm: (chunk: unknown) => number): void;
declare function createReadableStream(start: StartAlgorithm, pull: PromiseAlgorithm, cancel: PromiseAlgorithm, highWaterMark?: number, size?: (chunk: unknown) => number): ReadableStream;
declare class ReadableStreamBYOBReader {
    [kType]: string;
    [kState]: ReaderState;
    constructor(stream: ReadableStream);
    read(view: ArrayBufferView, options?: {
        min?: number;
    }): Promise<{
        value: ArrayBufferView | undefined;
        done: boolean;
    }>;
    releaseLock(): void;
    get closed(): Promise<void>;
    cancel(reason?: unknown): Promise<void>;
    get [Symbol.toStringTag](): string;
}
declare class ReadableStreamBYOBRequest {
    [kType]: string;
    [kState]: BYOBRequestState;
    constructor(skipThrowSymbol?: symbol);
    get view(): ArrayBufferView | null;
    respond(bytesWritten: number): void;
    respondWithNewView(view: ArrayBufferView): void;
    get [Symbol.toStringTag](): string;
}
declare class ReadableByteStreamController {
    [kType]: string;
    [kState]: ByteControllerState;
    constructor(skipThrowSymbol?: symbol);
    get byobRequest(): ReadableStreamBYOBRequest | null;
    get desiredSize(): number | null;
    close(): void;
    enqueue(chunk: ArrayBufferView): void;
    error(error?: unknown): void;
    [kCancel](reason: unknown): Promise<unknown>;
    [kPull](readRequest: ReadRequest): void;
    [kRelease](): void;
    get [Symbol.toStringTag](): string;
}
declare const isReadableByteStreamController: (value: unknown) => value is ReadableByteStreamController;
declare const isReadableStreamBYOBReader: (value: unknown) => value is ReadableStreamBYOBReader;
declare const isReadableStreamBYOBRequest: (value: unknown) => value is ReadableStreamBYOBRequest;
declare function setupReadableByteStreamController(stream: ReadableStream, controller: ReadableByteStreamController, startAlgorithm: StartAlgorithm, pullAlgorithm: PromiseAlgorithm, cancelAlgorithm: PromiseAlgorithm, highWaterMark: number, autoAllocateChunkSize: number | undefined): void;
export { ReadableStream, ReadableStreamDefaultReader, ReadableStreamDefaultController, ReadableStreamBYOBReader, ReadableStreamBYOBRequest, ReadableByteStreamController, isReadableStream, isReadableStreamLocked, isReadableStreamDefaultReader, isReadableStreamDefaultController, isReadableStreamBYOBReader, isReadableStreamBYOBRequest, isReadableByteStreamController, readableStreamCancel, readableStreamClose, readableStreamError, readableStreamDefaultControllerClose, readableStreamDefaultControllerEnqueue, readableStreamDefaultControllerError, readableStreamDefaultControllerGetDesiredSize, readableStreamDefaultControllerCanCloseOrEnqueue, readableStreamDefaultControllerHasBackpressure, setupReadableStreamDefaultController, setupReadableByteStreamController, createReadableStream, };