/**
 * A single-consumer async channel with producer backpressure: push from
 * producers (await the returned promise - past the high water mark it
 * blocks until the consumer drains below low water, so OS pipe
 * backpressure can reach a child process), iterate from EXACTLY ONE
 * consumer, close to end iteration. A second concurrent iterator would
 * overwrite the consumer wake and strand the first - it throws instead.
 * push after close is a silent no-op by contract (the closer decided the
 * stream is over; racing producers must not crash).
 */
export declare class AsyncChannel<T> implements AsyncIterable<T> {
    private readonly highWater;
    private readonly lowWater;
    private items;
    private head;
    private closed;
    private wake;
    private producerWaiters;
    private consuming;
    private backpressureEnabled;
    constructor(highWater?: number, lowWater?: number);
    private get size();
    push(item: T): Promise<void>;
    close(): void;
    /** Stop blocking producers without closing delivery. This is a terminal
     * process state: the child has exited and output reads are being disposed,
     * so only already-buffered pipe data can still be added. */
    releaseBackpressure(): void;
    get isClosed(): boolean;
    private releaseProducers;
    [Symbol.asyncIterator](): AsyncIterator<T>;
}
//# sourceMappingURL=channel.d.ts.map