export interface LiveTurnPayload {
    phase: "live" | "idle";
    streamId?: string;
    messageId: string | null;
    text: string;
    reasoningId: string | null;
    reasoningText: string;
    truncated?: boolean;
}
export interface LiveTurnCoalescerOptions {
    intervalMs?: number;
    charThreshold?: number;
}
/** Merge a cumulative snapshot into retained text without duplicating it. */
export declare function mergeLiveText(existing: string, incoming: string): string;
export declare class LiveTurnCoalescer {
    private readonly emit;
    private readonly intervalMs;
    private readonly charThreshold;
    private readonly messageText;
    private readonly reasoningText;
    private activeMessageId;
    private activeReasoningId;
    private pendingChars;
    private timer;
    private idleSent;
    private lastLiveSignature;
    private lastFlushAt;
    private truncated;
    private streamId;
    constructor(emit: (payload: LiveTurnPayload) => void, options?: LiveTurnCoalescerOptions);
    startTurn(): void;
    messageDelta(data: unknown): void;
    reasoningDelta(data: unknown): void;
    finalMessage(data: unknown): void;
    finalReasoning(data: unknown): void;
    flushLive(): void;
    finishTurn(): void;
    dispose(): void;
    private scheduleOrFlush;
    private cancelTimer;
    private boundText;
}
/**
 * One operation in flight, one replaceable waiting value. Enqueueing ten
 * updates while a publish is blocked therefore produces exactly two writes:
 * the first and the newest.
 */
export declare class LatestValuePublisher<T> {
    private readonly publish;
    private readonly onError;
    private inFlight;
    private pending;
    private hasPending;
    constructor(publish: (value: T) => Promise<unknown>, onError?: (error: unknown) => void);
    enqueue(value: T): void;
    drain(): Promise<void>;
    private pump;
}
//# sourceMappingURL=live-turn.d.ts.map