import type { IControllerProjectFilesystemIdentity } from './interfaces.projects.js';
import type { IGitReversionApplyRequest, IGitReversionCaptureRequest, IGitReversionMetadata, IGitReversionMetadataRequest, IGitReversionOptions, IGitReversionReleaseRequest, IGitReversionWorktreeDescriptor, IGitReversionWorktreeRemoveRequest, IGitReversionWorktreeRequest, TGitReversionApplyInspection, TGitReversionCaptureInspection, TGitReversionFinalizedOutcome } from './interfaces.gitreversion.js';
export type TGitReversionDiscoveryLimitName = 'maximumRepositories' | 'maximumScannedDirectories';
export declare const ensureGitReversionParentDirectory: (dataRootArg: string) => Promise<string>;
export declare class GitReversionConflictError extends Error {
    constructor(messageArg?: string, optionsArg?: ErrorOptions);
}
export declare class GitReversionFencedError extends Error {
    constructor(messageArg?: string, optionsArg?: ErrorOptions);
}
export declare class GitReversionRecoveryRequiredError extends Error {
    constructor(messageArg?: string, optionsArg?: ErrorOptions);
}
export declare class GitReversionDirtyWorktreeError extends Error {
    constructor(messageArg?: string);
}
export declare class GitReversionDiscoveryLimitError extends Error {
    readonly limit: TGitReversionDiscoveryLimitName;
    constructor(limit: TGitReversionDiscoveryLimitName);
}
export declare class ControllerGitReversion {
    readonly protocolVersion: 2;
    private readonly ownerId;
    private readonly ownerKey;
    private readonly rootDirectory;
    private readonly limits;
    private readonly maximumPrivateTreeEntries;
    private readonly faultInjector?;
    private readonly projects;
    private readonly ownershipByCommonId;
    private readonly ownershipWaiters;
    private readonly ownershipWaitersByCommonId;
    private readonly lockTails;
    private readonly projectCatalogTails;
    private readonly activeProjectCatalogOperations;
    private readonly activeLockCohorts;
    private readonly activeGitCommands;
    private readonly unconfirmedGitChildren;
    private readonly retainedGitProcessGroups;
    private readonly gitCommandWaiters;
    private readonly validatedRefNames;
    private activeGitCommandPermits;
    private readonly captureRecordBytes;
    private captureAggregateBytes;
    private captureMutationTail;
    private readonly activeCaptureMutations;
    private readonly privateIntentBytes;
    private privateIntentAggregateBytes;
    private readonly privateRefCharges;
    private privateRefAggregateBytes;
    private readonly metadataWriteReservations;
    private readonly lifecycleRecordBytes;
    private lifecycleAggregateBytes;
    private readonly storeReservations;
    private readonly pendingGenerationCleanups;
    private readonly pendingTemporaryIndexCleanups;
    private maintenanceCleanupPromise?;
    private readonly pendingWorktreeRemovalProjectIds;
    private readonly activeWorktreeRemovalRecoveryProjectIds;
    private worktreeRemovalRecoveryTimer?;
    private worktreeRemovalRecoveryTask?;
    private metadataQuotaLoaded;
    private metadataMutationTail;
    private readonly activeMetadataMutations;
    private readonly recoveredProjects;
    private readonly projectRecoveryPromises;
    private initializationPromise?;
    private recoveryPromise?;
    private recoverySucceeded;
    private activeOperations;
    private readonly operationDrainWaiters;
    private readonly lifecycleAbortController;
    private initialized;
    private sealed;
    private sealError?;
    private closed;
    private closePromise?;
    private readonly onSealedForCleanup?;
    constructor(optionsArg: IGitReversionOptions);
    /**
     * True once the engine sealed itself for incomplete Git process cleanup or
     * closed. Such an engine rejects every operation; its owner must close it
     * and construct a replacement.
     */
    get requiresReplacement(): boolean;
    init(signalArg?: AbortSignal): Promise<void>;
    registerProject(projectIdArg: string, directoryArg: string, identityArg: IControllerProjectFilesystemIdentity): void;
    unregisterProject(projectIdArg: string): void;
    recover(signalArg?: AbortSignal): Promise<void>;
    close(): Promise<void>;
    prepare(requestArg: IGitReversionCaptureRequest): Promise<void>;
    inspectCapture(requestArg: IGitReversionCaptureRequest): Promise<TGitReversionCaptureInspection>;
    finalize(requestArg: IGitReversionCaptureRequest): Promise<TGitReversionFinalizedOutcome>;
    inspectApply(requestArg: IGitReversionApplyRequest): Promise<TGitReversionApplyInspection>;
    apply(requestArg: IGitReversionApplyRequest): Promise<void>;
    release(requestArg: IGitReversionReleaseRequest): Promise<void>;
    private deleteFinalizedCapture;
    releaseProjectCaptures(projectIdArg: string, signalArg?: AbortSignal): Promise<void>;
    cleanupProjectWorktrees(projectIdArg: string, signalArg?: AbortSignal): Promise<void>;
    listAffected(requestArg: IGitReversionMetadataRequest): Promise<Array<{
        id: string;
        label: string;
    }>>;
    getReversionMetadata(requestArg: IGitReversionMetadataRequest): Promise<IGitReversionMetadata>;
    createDetachedSessionWorktree(requestArg: IGitReversionWorktreeRequest): Promise<IGitReversionWorktreeDescriptor>;
    listDetachedSessionWorktrees(requestArg: IGitReversionWorktreeRequest): Promise<IGitReversionWorktreeDescriptor[]>;
    removeDetachedSessionWorktree(requestArg: IGitReversionWorktreeRemoveRequest): Promise<void>;
    compensateDetachedSessionWorktreeCreation(requestArg: IGitReversionWorktreeRemoveRequest): Promise<void>;
    private withPublicOperation;
    private waitForOperationsToDrain;
    private projectRecoveryKey;
    private invalidateRecovery;
    private sealForGitProcessCleanup;
    private retryPendingMaintenanceCleanups;
    private hasRemovingWorktreeRecord;
    private queueWorktreeRemovalRecovery;
    private scheduleWorktreeRemovalRecovery;
    private retryPendingWorktreeRemovalRecoveries;
    private releaseStrandedMetadataReservations;
    private ensureInitialized;
    private cleanupUnenrolledGenerationResidue;
    private ensureNonSourceOperationReady;
    private assertNoPendingSourceRecovery;
    private readCaptureSnapshot;
    private readFinalizedCaptureSnapshot;
    private ensureRecovery;
    private recoverRegisteredProject;
    private inspectProjectDurableRecoveryState;
    private assertProjectCaptureLifecycleState;
    private validateLimits;
    private assertUsable;
    private assertMaintenanceUsable;
    private requireProject;
    private captureKey;
    private copyIdentity;
    private captureIsDefinitivelyNew;
    private assertApplyRequest;
    private assertManifestIdentity;
    private assertManifest;
    private assertDiscoveryLimitCapture;
    private assertDiscoveryLimitCaptureRecord;
    private assertRepositoryIdentity;
    private assertFilesystemIdentity;
    private assertRepositoryBinding;
    private assertSide;
    private refNameHasSafeBytes;
    private assertGitRefName;
    private parseDirectRefOid;
    private assertPrivateDirectRefName;
    private fault;
    private indexRoot;
    private worktreeRoot;
    private worktreeRecordRoot;
    private worktreeRecordPathForRef;
    private isWorktreeRecordTemporaryName;
    private projectCatalogRoot;
    private captureRecordRoot;
    private lifecycleRoot;
    private captureRoot;
    private captureStoresRoot;
    private captureStoreRoot;
    private captureGitDirectory;
    private generationRoot;
    private generationDirectory;
    private lifecyclePath;
    private privateIntentRoot;
    private privateIntentPath;
    private countDirectoryEntries;
    private syncDirectory;
    private writeFileHandleChunk;
    private syncRegularFile;
    private readBoundedRegularFile;
    private assertPrivateIntent;
    private cleanupPrivateIntentTemporaryFiles;
    private listPrivateIntents;
    private listPrivateIntentsUnlocked;
    private readPrivateIntent;
    private writePrivateIntent;
    private removePrivateIntent;
    private assertLifecycleRecord;
    private listLifecycleRecords;
    private listLifecycleRecordsUnlocked;
    private cleanupLifecycleTemporaryFiles;
    private loadLifecycleQuota;
    private writeLifecycleRecord;
    private writeLifecycleRecordUnlocked;
    private removeLifecycleRecord;
    private removeLifecycleRecordUnlocked;
    private lifecycleRecord;
    private captureLifecycleClaim;
    private hasCaptureLifecycleClaim;
    private claimCaptureLifecycle;
    private releaseCaptureLifecycleClaim;
    private beginCaptureCreation;
    private publishCaptureLifecycle;
    private publishFinalizedCaptureRecord;
    private assertPrivatePathAncestry;
    private assertPrivateTreeNode;
    private walkPrivateTree;
    private inspectPrivateTree;
    private chmodPrivateNode;
    private removePrivateTree;
    private removePrivateIntentsForCaptures;
    private readLifecycleRecord;
    private requireFinalizedCaptureLifecycle;
    private claimLifecycleRecordForRecovery;
    private deleteCaptureRootWithLifecycle;
    private assertPrivateCaptureTree;
    private reconcileActiveFinalizedCaptureLifecycle;
    private recoverCaptureLifecycles;
    private captureRecordPath;
    private projectCatalogPath;
    private assertDurableCaptureRecord;
    private assertInitialFinalizedCaptureRecord;
    private readDurableCaptureRecord;
    private listDurableCaptureRecords;
    private loadCaptureRecordQuota;
    private cleanupCaptureRecordTemporaryFiles;
    private withCaptureMutation;
    private syncCaptureRecordRoot;
    private writeDurableCaptureRecord;
    private deleteDurableCaptureRecord;
    private ensurePrivateDirectory;
    private assertPrivateDirectory;
    private rememberProjectRepositories;
    private readProjectRepositoryCatalog;
    private writeProjectRepositoryCatalog;
    private deleteProjectRepositoryCatalog;
    private withProjectCatalogLock;
    private cleanupProjectCatalogTemporaryFiles;
    private cleanupOwnedTemporaryIndexDirectory;
    private cleanupRepositoryTemporaryIndexes;
    private discoverProjectRepositories;
    private tryRepositoryRoot;
    private assertGitEntryTargetsGitDirectory;
    private describeRepository;
    private parseWorktreeRegistrations;
    private worktreeTopologyHash;
    private pathspec;
    private estimateGenerationReservation;
    private readPackIndexObjectCount;
    private scanObjectDirectory;
    private generationReservationKey;
    private activeGenerationReservationKeys;
    private scanCaptureStoreUsage;
    private scanControllerStoreUsage;
    private assertStoreReservationsWithinQuota;
    private reserveStoreCapacity;
    private resizeStoreReservation;
    private reconcileStoreReservation;
    private releaseStoreReservation;
    private createGeneration;
    private closureRoots;
    private packIndexMaximumBytes;
    private growGenerationReservation;
    private removeGenerationLooseObjects;
    private writeReachablePack;
    private verifyReachableClosure;
    private materializeGenerationClosure;
    private verifyGeneration;
    private removeGeneration;
    private performGenerationCleanup;
    private generationContext;
    private enrollGenerationIds;
    private deleteGenerationIds;
    private scavengeUnenrolledGenerations;
    private captureStableRepositories;
    private captureSide;
    private checkIndexSupport;
    private checkPathSupport;
    private assertPathOutputBound;
    private captureOperationState;
    private captureIgnorePolicy;
    private fallbackTrees;
    private assertTemporaryIndexBound;
    private captureTrees;
    private parseRefs;
    private sidesEqual;
    private semanticSidesEqual;
    private captureRepositoryReason;
    private createPreparedRecords;
    private finalizeRecords;
    private createFinalizationIntent;
    private assertFinalizationIntent;
    private validateFinalizationRecords;
    private publishFinalization;
    private recoverFinalizations;
    private recoverFinalization;
    private scanFinalizationRecords;
    private assertUniqueFinalizationIntent;
    private finalizationPublicationComplete;
    private validatePublishedFinalization;
    private fenceFinalization;
    private findManifest;
    private loadFinalizedCapture;
    private assertFreshRepositoryBindings;
    private recoverPendingApplyWals;
    private fenceDiscoveredApplyWals;
    private createState;
    private replaceState;
    private loadState;
    private createApplyPlans;
    private createApplySyntheticRoot;
    private assertApplyPreconditions;
    private verifyCapturedObjects;
    private mergeTrees;
    private preflightPlan;
    private assertNoIgnoredCollision;
    private verifyPlansUnchanged;
    private applyPlan;
    private materializePlanObjectsInSource;
    private assertSourceKeep;
    private removeSourceKeeps;
    private sourceKeepQuarantinePath;
    private reconcileSourceKeepQuarantine;
    private removeSourceKeep;
    private removeSourceKeepOwned;
    private transitionWorktree;
    private installIndex;
    private applyRefs;
    private verifyTargetPlans;
    private sideMatchesTarget;
    private writeInitialWal;
    private updateWal;
    private loadLatestApplyWal;
    private assertWal;
    private listLatestApplyWals;
    private inspectApplyOperations;
    private canonicalizeWalAttempt;
    private persistRecoveryWal;
    private assertCaptureState;
    private reconcileStateForWal;
    private recoverWal;
    private compensate;
    private rollForward;
    private sideIsOperationCombination;
    private treeIsCombination;
    private treeEntries;
    private fenceWal;
    private selectContainingRepository;
    private assertProjectDirectory;
    private worktreeDescriptor;
    private listWorktreeRecords;
    private assertWorktreeRecord;
    private assertWorktreeParentBinding;
    private assertWorktreePathBinding;
    private requireOwnedWorktreeRegistration;
    private assertOwnedWorktreeDiscoveryRegistration;
    private restoreOwnedWorktreeLock;
    private addWorktreeCaptureParticipant;
    private removeWorktreeRecord;
    private recoverWorktrees;
    private worktreeLockReason;
    private listManifestCopies;
    private metadataRepositories;
    private repositoryBindingsEqual;
    private acquireOwnership;
    private releaseOwnership;
    private grantOwnership;
    private removeOwnershipWaiter;
    private drainOwnershipWaiters;
    private withLocks;
    private privateRefChargeKey;
    private captureKeyFromPrivateRef;
    private hardenPrivateTree;
    private assertPrivateDirectoryNode;
    private listGenerationObjectDirectories;
    private privateStoreConfig;
    private privateDirectoryEntries;
    private forEachPrivateDirectoryEntry;
    private assertPrivateObjectDirectory;
    private assertPrivateRefsDirectory;
    private assertPrivateGitStore;
    private assertPrivateGitStoreByFormat;
    private ensurePrivateStore;
    private privateGit;
    private captureReadEnvironment;
    private withMetadataMutation;
    private setPrivateRefCharge;
    private reserveMetadataWrite;
    private releaseMetadataWrite;
    private reconcileMetadataStoreReservation;
    private consumeMetadataWriteReservation;
    private prunePrivateMetadataStore;
    private rebuildPrivateRefQuota;
    private pinsForRecord;
    private buildRecord;
    private buildPublicationEntry;
    private cleanupPublicationEntries;
    private createPublicationIntent;
    private executePublicationIntent;
    private chargeForOid;
    private recoverPublicationIntent;
    private recoverPublicationIntentUnlocked;
    private recoverDeletionIntent;
    private recoverDeletionIntentUnlocked;
    private executeDeletionIntent;
    private releaseRepositoryCapture;
    private recoverPrivateIntents;
    private readWorktreeRecordByRef;
    private cleanupWorktreeRecordTemporaryFiles;
    private writeWorktreeRecord;
    private listWorktreeRecordRefs;
    private writeRecord;
    private replaceRecord;
    private putRecord;
    private readRecord;
    private readNulTerminatedBatchField;
    private readExactBatchBytes;
    private readBatchRecordsAt;
    private readRecordAt;
    private resolveRef;
    private listDirectRefs;
    private listRefs;
    private deleteExactRef;
    private deleteExpectedRef;
    private captureRefRoot;
    private manifestRef;
    private captureWalRef;
    private captureStateRef;
    private capturePinsRef;
    private finalizationCandidateRef;
    private finalizationIntentRef;
    private finalizationFenceRef;
    private captureSideRef;
    private repositoryIdentityRef;
    private applyLatestRef;
    private applyAttemptRef;
    private applyDecisionRef;
    private applyFenceRef;
    private worktreeRef;
    private worktreeRefRoot;
    private temporaryIndexPath;
    private removeTemporaryIndexPaths;
    private canonicalCommitEnvironment;
    private acquireGitCommandPermit;
    private git;
    private runGit;
    /**
     * Waits a bounded time for a SIGKILLed Git child to confirm close, then
     * judges liveness. Pending exit and close events are given a chance to run
     * first because a busy event loop delivers expired timers before the child's
     * I/O callbacks. Only a child that is still alive after SIGKILL is a cleanup
     * failure that must seal the engine.
     */
    private confirmTerminatedGitChildClose;
    private reapGitProcessGroup;
    private reapRetainedGitProcessGroups;
}
export declare class ControllerGitReversionManager extends ControllerGitReversion {
}