import type { AssistantMessage, AssistantMessageEvent } from "../types";
export declare class EventStream<T, R = T> implements AsyncIterable<T> {
    #private;
    waiting: Array<{
        resolve: (value: IteratorResult<T>) => void;
        reject: (err: unknown) => void;
    }>;
    done: boolean;
    finalResultPromise: Promise<R>;
    resolveFinalResult: (result: R) => void;
    rejectFinalResult: (err: unknown) => void;
    isComplete: (event: T) => boolean;
    extractResult: (event: T) => R;
    constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R, onConsumerClose?: () => void);
    /**
     * Read-only snapshot of the not-yet-consumed events. Always a fresh copy:
     * external code can never mutate internal queue state or observe head-index
     * tombstones or private consumer-drain sentinels, so the deque cannot desynchronize.
     */
    get queue(): T[];
    /** Read-only test seam for outstanding consumer-drain waiters. */
    get pendingConsumerDrainCountForTests(): number;
    /** Whether an async iterator is currently consuming this stream. */
    get hasActiveConsumer(): boolean;
    push(event: T): void;
    deliver(event: T): void;
    /**
     * Resolves after every event enqueued before this call has been yielded and
     * the consumer asks the iterator for its next node. The private sentinel is
     * never exposed through the async iterator.
     */
    waitForConsumerDrain(signal: AbortSignal): Promise<void>;
    end(result?: R): void;
    endWaiting(): void;
    fail(err: unknown): void;
    [Symbol.asyncIterator](): AsyncIterator<T>;
    result(): Promise<R>;
}
export declare class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
    constructor(onConsumerClose?: () => void);
}