import { type EvtMirrorDelta, type EvtMirrorRefused, type EvtMirrorReset, type EvtMirrorSettled, type EvtMirrorWriteSettled, type MirrorOp, type MirrorPendingReason, type MirrorWriteOp, type MirrorWriteResult } from "@vibes.diy/vibe-types";
import { type DocWithId } from "@vibes.diy/vibe-runtime/indexeddb-store.js";
import type { HostReplicaManager } from "./host-replica-manager.js";
import type { AppIdentity } from "./host-sync-transport.js";
import { type LeaderRole, type LockManagerLike, type MakeBus } from "./tab-mirror-bus.js";
export declare function mirrorLockName(app: AppIdentity, dbName: string): string;
export declare function mirrorBusChannel(app: AppIdentity, dbName: string): string;
export type MirrorEmit = (evt: EvtMirrorDelta | EvtMirrorReset | EvtMirrorSettled | EvtMirrorRefused | EvtMirrorWriteSettled) => void;
export type SubscribeDataResult = {
    readonly mode: "snapshot";
    readonly seq: number;
    readonly docs: DocWithId[];
    readonly settled?: boolean;
    readonly confirmed?: boolean;
} | {
    readonly mode: "resume";
    readonly seq: number;
    readonly ops: MirrorOp[];
    readonly settled?: boolean;
    readonly confirmed?: boolean;
};
export interface SubscribePendingResult {
    readonly mode: "pending";
    readonly reason: MirrorPendingReason;
    readonly retryAfterMs?: number;
}
export type SubscribeResult = SubscribeDataResult | SubscribePendingResult;
export type SubscribeOpts = EphemeralOpts & {
    readonly pendingCapable?: boolean;
};
export interface EphemeralOpts {
    readonly ephemeral: boolean;
    readonly seedDocs?: DocWithId[];
    readonly seedOnly?: boolean;
}
export interface MirrorHubOptions {
    readonly manager: HostReplicaManager;
    readonly ringBufferMax?: number;
    readonly locks?: LockManagerLike;
    readonly onMissingLocks?: LeaderRole;
    readonly makeBus?: MakeBus;
    readonly busRequestTimeoutMs?: number;
}
export declare class MirrorHub {
    private readonly manager;
    private readonly ringBufferMax;
    private readonly locks?;
    private readonly onMissingLocks?;
    private readonly makeBus;
    private readonly busRequestTimeoutMs;
    private readonly dbs;
    private readonly declared;
    private readonly seedOnlyApps;
    constructor(opts: MirrorHubOptions);
    subscribe(app: AppIdentity, dbName: string, fromSeq: number | undefined, emit: MirrorEmit, subscriberKey?: string, opts?: SubscribeOpts): Promise<SubscribeResult>;
    private capableSubscribe;
    unsubscribe(app: AppIdentity, dbName: string, subscriberKey: string): void;
    declareInterests(app: AppIdentity, sourceId: string, interests: readonly string[]): void;
    private emitDeclaration;
    private emitAllDeclarations;
    write(app: AppIdentity, dbName: string, originRuntimeId: string, writes: MirrorWriteOp[], opts?: EphemeralOpts): Promise<MirrorWriteResult[]>;
    private isSeedOnlyRefusal;
    detach(appKey: string): void;
    detachAll(): void;
    private withdrawApp;
    private teardownHub;
    private ensureDb;
    private ensureEphemeralDb;
    seedEphemeral(app: AppIdentity, dbName: string, seedDocs: DocWithId[]): void;
    dropEphemeral(appKey: string): void;
    enterEphemeral(app: AppIdentity, seedsByDb: Readonly<Record<string, DocWithId[]>>): Promise<void>;
    exitEphemeral(appKey: string, opts?: {
        readonly afterSync?: boolean;
    }): Promise<void>;
    private moveAfterSync;
    private whenSynced;
    private wakeSync;
    private rebindSubscribers;
    private publishLocalDelta;
    private activateLeader;
    private leaderSubscribe;
    private catchUp;
    private leaderResult;
    private publishSettled;
    private publishSettledToSubscribers;
    private publishRefusedToSubscribers;
    private publishWriteSettled;
    private publishWriteSettledToSubscribers;
    private applyWrites;
    private followerSubscribe;
    private followerAnswer;
    private followerWrite;
    private relayToSubscribers;
    private busRequest;
    private onBusMessage;
    private canResume;
    private opsSince;
}