export declare class SseClient {
    private reader;
    private abortCtrl;
    private heartbeatTimer;
    private timeoutTimer;
    private reconnect;
    private lastSeq;
    private buffer;
    private status;
    private options;
    private destroyed;
    /** Current connection status */
    get connectionStatus(): SseConnectionStatus;
    /** Current reconnect attempt count */
    get reconnectAttempt(): number;
    /** Last acknowledged sequence number */
    get currentSeq(): number;
    start(options: SseClientOptions): Promise<void>;
    /** Abort the current connection (does not destroy). */
    abort(): void;
    /** Permanently destroy — no further connections allowed. */
    destroy(): void;
    private _connect;
    private _processChunk;
    private _processLine;
    private _parseEvent;
    private _startHeartbeat;
    private _handleHeartbeat;
    private _handleError;
    private _scheduleReconnect;
    private _resetReconnect;
    private _setStatus;
    private _cancelReader;
    private _clearTimers;
    private _clearHeartbeat;
    private _clearReconnectTimer;
}

export declare interface SseClientOptions {
    /** Target URL */
    url: string;
    /** POST body */
    body: unknown;
    /** Request headers */
    headers: Record<string, string>;
    /** Abort signal for cancellation */
    signal?: AbortSignal;
    /** Called for every parsed stream event */
    onEvent?: (event: unknown) => void;
    /** Called on unrecoverable errors */
    onError?: (error: Error) => void;
    /** Called when connection status changes */
    onStatusChange?: (status: SseConnectionStatus) => void;
    /** Heartbeat timeout in ms (default 15000) */
    heartbeatMs?: number;
    /** Request timeout in ms (default 180000) */
    timeoutMs?: number;
    /** Reconnect config */
    reconnect?: {
        max: number;
        baseMs: number;
        maxMs?: number;
        resetOnSuccessMs?: number;
    };
    /** Last acknowledged sequence number (for resume) */
    lastSeq?: number;
    /**
     * Resume hook, consulted ONLY when re-establishing a dropped stream (i.e. on a
     * reconnect attempt, never the initial connect). Returns the additive body
     * fields that let the backend replay from where the client left off —
     * typically `{ conversationId, messageId, lastSeq }`. These are merged over the
     * base body so the same `/chat/stream` endpoint serves both fresh sends and
     * resumes (the 14-endpoint contract stays frozen). Any `lastSeq` returned here
     * takes precedence over the client's internally tracked seq.
     */
    resume?: () => Record<string, unknown> | undefined;
}

/**
 * SSE Client for AI Assistant Core
 *
 * Uses fetch + ReadableStream (not EventSource) to support:
 * - POST requests with custom headers
 * - AbortController cancellation
 * - Custom event parsing and heartbeat handling
 * - Sequence-based ack / resume protocol
 * - Exponential backoff reconnection
 */
export declare type SseConnectionStatus = 'idle' | 'connecting' | 'streaming' | 'reconnecting' | 'closed' | 'error';

export { }