import { ControllerCodexConnectionStore } from './classes.codexconnectionstore.js';
import * as plugins from './plugins.js';
import { type ICodexCreationRuntime, type IControllerCodexCreationDocument } from './classes.codexcreationmodels.js';
import type { ICodexCreationScope, IBeginCodexCreationInput } from './classes.codexcreationstore.js';
import { type IAuthStore, type IConsumeCeremonyOptions, type IControllerAuditEvent, type IControllerAuthDocument, type IRecordAuditEventInput, type IMintedTempPassword, type ISetupAuthority, type IStoredPasskeyCredential, type TWebAuthnCeremonyKind, type IWebAuthnCeremonyDocument, type IWebAuthnSetupCeremonyDocument } from './interfaces.auth.js';
import type { IControllerRuntimeConfig } from './interfaces.config.js';
import type { IControllerIssuerIdentity } from './interfaces.identity.js';
import { type IControllerFlexCleanupEntry } from './classes.managedsessionmodels.js';
import { ControllerSessionIdentityService, type IAdmitControllerManagedSessionInput, type IBeginControllerManagedSessionCreationInput, type IBeginControllerManagedSessionDeletionInput, type ICancelControllerManagedSessionDeletionInput, type ICompleteControllerManagedSessionCreationAdmissionInput, type ICompleteControllerManagedSessionDeletionInput, type IControllerManagedSessionDeletionObligation, type IControllerSessionManagedObservation, type IControllerSessionCreationObligation, type IGetControllerSessionCreationObligationInput, type IListControllerManagedSessionDeletionObligationsInput, type IListControllerFlexManagedCleanupRootsInput, type IListControllerSessionCreationObligationsInput, type IMarkControllerManagedSessionCreationDispatchedInput, type IMarkControllerManagedSessionDeletionDispatchedInput, type IRequireControllerManagedSessionInput, type IRetireControllerManagedSessionCreationInput, type IRetireControllerProjectManagedSessionsInput, type IResolveControllerFlexHostSessionAuthorityInput, type IResolveControllerFlexProjectManagementRegistrationLoadAuthorityInput, type IResolveControllerPendingFlexProjectManagementLoadAuthorityInput, type IResolveControllerSessionLayoutAuthorityInput, type IResolveRetiredManagedSessionIdentityInput, type TControllerFlexHostSessionAuthority, type TControllerFlexProjectManagementRegistrationLoadAuthority, type TControllerPendingFlexProjectManagementLoadAuthority, type TControllerSessionLayoutAuthority } from './classes.sessionidentityservice.js';
import { authStoreSessionIdentityCapability, type IAuthStoreSessionIdentityCapability } from './classes.sessionidentityintegration.js';
import { type IControllerTrackedConversationDocument, type IControllerProjectFilesystemIdentity, type IControllerProjectDocument, type IControllerResourceDocument, type IControllerResourceAttachmentEntryDocument, type IControllerSessionState, type IControllerIntelligenceAdmission, type IControllerInterruptedIntelligenceRecovery, type IControllerSettingsDocument } from './interfaces.projects.js';
import type { TControllerModelChoice, IControllerSystemMetrics, IControllerSystemMetricsHistoryPoint, IControllerRuntimeId, IControllerSessionGroup, IControllerSessionLayout, TControllerResourceKind, TControllerTerminalAgentDesiredState, TControllerTerminalAgentLaunchMode, TControllerTerminalAgentFailure, TControllerSessionId, TControllerSessionHarnessId, TControllerConversationOrigin, TControllerScratchpadUpdater, TControllerProjectRemovalBlockedCode } from '../dist_ts_interfaces/index.js';
import { type IControllerLegacyManagedSessionMigrationResult } from '../dist_ts_migration/v26_legacymanagedsessionmigration.js';
import { type TControllerLegacyManagedSessionMigrationRunnerInput } from '../dist_ts_migration/classes.managedsessionmigrationrunner.js';
import type { IFlexDatabaseDescriptor } from './interfaces.flexipc.js';
export interface ISmartDataAuthStoreOptions {
    /** external server URL; absent = embedded smartdb engine */
    mongoDbUrl?: string;
    mongoDbName: string;
    /** storage directory for the embedded engine; required without mongoDbUrl */
    embeddedDataDirectory?: string;
    /** previous installed default that may be logically migrated */
    legacyEmbeddedDataDirectory?: string;
}
export declare const assertProvidedSetupCode: (setupCodeArg: string) => string;
type TFlexProjectManagementRecord = plugins.flexharness.TFlexProjectManagementRecord;
type TFlexProjectManagementSnapshot = plugins.flexharness.IFlexProjectManagementSnapshot;
type TFlexProjectManagementTombstone = plugins.flexharness.IFlexProjectManagementTombstone;
type TFlexProjectManagementWriteContext = plugins.flexharness.IFlexProjectManagementWriteContext;
type TFlexSessionGeneration = plugins.flexharness.IFlexSessionGeneration;
type TFlexProjectManagementSessionContext = plugins.flexharness.IFlexProjectManagementSessionContext;
export declare const assertControllerResourceCreationCapacity: (projectResourceCountArg: number, controllerResourceCountArg: number) => void;
export declare class SmartDataAuthStore implements IAuthStore, IAuthStoreSessionIdentityCapability {
    private readonly options;
    private database?;
    private embeddedDatabase?;
    private readonly smartDataManager;
    private initialized;
    private initPromise?;
    private initializationDataRoot?;
    private initializedDataRoot?;
    private issuerIdentity?;
    private sessionIdentityService?;
    private codexConnectionStore?;
    private readonly modelOwner;
    private releaseModelOwnership?;
    private controllerId?;
    private resolvedMongoDbUrl?;
    private closePromise?;
    private closeStarted;
    private projectMutationAdmissionOpen;
    private projectMutationTail;
    private sessionStateMutationTail;
    private auditPruneTimer?;
    private auditPrunePromise?;
    private runSessionStateMutation;
    constructor(options: ISmartDataAuthStoreOptions);
    private get db();
    init(): Promise<void>;
    initForController(dataRootDirectoryArg: string): Promise<IControllerIssuerIdentity>;
    recordSystemMetricsHistory(metricsArg: IControllerSystemMetrics): Promise<void>;
    listSystemMetricsHistory(): Promise<IControllerSystemMetricsHistoryPoint[]>;
    pruneSystemMetricsHistory(): Promise<void>;
    private initialize;
    private initOnce;
    private startAuditPrune;
    private pruneAuditHistory;
    private stopEmbeddedDatabase;
    private closeSessionIdentityService;
    private releaseModelOwnershipIfResourcesClosed;
    close(): Promise<void>;
    getRuntimeConfig(controllerPortArg: number): Promise<IControllerRuntimeConfig | undefined>;
    /** Process-private connection data for the isolated Flex child and projection reader. */
    getDatabaseDescriptor(): IFlexDatabaseDescriptor;
    resolveOrCreateRuntimeConfig(runtimeConfigArg: IControllerRuntimeConfig): Promise<IControllerAuthDocument>;
    private finalizeRuntimeConfigDocument;
    rotateSetupAuthority(providedCodeArg?: string): Promise<ISetupAuthority | null>;
    getState(): Promise<IControllerAuthDocument>;
    assertSetupAuthority(setupCodeArg: string, ceremonyArg?: IWebAuthnSetupCeremonyDocument, nowArg?: Date): Promise<IControllerAuthDocument>;
    countActiveCeremonies(kindArg: TWebAuthnCeremonyKind, nowArg: Date): Promise<number>;
    createCeremony(ceremonyArg: IWebAuthnCeremonyDocument): Promise<IWebAuthnCeremonyDocument>;
    consumeCeremony(optionsArg: IConsumeCeremonyOptions): Promise<IWebAuthnCeremonyDocument>;
    assertPendingCeremony(optionsArg: IConsumeCeremonyOptions): Promise<IWebAuthnCeremonyDocument>;
    private findPendingCeremony;
    commitFirstCredential(ceremonyArg: IWebAuthnSetupCeremonyDocument, credentialArg: IStoredPasskeyCredential): Promise<IControllerAuthDocument>;
    updateCounter(credentialIdArg: string, expectedCounterArg: number, newCounterArg: number): Promise<IStoredPasskeyCredential>;
    recordAuditEvent(eventArg: IRecordAuditEventInput): Promise<IControllerAuditEvent>;
    private assertInitialized;
    private requireSessionIdentityServiceForActiveProject;
    private requireSessionIdentityServiceForPendingProjectRemoval;
    private withActiveProjectSessionIdentityMutation;
    private withPendingProjectRemovalSessionIdentityMutation;
    admitManagedSession(inputArg: IAdmitControllerManagedSessionInput): Promise<IControllerSessionManagedObservation>;
    requireCodexConnections(): ControllerCodexConnectionStore;
    listCodexMemberships(projectIdArg: string, signalArg?: AbortSignal): ReturnType<ControllerSessionIdentityService['listCodexMemberships']>;
    listCodexMembershipsForProjectRemoval(projectIdArg: string, signalArg?: AbortSignal): ReturnType<ControllerSessionIdentityService['listCodexMemberships']>;
    getCodexOrigin(projectIdArg: string, nativeIdArg: string, signalArg?: AbortSignal): ReturnType<ControllerSessionIdentityService['codexOrigin']>;
    beginCodexCreation(inputArg: IBeginCodexCreationInput): Promise<IControllerCodexCreationDocument>;
    observeManagedCodexSession(inputArg: Parameters<ControllerSessionIdentityService['observeManagedCodexSession']>[0]): ReturnType<ControllerSessionIdentityService['observeManagedCodexSession']>;
    getCodexCreation(scopeArg: ICodexCreationScope): Promise<IControllerCodexCreationDocument>;
    listCodexCreations(projectIdArg: string, signalArg?: AbortSignal): Promise<IControllerCodexCreationDocument[]>;
    listCodexCreationsForProjectRemoval(projectIdArg: string, signalArg?: AbortSignal): Promise<IControllerCodexCreationDocument[]>;
    admitCodexCreationForProjectRemoval(scopeArg: ICodexCreationScope, generationArg: string): Promise<IControllerSessionManagedObservation>;
    retireCodexCreationForProjectRemoval(scopeArg: ICodexCreationScope, assertRuntimeTerminatedArg: (runtimeArg: ICodexCreationRuntime) => Promise<void>): Promise<void>;
    dispatchCodexCreation(scopeArg: ICodexCreationScope, runtimeArg: ICodexCreationRuntime): Promise<IControllerCodexCreationDocument>;
    bindCodexCreation(scopeArg: ICodexCreationScope, generationArg: string, nativeIdArg: string, createdAtArg: number): Promise<IControllerCodexCreationDocument>;
    admitCodexCreation(scopeArg: ICodexCreationScope, generationArg: string): Promise<IControllerSessionManagedObservation>;
    findUnmaterializedCodexCreation(projectIdArg: string, nativeIdArg: string): Promise<IControllerCodexCreationDocument | undefined>;
    finalizeCodexCreationMetadata(scopeArg: ICodexCreationScope): Promise<IControllerCodexCreationDocument>;
    prepareCodexTurn(projectIdArg: string, nativeIdArg: string): Promise<void>;
    cancelUndispatchedCodexTurn(projectIdArg: string, nativeIdArg: string): Promise<void>;
    markCodexMaterialized(projectIdArg: string, nativeIdArg: string): Promise<void>;
    completeCodexCreationDeletion(projectIdArg: string, nativeIdArg: string, projectRemovalArg?: boolean): Promise<void>;
    retireCodexCreation(scopeArg: ICodexCreationScope, assertRuntimeTerminatedArg: (runtimeArg: ICodexCreationRuntime) => Promise<void>): Promise<void>;
    migrateLegacyManagedSessions(inputArg: TControllerLegacyManagedSessionMigrationRunnerInput): Promise<IControllerLegacyManagedSessionMigrationResult>;
    requireManagedSession(inputArg: IRequireControllerManagedSessionInput): Promise<IControllerSessionManagedObservation>;
    resolveManagedSession(inputArg: IRequireControllerManagedSessionInput): Promise<IControllerSessionManagedObservation | undefined>;
    resolveSessionLayoutAuthority(inputArg: IResolveControllerSessionLayoutAuthorityInput): Promise<TControllerSessionLayoutAuthority>;
    pruneDefinitivelyUnmanagedSessionLayoutEntries(projectIdentityIdArg: string, sessionIdsArg: readonly IControllerRuntimeId[], signalArg?: AbortSignal): Promise<{
        changed: boolean;
        sessionIds: IControllerRuntimeId[];
    }>;
    resolveRetiredManagedSessionIdentity(inputArg: IResolveRetiredManagedSessionIdentityInput): Promise<boolean>;
    resolveFlexHostSessionAuthority(inputArg: IResolveControllerFlexHostSessionAuthorityInput): Promise<TControllerFlexHostSessionAuthority>;
    resolvePendingFlexProjectManagementLoadAuthority(inputArg: IResolveControllerPendingFlexProjectManagementLoadAuthorityInput): Promise<TControllerPendingFlexProjectManagementLoadAuthority>;
    resolveFlexProjectManagementRegistrationLoadAuthority(inputArg: IResolveControllerFlexProjectManagementRegistrationLoadAuthorityInput): Promise<TControllerFlexProjectManagementRegistrationLoadAuthority>;
    beginManagedSessionDeletion(inputArg: IBeginControllerManagedSessionDeletionInput): Promise<IControllerManagedSessionDeletionObligation>;
    markManagedSessionDeletionDispatched(inputArg: IMarkControllerManagedSessionDeletionDispatchedInput): Promise<IControllerManagedSessionDeletionObligation>;
    cancelManagedSessionDeletion(inputArg: ICancelControllerManagedSessionDeletionInput): Promise<IControllerSessionManagedObservation>;
    completeManagedSessionDeletion(inputArg: ICompleteControllerManagedSessionDeletionInput): Promise<void>;
    listManagedSessionDeletionObligations(inputArg: IListControllerManagedSessionDeletionObligationsInput): Promise<IControllerManagedSessionDeletionObligation[]>;
    listFlexManagedCleanupRoots(inputArg: IListControllerFlexManagedCleanupRootsInput): Promise<IControllerFlexCleanupEntry[]>;
    retireProjectManagedSessions(inputArg: IRetireControllerProjectManagedSessionsInput): Promise<IControllerManagedSessionDeletionObligation[]>;
    beginManagedSessionCreation(inputArg: IBeginControllerManagedSessionCreationInput): Promise<IControllerSessionCreationObligation>;
    markManagedSessionCreationDispatched(inputArg: IMarkControllerManagedSessionCreationDispatchedInput): Promise<IControllerSessionCreationObligation>;
    completeManagedSessionCreationAdmission(inputArg: ICompleteControllerManagedSessionCreationAdmissionInput): Promise<IControllerSessionManagedObservation>;
    retireManagedSessionCreation(inputArg: IRetireControllerManagedSessionCreationInput): Promise<IControllerSessionCreationObligation>;
    listPendingSessionCreationObligations(inputArg: IListControllerSessionCreationObligationsInput): Promise<IControllerSessionCreationObligation[]>;
    getSessionCreationObligation(inputArg: IGetControllerSessionCreationObligationInput): Promise<IControllerSessionCreationObligation | undefined>;
    /** Internal recovery path: normal callers must use the active-project wrapper. */
    listManagedSessionDeletionObligationsForProjectRemoval(inputArg: IListControllerManagedSessionDeletionObligationsInput): Promise<IControllerManagedSessionDeletionObligation[]>;
    /** Internal recovery path: normal callers must use the active-project wrapper. */
    markManagedSessionDeletionDispatchedForProjectRemoval(inputArg: IMarkControllerManagedSessionDeletionDispatchedInput): Promise<IControllerManagedSessionDeletionObligation>;
    /** Internal recovery path: normal callers must use the active-project wrapper. */
    completeManagedSessionDeletionForProjectRemoval(inputArg: ICompleteControllerManagedSessionDeletionInput): Promise<void>;
    /** Internal recovery path: normal callers must use the active-project wrapper. */
    retireProjectManagedSessionsForProjectRemoval(inputArg: IRetireControllerProjectManagedSessionsInput): Promise<IControllerManagedSessionDeletionObligation[]>;
    /** Internal recovery path: normal callers must use the active-project wrapper. */
    listPendingSessionCreationObligationsForProjectRemoval(inputArg: IListControllerSessionCreationObligationsInput): Promise<IControllerSessionCreationObligation[]>;
    /** Internal recovery path: caller must prove the provider session exists. */
    completeManagedSessionCreationAdmissionForProjectRemoval(inputArg: ICompleteControllerManagedSessionCreationAdmissionInput): Promise<IControllerSessionManagedObservation>;
    /** Internal recovery path: caller must first prove the provider session absent. */
    retireManagedSessionCreationForProjectRemoval(inputArg: IRetireControllerManagedSessionCreationInput): Promise<IControllerSessionCreationObligation>;
    [authStoreSessionIdentityCapability](inputArg: Parameters<IAuthStoreSessionIdentityCapability[typeof authStoreSessionIdentityCapability]>[0]): ReturnType<IAuthStoreSessionIdentityCapability[typeof authStoreSessionIdentityCapability]>;
    private findStoredState;
    private requireControllerId;
    listProjects(): Promise<IControllerProjectDocument[]>;
    createProject(nameArg: string, directoryArg: string, identityArg: IControllerProjectFilesystemIdentity): Promise<{
        project: IControllerProjectDocument;
        created: boolean;
    }>;
    removeProject(projectIdArg: string, operationIdArg: string): Promise<boolean>;
    beginProjectRemoval(projectIdArg: string, operationIdArg: string, flexCleanupCohortArg: readonly IControllerFlexCleanupEntry[]): Promise<IControllerProjectDocument | undefined>;
    /**
     * Records why a pending removal stopped being retried. Only the removal operation that owns the
     * project may block it, so a stale attempt can never label a removal it no longer drives.
     */
    blockProjectRemoval(projectIdArg: string, operationIdArg: string, codeArg: TControllerProjectRemovalBlockedCode, reasonArg: string): Promise<boolean>;
    /**
     * Clears a recorded removal block so the pending removal can be attempted again. The removal
     * itself is never discarded; the returned document is the still-pending project.
     */
    clearProjectRemovalBlock(projectIdArg: string): Promise<IControllerProjectDocument | undefined>;
    listPendingProjectRemovals(): Promise<IControllerProjectDocument[]>;
    private withProjectMutation;
    private insertResourceDocument;
    private transitionResourceDocument;
    getProject(projectIdArg: string): Promise<IControllerProjectDocument | undefined>;
    getPendingProjectRemoval(projectIdArg: string): Promise<IControllerProjectDocument | undefined>;
    listResources(projectIdArg: string, optionsArg?: {
        includeRetired?: boolean;
        signal?: AbortSignal;
    }): Promise<IControllerResourceDocument[]>;
    listRecoverableResources(): Promise<IControllerResourceDocument[]>;
    getResource(projectIdArg: string, resourceIdArg: string, optionsArg?: {
        includeRetired?: boolean;
    }): Promise<IControllerResourceDocument | undefined>;
    createResource(inputArg: {
        projectId: string;
        kind: TControllerResourceKind;
        title: string;
        terminal?: IControllerResourceDocument['terminal'];
    }): Promise<IControllerResourceDocument>;
    renameResource(projectIdArg: string, resourceIdArg: string, titleArg: string): Promise<IControllerResourceDocument>;
    /**
     * Opens the single in-flight attachment obligation. `add` installs an entry (idempotent when
     * the same entry is already present), `remove` takes one out or clears the set when no entry is
     * named, and `replace` does both atomically for a Move.
     */
    beginResourceAttachmentTransition(projectIdArg: string, resourceIdArg: string, intentArg: {
        op: 'add' | 'remove' | 'replace';
        entry?: IControllerResourceAttachmentEntryDocument;
        replaces?: IControllerResourceAttachmentEntryDocument;
    }, expectedAttachmentRevisionArg: number): Promise<IControllerResourceDocument>;
    commitResourceAttachmentTransition(projectIdArg: string, resourceIdArg: string, operationIdArg: string): Promise<IControllerResourceDocument>;
    cancelResourceAttachmentTransition(projectIdArg: string, resourceIdArg: string, operationIdArg: string): Promise<IControllerResourceDocument>;
    beginResourceRetirement(projectIdArg: string, resourceIdArg: string): Promise<IControllerResourceDocument>;
    completeResourceRetirement(projectIdArg: string, resourceIdArg: string): Promise<IControllerResourceDocument>;
    markTerminalResourceStopped(projectIdArg: string, resourceIdArg: string, outcomeArg?: {
        stoppedAt?: Date;
        lastExitCode?: number;
        /**
         * Absent preserves the recorded intent, which is the controller-shutdown case: the chat was
         * closed underneath the user and must come back on the next start.
         */
        desiredState?: TControllerTerminalAgentDesiredState;
        failure?: {
            code: TControllerTerminalAgentFailure;
            message: string;
        };
    }): Promise<IControllerResourceDocument>;
    markTerminalResourceRunning(projectIdArg: string, resourceIdArg: string, outcomeArg?: {
        launchMode?: TControllerTerminalAgentLaunchMode;
    }): Promise<IControllerResourceDocument>;
    getSettings(): Promise<IControllerSettingsDocument>;
    updateSettings(patchArg: {
        defaultModels?: TControllerModelChoice[];
        autoAcceptPermissions?: boolean;
        browserVideoBackend?: 'chromium' | 'native';
        selectedOpenCodeProviderConnectionId?: string | null;
        /** Full replacement; an empty list clears the key. */
        standardProjectDirectories?: string[];
        lastSessionHarnessId?: TControllerSessionHarnessId;
    }): Promise<IControllerSettingsDocument>;
    private trackedConversationDocumentId;
    /**
     * Every conversation AGL tracks, newest first per page scan. Pass project IDs to scope the
     * read; the complete set is bounded so one cross-project sidebar read can never be unbounded.
     */
    listTrackedConversations(projectIdsArg?: readonly string[], signalArg?: AbortSignal): Promise<IControllerTrackedConversationDocument[]>;
    getTrackedConversation(projectIdArg: string, runtimeIdArg: TControllerSessionId): Promise<IControllerTrackedConversationDocument | undefined>;
    /**
     * Idempotent. An explicit `opened` intent also returns an AGL-archived conversation to the
     * active list, because opening it again is exactly the user asking for it back.
     */
    trackConversation(inputArg: {
        projectId: string;
        runtimeId: TControllerSessionId;
        sessionIdentityId: string;
        origin: TControllerConversationOrigin;
        title?: string;
    }): Promise<IControllerTrackedConversationDocument>;
    /** AGL-level archive state only. The harness conversation is never touched here. */
    setTrackedConversationArchived(projectIdArg: string, runtimeIdArg: TControllerSessionId, archivedArg: boolean): Promise<IControllerTrackedConversationDocument>;
    /** Cache the newest observed title so the archive view needs no harness read. */
    cacheTrackedConversationTitle(projectIdArg: string, runtimeIdArg: TControllerSessionId, titleArg: string): Promise<void>;
    untrackConversation(projectIdArg: string, runtimeIdArg: TControllerSessionId): Promise<boolean>;
    /** Project removal takes its tracked conversations with it. */
    untrackProjectConversations(projectIdArg: string): Promise<number>;
    getSessionLayout(): Promise<IControllerSessionLayout>;
    updateSessionLayout(groupsArg: IControllerSessionGroup[], ungroupedItemIdsArg?: IControllerSessionGroup['itemIds'], expectedRevisionArg?: number): Promise<IControllerSessionLayout>;
    removeSessionFromLayout(projectIdArg: string, sessionIdArg: IControllerRuntimeId): Promise<boolean>;
    /** A retired resource must not leave a dangling layout member behind. */
    removeResourceFromLayout(projectIdArg: string, resourceIdArg: string): Promise<boolean>;
    /** A deregistered project must not leave its conversations and resources in the layout. */
    removeProjectFromLayout(projectIdArg: string): Promise<boolean>;
    pruneArchivedSessionLayoutEntries(projectIdArg: string, archivedSessionIdsArg: readonly IControllerRuntimeId[]): Promise<boolean>;
    private filterSessionLayout;
    private sessionStateIdentity;
    private createEmptySessionStateDocument;
    private findStoredSessionState;
    private insertSessionState;
    private transitionSessionState;
    getSessionState(projectIdArg: string, sessionIdArg: IControllerRuntimeId): Promise<IControllerSessionState>;
    readFlexProjectTasks(projectIdArg: string, sessionIdArg: string, sessionGenerationArg: Readonly<TFlexSessionGeneration>): Promise<plugins.flexharness.IFlexProjectTask[]>;
    loadFlexProjectManagement(projectIdArg: string, sessionIdArg: string, sessionGenerationArg: Readonly<TFlexProjectManagementSessionContext>): Promise<TFlexProjectManagementRecord | undefined>;
    saveFlexProjectManagement(projectIdArg: string, sessionIdArg: string, snapshotArg: TFlexProjectManagementSnapshot, expectedRevisionArg: number, writeContextArg: TFlexProjectManagementWriteContext): Promise<void>;
    tombstoneFlexProjectManagement(projectIdArg: string, sessionIdArg: string, tombstoneArg: TFlexProjectManagementTombstone, expectedRevisionArg: number, sessionContextArg: Readonly<TFlexProjectManagementSessionContext>): Promise<void>;
    purgeFlexProjectManagementNamespace(projectIdArg: string): Promise<void>;
    setSessionModelChoice(projectIdArg: string, sessionIdArg: IControllerRuntimeId, modelChoiceArg: TControllerModelChoice, providerConnectionIdArg?: string): Promise<IControllerSessionState>;
    private clearStoredSessionProviderConnection;
    clearSessionProviderConnectionsForConnection(providerConnectionIdArg: string, signalArg?: AbortSignal): Promise<number>;
    saveSessionScratchpad(projectIdArg: string, sessionIdArg: IControllerRuntimeId, textArg: string, expectedRevisionArg: number, updatedByArg?: TControllerScratchpadUpdater): Promise<IControllerSessionState>;
    private saveSessionScratchpadUnqueued;
    admitSessionIntelligence(projectIdArg: string, sessionIdArg: IControllerRuntimeId, questionArg: string): Promise<IControllerIntelligenceAdmission>;
    private admitSessionIntelligenceUnqueued;
    attachSessionIntelligenceTemporarySession(projectIdArg: string, sessionIdArg: IControllerRuntimeId, exchangeIdArg: string, temporarySessionIdArg: string): Promise<void>;
    private attachSessionIntelligenceTemporarySessionUnqueued;
    completeSessionIntelligence(projectIdArg: string, sessionIdArg: IControllerRuntimeId, exchangeIdArg: string, answerArg: string, scratchpadTextArg: string, modelArg: string): Promise<IControllerSessionState | undefined>;
    private completeSessionIntelligenceUnqueued;
    failSessionIntelligence(projectIdArg: string, sessionIdArg: IControllerRuntimeId, exchangeIdArg: string, errorArg: string, modelArg?: string): Promise<IControllerSessionState | undefined>;
    private failSessionIntelligenceUnqueued;
    recoverInterruptedSessionIntelligence(): Promise<IControllerInterruptedIntelligenceRecovery>;
    private recoverInterruptedSessionIntelligenceUnqueued;
    listProjectSessionIntelligenceCleanupObligations(projectIdArg: string): Promise<IControllerInterruptedIntelligenceRecovery['temporarySessionIds']>;
    getSessionIntelligenceCleanupObligations(projectIdArg: string, sessionIdArg: IControllerRuntimeId): Promise<IControllerInterruptedIntelligenceRecovery['temporarySessionIds']>;
    findProjectSessionIntelligenceTemporarySessionIds(projectIdArg: string, candidateIdsArg: string[], signalArg?: AbortSignal): Promise<Set<string>>;
    isSessionStateTombstoned(projectIdArg: string, sessionIdArg: IControllerRuntimeId): Promise<boolean>;
    retireProjectSessionStates(projectIdArg: string, cleanupTemporarySessionArg: (temporarySessionIdArg: string) => Promise<void>, signalArg?: AbortSignal): Promise<{
        retiredCount: number;
        temporarySessionIds: string[];
    }>;
    clearSessionIntelligenceTemporarySession(projectIdArg: string, sessionIdArg: IControllerRuntimeId, exchangeIdArg: string, temporarySessionIdArg: string): Promise<void>;
    private clearSessionIntelligenceTemporarySessionUnqueued;
    tombstoneSessionState(projectIdArg: string, sessionIdArg: IControllerRuntimeId): Promise<void>;
    private tombstoneSessionStateUnqueued;
    private applyFlexProjectManagementScratchpad;
    private applySessionStateTombstone;
    createTempPassword(ttlMsArg: number): Promise<IMintedTempPassword>;
    verifyTempPassword(passwordArg: string): Promise<{
        credentialId: string;
        expiresAt: Date;
    } | undefined>;
    private assertRuntimeConfigMatches;
    private auditEventsEqual;
}
export {};