import { kState, kType } from './util.js';
declare const kAbort: unique symbol;
declare const kError: unique symbol;
interface WritableStreamState {
    close: PromiseRecord;
    closeRequest: PromiseRecord;
    inFlightWriteRequest: PromiseRecord;
    inFlightCloseRequest: PromiseRecord;
    pendingAbortRequest: {
        abort: PromiseRecord;
        reason: unknown;
        wasAlreadyErroring: boolean;
    };
    backpressure: boolean;
    controller: WritableStreamDefaultController | undefined;
    state: string;
    storedError: unknown;
    writeRequests: PromiseRecord[];
    writer: WritableStreamDefaultWriter | undefined;
}
interface WriterState {
    stream: WritableStream | undefined;
    close: PromiseRecord;
    ready: PromiseRecord;
}
type PromiseAlgorithm = (...args: unknown[]) => Promise<unknown>;
type StartAlgorithm = (...args: unknown[]) => unknown;
interface WritableControllerState {
    abortAlgorithm: PromiseAlgorithm | undefined;
    closeAlgorithm: PromiseAlgorithm | undefined;
    writeAlgorithm: PromiseAlgorithm | undefined;
    sizeAlgorithm: ((chunk: unknown) => number) | undefined;
    highWaterMark: number;
    queue: {
        value: unknown;
        size: number;
    }[];
    queueTotalSize: number;
    abortController: AbortController;
    started: boolean;
    stream: WritableStream;
}
export declare class WritableStream {
    [kType]: string;
    [kState]: WritableStreamState;
    constructor(sink?: UnderlyingSink | null, strategy?: QueuingStrategy);
    get locked(): boolean;
    abort(reason?: unknown): Promise<void>;
    close(): Promise<void>;
    getWriter(): WritableStreamDefaultWriter;
    get [Symbol.toStringTag](): string;
}
export declare class WritableStreamDefaultWriter {
    [kType]: string;
    [kState]: WriterState;
    constructor(stream: WritableStream);
    get closed(): Promise<void>;
    get desiredSize(): number | null;
    get ready(): Promise<void>;
    abort(reason?: unknown): Promise<void>;
    close(): Promise<void>;
    releaseLock(): void;
    write(chunk?: unknown): Promise<void>;
    get [Symbol.toStringTag](): string;
}
export declare class WritableStreamDefaultController {
    [kType]: string;
    [kState]: WritableControllerState;
    constructor(skipThrowSymbol?: symbol);
    [kAbort](reason: unknown): Promise<unknown>;
    [kError](): void;
    get signal(): AbortSignal;
    error(error?: unknown): void;
    get [Symbol.toStringTag](): string;
}
export declare const isWritableStream: (value: unknown) => value is WritableStream;
export declare const isWritableStreamDefaultWriter: (value: unknown) => value is WritableStreamDefaultWriter;
export declare const isWritableStreamDefaultController: (value: unknown) => value is WritableStreamDefaultController;
interface PromiseRecord<T = void> {
    promise: Promise<T> | undefined;
    resolve: ((value: T | PromiseLike<T>) => void) | undefined;
    reject: ((reason?: unknown) => void) | undefined;
}
export declare function isWritableStreamLocked(stream: WritableStream): boolean;
export declare function writableStreamAbort(stream: WritableStream, reason?: unknown): Promise<void>;
export declare function writableStreamClose(stream: WritableStream): Promise<void>;
export declare function writableStreamCloseQueuedOrInFlight(stream: WritableStream): boolean;
export declare function writableStreamDefaultWriterWrite(writer: WritableStreamDefaultWriter, chunk: unknown): Promise<void>;
export declare function writableStreamDefaultWriterRelease(writer: WritableStreamDefaultWriter): void;
export declare function writableStreamDefaultWriterCloseWithErrorPropagation(writer: WritableStreamDefaultWriter): Promise<void>;
export declare function writableStreamDefaultControllerErrorIfNeeded(controller: WritableStreamDefaultController, error: unknown): void;
export declare function createWritableStream(start: StartAlgorithm, write: PromiseAlgorithm, close: PromiseAlgorithm, abort: PromiseAlgorithm, highWaterMark?: number, size?: (chunk: unknown) => number): WritableStream;
export {};