import type { ContentProof } from './history-content-proof.js';
import type { DshNativeTransport } from './native-transport.js';
import { DshApiProxyAdapter } from './api-proxy-adapter.js';
import { DshRemoteCommandLedger } from './command-ledger.js';
import { type DshRemoteHistoryEntry } from './dsh-event-contract.js';
import { DshRemoteRuntimeStore } from './runtime-store.js';
import { DshRemoteRuntimeSecretBroker } from './runtime-secret-broker.js';
import type { DshRemoteSessionOwnership } from './session-ownership-store.js';
import type { DshRemoteTurnUploadOutbox } from './turn-upload-outbox.js';
import { type DshRemoteControlPlane, type DshRemoteHostFacade, type DshRemoteRealtimeTransport, type DshRemoteResponse, type DshRemoteStatus, type DshRemoteTrustedEventMetadata } from './types.js';
interface HostSession {
    userId: number;
    clientId: number;
}
interface DshRemotePersistenceHeader {
    id: string;
}
interface DshRemotePersistenceSnapshot {
    header: DshRemotePersistenceHeader;
    revision: unknown;
}
export interface DshRemoteSessionPersistenceLike {
    listSnapshots(signal?: AbortSignal): Promise<DshRemotePersistenceSnapshot[]>;
    readFrom(sessionId: string, fromSeq: number, signal?: AbortSignal): Promise<{
        meta: DshRemotePersistenceHeader;
        events: DshRemoteHistoryEntry['event'][];
    }>;
    /** Public JSONL-backend seam that decodes packed rows without current message-shape validation. */
    loadStored?(sessionId: string, signal?: AbortSignal): Promise<{
        meta: DshRemotePersistenceHeader;
        events: DshRemoteHistoryEntry['event'][];
    } | undefined>;
}
interface HostRuntimeContext {
    serviceLeaseGeneration: number;
    metadata: DshRemoteTrustedEventMetadata;
}
type DshRemoteHostControlPlane = Pick<DshRemoteControlPlane, 'registerDesktop' | 'registerRuntime' | 'syncWorkspaces' | 'syncSessions' | 'completeProjectionSnapshot' | 'turnObjectUploadCapabilities' | 'knownHistorySessions' | 'appendSessionEvents'>;
export interface ArkmeRemoteRealtimeHostOptions {
    featureEnabled: boolean;
    transportAvailable?: boolean;
    profileRef: string;
    hostClientRef: string;
    displayName?: string;
    platform?: NodeJS.Platform;
    readLifecycle?: () => Promise<{
        resumeGeneration: number;
        suspended: boolean;
    } | undefined>;
    readSession: () => Promise<HostSession | undefined>;
    secretBroker: DshRemoteRuntimeSecretBroker;
    runtimeStore: DshRemoteRuntimeStore;
    sessionOwnership: DshRemoteSessionOwnership;
    controlPlane: DshRemoteHostControlPlane;
    realtime: DshRemoteRealtimeTransport;
    nativeTransport?: DshNativeTransport;
    apiProxy: DshApiProxyAdapter;
    ledgerForAccount: (accountId: string, key: Buffer) => Promise<DshRemoteCommandLedger> | DshRemoteCommandLedger;
    turnUploadForAccount?: (accountId: string, key: Buffer, maxObjectBytes: number, callbacks: {
        onError: (error: unknown, sessionRef?: string) => void;
        onFinalized: (sessionRef: string) => void;
    }) => DshRemoteTurnUploadOutbox;
    readRecoveryProof?: (session: string, through: number, signal: AbortSignal) => Promise<ContentProof>;
    sessionPersistence?: DshRemoteSessionPersistenceLike;
    now?: () => number;
    yieldToEventLoop?: () => Promise<void>;
    onDiagnostic?: (event: string, fields: Record<string, unknown>) => void;
}
/**
 * Account-login Host facade. Backend owns durable discovery/projections,
 * Realtime owns the short-lived Host lease, and DSH remains session truth.
 */
