import { EventEmitter } from 'events';
export interface StreamChunk {
    id: string;
    type: 'text' | 'tool_call' | 'error' | 'done';
    data: string;
    timestamp: number;
    metadata?: Record<string, unknown>;
}
export interface StreamOptions {
    /** High-water mark for backpressure (default 64 chunks). */
    highWaterMark?: number;
    /** Heartbeat interval in ms to keep connection alive (default 15000). */
    heartbeatInterval?: number;
}
export declare class StreamableResponse extends EventEmitter {
    readonly id: string;
    private chunks;
    private ended;
    private paused;
    private buffer;
    private highWaterMark;
    constructor(id: string, options?: StreamOptions);
    /** Push a chunk. Returns false if backpressure threshold reached. */
    push(chunk: StreamChunk): boolean;
    /** Resume after backpressure — flush buffered chunks. */
    resume(): void;
    end(): void;
    getChunks(): StreamChunk[];
    /** Collect all text chunks into a single string. */
    getText(): string;
    get isEnded(): boolean;
    get isPaused(): boolean;
    get length(): number;
}
export declare class StreamingManager {
    private streams;
    private counter;
    /** Create a new stream. */
    createStream(options?: StreamOptions): StreamableResponse;
    /** Write a text chunk to a stream. */
    writeChunk(streamId: string, data: string, metadata?: Record<string, unknown>): boolean;
    /** End a stream. */
    endStream(streamId: string): void;
    /** Get an existing stream. */
    getStream(streamId: string): StreamableResponse | undefined;
    /** Format a chunk as an SSE event string. */
    static formatSSE(chunk: StreamChunk): string;
    /** Pipe a stream to an SSE-compatible HTTP response (Express-style). */
    static pipeSSE(stream: StreamableResponse, res: {
        write(data: string): boolean;
        end(): void;
        setHeader?(name: string, value: string): void;
    }, options?: StreamOptions): void;
    get activeCount(): number;
}
//# sourceMappingURL=streaming.d.ts.map