/**
 * STREAMING SUPPORT
 * Real-time response streaming, SSE, backpressure, buffering
 */
export declare enum StreamEvent {
    START = "start",
    CHUNK = "chunk",
    END = "end",
    ERROR = "error",
    METADATA = "metadata"
}
export interface StreamChunk {
    id: string;
    sequence: number;
    data: unknown;
    timestamp: Date;
    metadata?: Record<string, unknown>;
}
export interface StreamConfig {
    buffer_size?: number;
    chunk_size?: number;
    enable_backpressure?: boolean;
    timeout_ms?: number;
    metadata?: Record<string, unknown>;
}
export interface StreamMetrics {
    chunks_sent: number;
    bytes_sent: number;
    duration_ms: number;
    avg_chunk_time_ms: number;
    buffer_overflows: number;
}
export declare class StreamManager {
    private streams;
    /**
     * Create new stream
     */
    create(config?: StreamConfig): Stream;
    /**
     * Get stream by ID
     */
    get(stream_id: string): Stream | null;
    /**
     * Close stream
     */
    close(stream_id: string): boolean;
    /**
     * List active streams
     */
    list(): Stream[];
    /**
     * Close all streams
     */
    closeAll(): void;
}
export declare class Stream {
    readonly id: string;
    closed: boolean;
    private config;
    private buffer;
    private sequence;
    private listeners;
    private metrics;
    private started_at?;
    constructor(config?: StreamConfig);
    /**
     * Start stream
     */
    start(): void;
    /**
     * Write chunk to stream
     */
    write(data: unknown): Promise<void>;
    /**
     * End stream
     */
    end(): void;
    /**
     * Send error
     */
    error(error: Error): void;
    /**
     * Subscribe to event
     */
    on(event: StreamEvent, listener: (...args: unknown[]) => void): void;
    /**
     * Unsubscribe from event
     */
    off(event: StreamEvent, listener: (...args: unknown[]) => void): void;
    /**
     * Get stream metrics
     */
    getMetrics(): StreamMetrics;
    /**
     * Check if buffer has space
     */
    hasCapacity(): boolean;
    private flush;
    private waitForDrain;
    private emit;
    private estimateSize;
    private generateId;
    private generateChunkId;
}
export declare class SSEHandler {
    private connections;
    /**
     * Create SSE connection
     */
    create(client_id: string): SSEConnection;
    /**
     * Get connection
     */
    get(client_id: string): SSEConnection | null;
    /**
     * Close connection
     */
    close(client_id: string): boolean;
    /**
     * Broadcast to all connections
     */
    broadcast(event: string, data: unknown): void;
    /**
     * Get active connections
     */
    getActiveConnections(): number;
}
export declare class SSEConnection {
    readonly client_id: string;
    closed: boolean;
    private messages;
    private last_event_id;
    constructor(client_id: string);
    /**
     * Send SSE message
     */
    send(event: string, data: unknown): void;
    /**
     * Get pending messages
     */
    getMessages(): string[];
    /**
     * Close connection
     */
    close(): void;
    private formatSSE;
}
export declare class BackpressureManager {
    private config;
    private buffer_size;
    private paused;
    constructor(config?: {
        low_water_mark?: number;
        high_water_mark?: number;
    });
    /**
     * Report buffer size
     */
    report(size: number): void;
    /**
     * Check if paused
     */
    isPaused(): boolean;
    /**
     * Wait until resumed
     */
    waitForResume(): Promise<void>;
    /**
     * Get current state
     */
    getState(): {
        buffer_size: number;
        paused: boolean;
    };
}
//# sourceMappingURL=stream-manager.d.ts.map