import type { AgentContext, ContactAddedPayload, ContactApprovedPayload, ContactRemovedPayload, ContactRequestPayload, ContactRequestUpdatedPayload, ConversationUpdatedPayload, MessageCreatedPayload, MessageUpdatedPayload, TypingPayload, PresencePayload, RuntimeUpdatedPayload, RuntimeControlEventPayload, TurnUpdatedPayload, ParticipationSuppressedPayload, VoiceSessionEventPayload } from './types.js';
export interface CanonStreamErrorPayload {
    code?: string;
    message?: string;
    retryAfterMs?: number;
    activeConnections?: number;
    maxConnections?: number;
    [key: string]: unknown;
}
export interface ReplayExpiredPayload {
    /** Oldest event id still available in the server's replay buffer, if any. */
    lastAvailableId?: string | null;
    message?: string;
    [key: string]: unknown;
}
export declare class CanonStreamError extends Error {
    readonly code?: string;
    readonly retryAfterMs?: number;
    readonly payload: CanonStreamErrorPayload;
    constructor(payload: CanonStreamErrorPayload, fallbackMessage: string);
}
export type StreamHandler = {
    onMessage: (payload: MessageCreatedPayload) => void;
    onMessageUpdated?: (payload: MessageUpdatedPayload) => void;
    onAgentContext?: (ctx: AgentContext) => void;
    onContactRequest?: (payload: ContactRequestPayload) => void;
    onContactRequestUpdated?: (payload: ContactRequestUpdatedPayload) => void;
    onContactApproved?: (payload: ContactApprovedPayload) => void;
    onContactAdded?: (payload: ContactAddedPayload) => void;
    onContactRemoved?: (payload: ContactRemovedPayload) => void;
    onTyping?: (data: TypingPayload) => void;
    onPresence?: (data: PresencePayload) => void;
    onRuntimeUpdated?: (payload: RuntimeUpdatedPayload) => void;
    onTurnUpdated?: (payload: TurnUpdatedPayload) => void;
    /** Observe-only: the participation gate suppressed a turn for this agent. */
    onParticipationSuppressed?: (payload: ParticipationSuppressedPayload) => void;
    onRuntimeControl?: (payload: RuntimeControlEventPayload) => void;
    onVoiceSessionStarted?: (payload: VoiceSessionEventPayload) => void;
    onVoiceSessionEnded?: (payload: VoiceSessionEventPayload) => void;
    onMessageDeleted?: (payload: {
        conversationId: string;
        messageId: string;
    }) => void;
    onConversationUpdated?: (payload: ConversationUpdatedPayload) => void;
    onConnected?: () => void;
    onDisconnected?: () => void;
    /**
     * Fired when the server reports the replay window expired (`replay.expired`):
     * the reconnect cursor was evicted, so events in the gap were NOT replayed
     * and must be recovered out-of-band (e.g. via the REST API). The transport
     * stays policy-free — it only clears its cursor and surfaces the expiry.
     *
     * When this handler is provided it REPLACES the synthetic
     * `Replay expired — some messages may have been missed` error on `onError`;
     * raw consumers that only register `onError` keep the existing behavior.
     */
    onReplayExpired?: (payload: ReplayExpiredPayload) => void;
    onError?: (error: Error) => void;
};
/**
 * Manages a persistent SSE connection to Canon's stream service.
 *
 * Uses native fetch + ReadableStream (Node 18+) — no EventSource polyfill.
 * Supports Last-Event-ID for gapless replay on reconnect.
 */
export declare class CanonStream {
    private apiKey;
    private agentId;
    private streamUrl;
    private handler;
    private running;
    private abortController;
    private lastEventId;
    private reconnectAttempt;
    private reconnectTimer;
    private nextRetryAfterMs;
    constructor(opts: {
        apiKey: string;
        agentId: string;
        streamUrl?: string;
        handler: StreamHandler;
    });
    start(): Promise<void>;
    stop(): void;
    isRunning(): boolean;
    private requestedEventFamilies;
    private streamEndpoint;
    private connect;
    private readStream;
    private processFrame;
    private handleReplayExpired;
    private handleStreamError;
    private handleAgentContext;
    private handleMessageCreated;
    private handleMessageUpdated;
    private handleTyping;
    private handlePresence;
    private handleContactRequest;
    private handleContactApproved;
    private handleContactRequestUpdated;
    private handleContactAdded;
    private handleContactRemoved;
    private handleRuntimeUpdated;
    private handleTurnUpdated;
    private handleParticipationSuppressed;
    private handleRuntimeControl;
    private handleMessageDeleted;
    private handleConversationUpdated;
    private handleVoiceSessionStarted;
    private handleVoiceSessionEnded;
    private scheduleReconnect;
}