import { EventEmitter } from "node:events";
import { type AddressedMessageEvent, type DeliveryPendingEvent, type DeliveryStatusEvent, type SendAckEvent, type StructuredErrorEvent } from "./types.js";
export declare const REPLACED_BY_NEW_RUNTIME_REASON = "Replaced by new Runtime";
export declare const REPLACED_BY_NEW_RUNTIME_CODE = 4001;
export declare class ConnectorError extends Error {
    readonly code: string;
    readonly to?: string;
    constructor(message: string, code: string, to?: string);
}
export declare class ConnectorClientUnavailableError extends Error {
    readonly code: "connector_client_unavailable";
    constructor(message?: string);
}
export declare class ConnectorSendAckTimeoutError extends Error {
    readonly code: "connector_send_ack_timeout";
    constructor(message?: string);
}
type ConnectorClientEvents = {
    message_received: (event: AddressedMessageEvent) => void;
    send_ack: (event: SendAckEvent) => void;
    delivery_pending: (event: DeliveryPendingEvent) => void;
    delivery_status: (event: DeliveryStatusEvent) => void;
    delivery_cursor_advanced: (cursor: number) => void;
    structured_error: (event: StructuredErrorEvent) => void;
    error: (error: Error) => void;
    connected: () => void;
    disconnected: (details: ConnectorCloseDetails) => void;
};
export interface ConnectorCloseDetails {
    code?: number;
    reason: string;
    intentional: boolean;
    wasRegistering: boolean;
    replacedByNewRuntime: boolean;
}
export interface ConnectorClientOptions {
    runtimeSessionId?: string;
}
export declare class ConnectorClient extends EventEmitter {
    private readonly url;
    private readonly token;
    private ws;
    private intentionalClose;
    private backoffMs;
    private alreadyConnectedRetries;
    private reconnectTimer;
    private registerResolve;
    private registerReject;
    private registerTimer;
    private runtimeSessionId;
    private lastKnownSeq;
    private readonly acceptedDeliveryGaps;
    private readonly seenPayloadIds;
    private readonly seenPayloadIdOrder;
    private readonly pendingPayloadIds;
    private readonly payloadIdBySeq;
    private pendingSends;
    constructor(url: string, token: string, opts?: ConnectorClientOptions);
    connect(): Promise<void>;
    disconnect(): void;
    send(to: string, content: string, contentType?: string, metadata?: Record<string, unknown>): Promise<SendAckEvent>;
    sendTyping(to: string, isTyping: boolean): boolean;
    ackDelivery(upToSeq: number): boolean;
    requestGapFill(sinceSeq: number): boolean;
    setDeliveryCursor(seq: number): void;
    resetRuntimeSessionCursorScope(runtimeSessionId: string | undefined, seq: number): void;
    getDeliveryCursor(): number | undefined;
    setRuntimeSessionId(runtimeSessionId: string | undefined): void;
    getRuntimeSessionId(): string | undefined;
    private computeContiguousDeliveryCursor;
    prepareDeliverySeqAccepted(seq: number): number | undefined;
    releaseDeliverySeqPending(seq: number): void;
    private flushDeliveryAck;
    private commitDeliveryCursor;
    markDeliverySeqAccepted(seq: number): number | undefined;
    on<K extends keyof ConnectorClientEvents>(event: K, listener: ConnectorClientEvents[K]): this;
    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
    once<K extends keyof ConnectorClientEvents>(event: K, listener: ConnectorClientEvents[K]): this;
    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
    off<K extends keyof ConnectorClientEvents>(event: K, listener: ConnectorClientEvents[K]): this;
    off(event: string | symbol, listener: (...args: unknown[]) => void): this;
    emit<K extends keyof ConnectorClientEvents>(event: K, ...args: Parameters<ConnectorClientEvents[K]>): boolean;
    emit(event: string | symbol, ...args: unknown[]): boolean;
    private doConnect;
    private sendRegister;
    private startRegisterTimeout;
    private resolveRegister;
    private rejectRegister;
    private handleMessage;
    private dispatchAddressed;
    private rememberPayloadId;
    private handleRegisterAck;
    private handleSendAck;
    private handleStructuredError;
    private handleClose;
    private handleError;
    private scheduleReconnect;
    private calculateBackoff;
    private nextExponentialBackoff;
    private clearReconnectTimer;
    private cleanupConnection;
    private sendEvent;
    private runtimeSessionTag;
    private runtimeSessionFrameMatches;
}
export {};
//# sourceMappingURL=connector-client.d.ts.map