export declare class ArkmeRemoteRealtimeHost implements DshRemoteHostFacade {
    private readonly options;
    private readonly now;
    private readonly listeners;
    private runtime;
    private accountGeneration;
    private projectionController;
    private accountId;
    private clientId;
    private ledger;
    private turnUpload;
    private turnUploadActivationFlight;
    private turnUploadActivationController;
    private nextTurnUploadActivationAt;
    private attemptId;
    private failedAttemptId;
    private resumeGeneration;
    private started;
    private connected;
    private serviceLeaseGeneration;
    private revision;
    private stopEvents;
    private stopProjectionEvents;
    private channelManager;
    private stopTransportDisconnect;
    private reconnectTimer;
    private stableConnectionTimer;
    private connectionFlight;
    private connectionController;
    private reconnectAttempt;
    private sessionTimer;
    private connectionError;
    private historySyncError;
    private historySyncErrorSessionRef;
    private projectionError;
    private lastProjectionSyncAttemptMillis;
    private projectionVersion;
    private historyObjectBackfillTimer;
    private historyObjectBackfillFlight;
    private historyObjectBackfillController;
    private readonly historyObjectBackfillFailures;
    private liveEventBatcher;
    private liveDeliveryStats;
    private lastDeliveryReportAt;
    private readonly projectionUpload;
    private projectionSyncTail;
    private backgroundProjectionFlight;
    private projectionSnapshotPending;
    constructor(options: ArkmeRemoteRealtimeHostOptions);
    start(): Promise<void>;
    stop(): Promise<void>;
    suspend(): Promise<void>;
    cancelPendingConnection(): void;
    private stopLifecycle;
    private readonly desktopSessions;
    private desktopSelectionTimer;
    private desktopSelectionFlight;
    private desktopSelectionDirty;
    private publishedDesktopSelection;
    private scheduleDesktopSelection;
    reportCurrentSession(input: {
        accountId: string;
        windowRef: string;
        revision: number;
        sessionRef: string | null;
        focused?: boolean;
    }): void;
    annotationSource(sessionRef: string, seq: number, signal: AbortSignal): Promise<{
        runtimeRef: string;
        hostGeneration: number;
        entry: DshRemoteHistoryEntry;
        canonical: string;
    }>;
    currentSession(): Promise<{
        session: {
            sessionRef: string;
            workspaceRef: string;
            title?: string;
            running: boolean;
            projectionAsOfSeq?: number;
        } | null;
    }>;
    private capabilities;
    getStatus(): DshRemoteStatus;
    renameDesktop(displayName: string): Promise<DshRemoteStatus>;
    subscribe(listener: (status: DshRemoteStatus) => void): () => void;
    /** Entry used only by the authenticated Realtime channel bridge. */
    dispatchAuthorizedRequest(value: unknown, context: HostRuntimeContext): Promise<DshRemoteResponse>;
    private syncSessionSafely;
    private syncSession;
    private startTurnUploadActivation;
    private activateTurnUploadIfAvailable;
    private turnObjectUploadCapability;
    private scheduleHistoryObjectBackfill;
    private deferHistoryObjectBackfill;
    private readHistorySource;
    private syncJournalGaps;
    private backfillOneHistorySession;
    private ensureAutomaticConnection;
    private scheduleSessionSync;
    private deactivateAccount;
    private startApiProxyEvents;
    private stopApiProxyEvents;
    private adoptExistingSessions;
    private accountSessionPage;
    private ownedInteractions;
    private requireSessionOwnership;
    private requireActiveAccount;
    private publishProjectionEvent;
    private enqueueSessionEventBatch;
    private publishSessionMetadata;
    private publishSessionEventBatch;
    private clearPendingSessionEventBatches;
    private flushPendingSessionEventBatches;
    private reportLiveDelivery;
    private historyOwnerMatches;
    private yieldHistoryReconciliation;
    private handleTransportDisconnect;
    private connectHost;
    private scheduleProjectionSnapshot;
    private syncProjectionSnapshotSafely;
    private nextProjectionVersion;
    private syncProjectionSnapshot;
    private reconcileSourceBindings;
    private performProjectionSnapshot;
    private dispatch;
    private dispatchNative;
    private dispatchWrite;
    private reconcileUnsettled;
    private requireReady;
    private requireConnected;
    private bump;
    private diagnostic;
}
export {};
//# sourceMappingURL=host.d.ts.map