import type { ArkmeSessionCredentials } from './keychain-store.js';
import type { ArkmeChatRealtimeState } from './types.js';
export declare const ARKME_CHAT_SSE_PATH = "/api/v1/sse/chat/noty";
export declare const ARKME_RUNTIME_INSTANCE_ID_HEADER = "X-Jotmo-Runtime-Instance-Id";
export declare const ARKME_SSE_IDENTITY_VERSION_HEADER = "X-Jotmo-SSE-Identity-Version";
export declare const ARKME_SSE_IDENTITY_VERSION = "2";
export declare const ARKME_CHAT_RECEIVE_BIZ_TYPE = 17;
export declare const ARKME_CHAT_READ_CURSOR_ADVANCED_BIZ_TYPE = 18;
export declare const ARKME_CHAT_POLICY_UPDATED_BIZ_TYPE = 19;
export declare const ARKME_CHAT_TIMELINE_CHANGED_BIZ_TYPE = 20;
export declare const ARKME_CHAT_MESSAGE_PREPARING_BIZ_TYPE = 21;
export declare const ARKME_PROJECTION_INVALIDATED_BIZ_TYPE = 25;
export declare const ARKME_CONVERSATION_LIST_PREFERENCE_UPDATED_BIZ_TYPE = 26;
export declare const ARKME_MEMBER_JOINED_BIZ_TYPE = 24;
export declare const ARKME_MEMBER_EVENT_CREATED_BIZ_TYPE = 27;
export interface ArkmeMemberInvalidationHint {
    joinAtMillis?: number;
    eventUid: string;
    chatSessionUid: string;
    eventAtMillis: number;
}
type FetchLike = typeof fetch;
export interface ArkmeChatReceiveHint {
    eventUid: string;
    chatSessionUid: string;
    relationUid: string;
    latestSequence: number;
    senderUserId: number;
    eventAtMillis: number;
}
export interface ArkmeProjectionInvalidatedHint {
    eventUid: string;
    projection: string;
    eventAtMillis: number;
}
export interface ArkmeConversationListPreferenceUpdatedHint {
    eventUid: string;
    userId: number;
    items: Array<{
        entityKind: 1 | 2;
        entityUid: string;
        revision: number;
    }>;
    acceptedAtMillis: number;
    sourceClientId: number;
}
export interface ArkmeChatPolicyUpdatedHint {
    eventUid: string;
    chatSessionUid: string;
    userId: number;
    pinState: 1 | 2;
    policyUpdateAtMillis: number;
    eventAtMillis: number;
}
export interface ArkmeChatReadCursorAdvancedHint {
    eventUid: string;
    chatSessionUid: string;
    readerUserId: number;
    readSequence: number;
    readAtMillis: number;
    eventAtMillis: number;
}
export interface ArkmeChatTimelineChangedHint {
    eventUid: string;
    chatSessionUid: string;
    relationUid: string;
    latestSequence: number;
    actorUserId: number;
    changeKind: 'deleted' | 'recovered' | 'reedited' | 'extended';
    changeVersion: number;
    relationTerminal: boolean;
    eventAtMillis: number;
}
export interface ArkmeChatMessagePreparingHint {
    eventUid: string;
    chatSessionUid: string;
    actorUserId: number;
    prepareAtMillis: number;
    expireAtMillis: number;
    preparingState: 1 | 2;
    stateVersion: number;
    eventAtMillis: number;
    sourceClientId: number;
}
export interface ArkmeChatRealtimeNotice {
    state: ArkmeChatRealtimeState;
    teamPublication?: ArkmeTeamPublicationHint;
    teamReceiptOnly?: boolean;
    cause: 'team-message-published' | 'team-invalidation' | 'reconcile' | 'chat-hint' | 'projection-invalidation' | 'conversation-list-preference-invalidation' | 'chat-policy-invalidation' | 'local';
    hint?: ArkmeChatReceiveHint;
    policyUpdated?: ArkmeChatPolicyUpdatedHint;
    readCursorAdvanced?: ArkmeChatReadCursorAdvancedHint;
    timelineChanged?: ArkmeChatTimelineChangedHint;
    messagePreparing?: ArkmeChatMessagePreparingHint;
    /** Host-only receiving connection evidence; never project these fields to Browser. */
    connectionUserId?: number;
    connectionSignal?: AbortSignal;
    connectionStartedAtMillis?: number;
    projectionInvalidation?: ArkmeProjectionInvalidatedHint;
    conversationListPreferenceUpdated?: ArkmeConversationListPreferenceUpdatedHint;
    memberJoined?: ArkmeMemberInvalidationHint;
    memberEvent?: ArkmeMemberInvalidationHint;
}
export interface ArkmeChatRealtimeRuntimeOptions {
    imBaseUrl: string;
    readSession(): Promise<ArkmeSessionCredentials | undefined>;
    refreshSession?(session: ArkmeSessionCredentials): Promise<ArkmeSessionCredentials | undefined>;
    fetchImpl?: FetchLike;
    connectTimeoutMs?: number;
    inactivityTimeoutMs?: number;
    leaseDurationMs?: number;
    idlePollMs?: number;
    retryBaseMs?: number;
    maxRetryMs?: number;
    stableConnectionMs?: number;
    random?: () => number;
    now?: () => number;
    diagnostic?(event: 'sse_disconnected' | 'reconnect_attempt' | 'sse_identity_capability', details: {
        connectionGeneration: number;
        identityVersion?: string;
    }): void;
}
export declare const ARKME_TEAM_NOTIFICATION_BIZ_TYPE = 28;
export interface ArkmeTeamPublicationHint {
    eventUid: string;
    conversationUid: string;
    messageUid: string;
    seq: number;
    publishedAt: number;
    expiresAt: number;
}
export declare function decodeArkmeTeamNotificationDataLine(line: string): {
    eventUid: string;
    eventAtMillis: number;
    receiptOnly: boolean;
    publication?: ArkmeTeamPublicationHint;
} | undefined;
export declare function decodeArkmeMemberJoinedDataLine(line: string): ArkmeMemberInvalidationHint | undefined;
export declare function decodeArkmeMemberEventDataLine(line: string): ArkmeMemberInvalidationHint | undefined;
/** Decode one server data line. Heartbeats, malformed frames, and non-Chat hints are ignored. */
export declare function decodeArkmeChatReceiveDataLine(line: string): ArkmeChatReceiveHint | undefined;
/** Decode one metadata-only read-cursor invalidation. Counts remain owned by the Chat read-receipt API. */
export declare function decodeArkmeChatReadCursorAdvancedDataLine(line: string): ArkmeChatReadCursorAdvancedHint | undefined;
/** Policy events invalidate a directory projection; Chat list remains the source of truth. */
export declare function decodeArkmeChatPolicyUpdatedDataLine(line: string): ArkmeChatPolicyUpdatedHint | undefined;
/** Preparing is metadata only; allow ordinary protocol extensions, never embedded message/recipient facts. */
export declare function decodeArkmeChatMessagePreparingDataLine(line: string): ArkmeChatMessagePreparingHint | undefined;
/** Decode one metadata-only timeline invalidation. Record content remains owned by Chat reads. */
export declare function decodeArkmeChatTimelineChangedDataLine(line: string): ArkmeChatTimelineChangedHint | undefined;
/** Decode one metadata-only projection invalidation from the shared user realtime stream. */
export declare function decodeArkmeProjectionInvalidatedDataLine(line: string): ArkmeProjectionInvalidatedHint | undefined;
/** Decode a metadata-only invalidation. The Browser must query the Chat owner for current state. */
export declare function decodeArkmeConversationListPreferenceUpdatedDataLine(line: string): ArkmeConversationListPreferenceUpdatedHint | undefined;
export declare class ArkmeChatRealtimeRuntime {
    private readonly options;
    private readonly fetchImpl;
    private readonly connectTimeoutMs;
    private readonly inactivityTimeoutMs;
    private readonly leaseDurationMs;
    private readonly idlePollMs;
    private readonly retryBaseMs;
    private readonly maxRetryMs;
    private readonly stableConnectionMs;
    private readonly random;
    private readonly now;
    private rootController;
    private connectionController;
    private waitController;
    private loop;
    private revision;
    private connected;
    private lastAcceptedAccessToken;
    private lastConnectionLifetimeMs;
    private connectionGeneration;
    private forceReconnectRequested;
    private lastEventAtMillis;
    private lastIdentityVersion;
    private readonly seenEventUids;
    private readonly listeners;
    constructor(options: ArkmeChatRealtimeRuntimeOptions);
    start(): () => void;
    stop(): void;
    reconnect(): void;
    state(): ArkmeChatRealtimeState;
    subscribe(listener: (notice: ArkmeChatRealtimeNotice) => void): () => void;
    invalidate(): void;
    private run;
    private consume;
    private reportIdentityCapability;
    private jitteredDelay;
    private wait;
    private acceptLine;
    private advanceRevision;
}
export {};
//# sourceMappingURL=chat-realtime.d.ts.map