import * as plugins from './plugins.js';
import { type IFlexDomainHeadDocument } from './classes.flexmodels.private.js';
import { type IFlexProjectionMessageRecordDocument, type IFlexProjectionSourceDocument, type IFlexProjectionSourceManifest, type IFlexPublicCandidateDocument, type IFlexPublicMessageRecordDocument, type IFlexPublicSessionRecordDocument } from './classes.flexmodels.public.js';
type TFlexLegacySnapshot = plugins.flexharnessMigration.IFlexLegacyHarnessSnapshot;
type TFlexScopeSnapshot = plugins.flexharness.IFlexScopeSnapshot;
type TFlexProjectionSnapshot = plugins.flexharness.IFlexProjectionSnapshot;
type TStoredDomainHead = plugins.smartdata.TStoredDocument<IFlexDomainHeadDocument>;
type TFlexObjectId = TStoredDomainHead['_id'];
export interface IFlexProjectionOrderMigrationPage {
    sessionIds: string[];
    nextCursor?: TFlexObjectId;
}
export interface IFlexStoreOptions {
    database: plugins.smartdata.SmartdataDb;
    controllerId: string;
    projectManagementHost: IFlexProjectManagementHost;
    onFatalError?: (errorArg: Error) => void;
}
export interface IFlexProjectManagementHost {
    load(storageKeyArg: string, sessionIdArg: string, sessionContextArg: Readonly<plugins.flexharness.IFlexProjectManagementSessionContext>): Promise<plugins.flexharness.TFlexProjectManagementRecord | undefined>;
    save(storageKeyArg: string, sessionIdArg: string, snapshotArg: plugins.flexharness.IFlexProjectManagementSnapshot, expectedRevisionArg: number, writeContextArg: plugins.flexharness.IFlexProjectManagementWriteContext): Promise<void>;
    tombstoneSession(storageKeyArg: string, sessionIdArg: string, tombstoneArg: plugins.flexharness.IFlexProjectManagementTombstone, expectedRevisionArg: number, sessionContextArg: Readonly<plugins.flexharness.IFlexProjectManagementSessionContext>): Promise<void>;
    purgeNamespace(storageKeyArg: string): Promise<void>;
}
export interface IFlexCommittedScopeSource {
    head: IFlexDomainHeadDocument;
    snapshot: TFlexScopeSnapshot;
}
export interface IFlexCommittedProjectionSource {
    head: IFlexDomainHeadDocument;
    snapshot: TFlexProjectionSnapshot;
}
export interface IFlexPublicProjectionBuild {
    candidate: IFlexPublicCandidateDocument;
    sessions: IFlexPublicSessionRecordDocument[];
    messages: IFlexPublicMessageRecordDocument[];
}
interface IFlexProjectionSourceBuild {
    manifest: IFlexProjectionSourceManifest;
    source: IFlexProjectionSourceDocument;
    messages: IFlexProjectionMessageRecordDocument[];
}
export interface IFlexProjectionSourceLimits {
    messageLimit: number;
    messageBytesLimit: number;
    singleMessageBytesLimit: number;
}
interface IFlexCandidatePreparation {
    candidateId: string;
    incarnationId: string;
    revision: number;
    createdAt: string;
}
export declare const flexOrphanGraceMs: number;
export declare const createProjectionSource: (controllerIdArg: string, storageKeyArg: string, sessionIdArg: string, snapshotArg: TFlexProjectionSnapshot, preparationArg: IFlexCandidatePreparation, limitsArg?: IFlexProjectionSourceLimits) => IFlexProjectionSourceBuild;
export declare const createFlexPublicProjection: (controllerIdArg: string, storageKeyArg: string, candidateIdArg: string, publicationRevisionArg: number, scopeSourceArg: IFlexCommittedScopeSource, projectionSourcesArg: IFlexCommittedProjectionSource[], createdAtArg?: string) => IFlexPublicProjectionBuild;
export declare class FlexStore implements plugins.flexharness.IFlexHarnessStores {
    readonly scopes: plugins.flexharness.IFlexScopeStore;
    readonly projections: plugins.flexharness.IFlexProjectionStore;
    readonly permissions: plugins.flexharness.IFlexPermissionStore;
    readonly projectManagement: plugins.flexharness.IFlexProjectManagementStore;
    readonly agentEvents: plugins.flexharness.IFlexAgentEventStoreProvider;
    readonly jobs: plugins.flexharness.IFlexToolJobStoreProvider;
    private readonly database;
    private readonly controllerId;
    private readonly onFatalError?;
    private readonly manager;
    private initialized;
    private initPromise?;
    private closed;
    private closeComplete;
    private closePromise?;
    private closeDrainTimeoutMs;
    private maintenanceOpen;
    private readonly maintenanceAbortController;
    private orphanMaintenanceTask?;
    private orphanMaintenanceTimer?;
    private heartbeatsOpen;
    private leaseHeartbeatTimer?;
    private leaseTransitionTimeoutMs;
    private fatalError?;
    private readonly leaseTransitionAbortControllers;
    private readonly heldLeases;
    private readonly storageQueues;
    private readonly activeCandidateIds;
    private readonly agentEventStores;
    private readonly jobStores;
    constructor(optionsArg: IFlexStoreOptions);
    init(): Promise<void>;
    getLegacyMigrationStores(): plugins.flexharness.IFlexHarnessStores;
    loadLegacy(storageKeyArg: string): Promise<TFlexLegacySnapshot | undefined>;
    hasCompletedLegacyMigration(storageKeyArg: string): Promise<boolean>;
    completeLegacyMigration(storageKeyArg: string): Promise<void>;
    ensurePublicProjection(storageKeyArg: string): Promise<void>;
    listProjectionOrderMigrationPage(storageKeyArg: string, cursorArg?: TFlexObjectId): Promise<IFlexProjectionOrderMigrationPage>;
    rewriteProjectionSourceOrder(storageKeyArg: string, sessionIdArg: string): Promise<boolean>;
    purgeScope(storageKeyArg: string): Promise<void>;
    reconcileOrphans(nowArg?: number, abortSignalArg?: AbortSignal): Promise<void>;
    close(): Promise<void>;
    private loadScope;
    private saveScope;
    private loadProjection;
    private saveProjection;
    private deleteProjection;
    private loadPermission;
    private savePermission;
    private deletePermission;
    private getAgentEventStore;
    private assertBoundSession;
    private loadAgentEventSnapshot;
    private saveAgentEventSnapshot;
    private saveAgentEventArchive;
    private loadAgentEventArchive;
    private deleteAgentEventSession;
    private getJobStore;
    private loadJobSnapshot;
    private saveJobSnapshot;
    private deleteJobSession;
    private validateScopeSnapshot;
    private validateProjectionSnapshot;
    private validatePermissionSnapshot;
    private validateAgentEventSnapshot;
    private validateAgentEventArchive;
    private validateToolJobSnapshot;
    private saveDomain;
    private loadDomainDirect;
    private readLegacyHead;
    private readMigration;
    private readDomainHead;
    private readDomainHeadPage;
    private assertDomainHeadIdentity;
    private commitDomainHead;
    private deleteDomainHead;
    private loadPrivateCandidate;
    private writeAndVerifyPrivate;
    private writeAndVerifyProjectionSource;
    private loadProjectionSource;
    private loadProjectionMessageRecord;
    private buildPublicProjectionFromSources;
    private publishPublicProjection;
    private readPublicHead;
    private commitPublicHead;
    private deletePublicHead;
    private writeAndVerifyPublic;
    private verifyPublicCandidate;
    private commitHeadMutation;
    private commitHeadMutationWithLease;
    private deleteScopeRecords;
    private deleteScopeRecordBatch;
    private deleteScopeRecordBatchWithLease;
    private runStorage;
    private ensureLease;
    private verifyHeldLease;
    private runLeaseTransition;
    private throwIfFatal;
    private markLeaseLost;
    private failStore;
    private startLeaseHeartbeat;
    private heartbeatHeldLeases;
    private releaseHeldLease;
    private forgetHeldLease;
    private releaseLease;
    private cleanupPrivateByCandidate;
    private cleanupProjectionSourceByCandidate;
    private cleanupPublicByCandidate;
    private ensureMaintenanceLease;
    private runIdleMaintenanceStorage;
    private reconcileCandidateOrphans;
    private hasCandidateHeadReference;
    private evictProviderScope;
    private queueOrphanMaintenance;
    private scheduleOrphanMaintenance;
}
export {};