import { type ControlJournalExportReceipt, type ControlJournalInspection, type ControlJournalQuarantineReceipt, type ControlJournalValidation } from "@claudexor/schema";
import { type JournalQuarantineRequest } from "./journal-recovery-operation.js";
import type { JournalProjectionDescriptor, JournalProjectionSlot } from "./journal-projection.js";
import type { JournalManagerOptions } from "./journal-manager-lifecycle.js";
export type { JournalProjectionDescriptor, JournalProjectionSlot } from "./journal-projection.js";
export type { JournalManagerOptions } from "./journal-manager-lifecycle.js";
export type { JournalQuarantineRequest } from "./journal-recovery-operation.js";
export interface JournalManagerPreparation {
    partition: string;
    coverage: "complete";
    inspection: ControlJournalInspection;
    validation: ControlJournalValidation;
    preparationFingerprint: string;
    virtual: boolean;
}
export declare class JournalManager {
    private readonly options;
    readonly rootDir: string;
    readonly partition: string;
    readonly journalRoot: string;
    readonly partitionDir: string;
    private readonly operationsDir;
    private readonly quarantineDir;
    private readonly artifactPrefix;
    private readonly now;
    private readonly faults;
    private readonly registrations;
    private readonly journalOptions;
    private journal;
    private recovery;
    private generationValue;
    private preparedOperation;
    private preparationResult;
    private lifecycle;
    constructor(rootDir: string, options?: JournalManagerOptions);
    registerProjection<T>(descriptor: JournalProjectionDescriptor<T>): JournalProjectionSlot<T>;
    start(): ControlJournalInspection;
    prepare(): JournalManagerPreparation;
    revalidatePreparation(): void;
    activatePrepared(): void;
    recoverAfterStartup(): void;
    inspect(): ControlJournalInspection;
    ready(): boolean;
    validate(): ControlJournalValidation;
    events(afterCursor?: string): {
        schemaVersion: 1;
        cursor: string;
        partition: string;
        type: string;
        observedAt: string;
        payload?: unknown;
    }[];
    exportRecovery(): ControlJournalExportReceipt;
    preflightQuarantine(input: JournalQuarantineRequest): {
        disposition: string;
        receipt: {
            schemaVersion: 1;
            operationId: string;
            partition: string;
            previousFingerprint: string;
            quarantineArtifactId: string;
            quarantinePath: string;
            newEpoch: string;
            completedAt: string;
        };
    } | {
        disposition: string;
        receipt: null;
    };
    quarantineAndStartFresh(input: JournalQuarantineRequest): ControlJournalQuarantineReceipt;
    close(): void;
    /**
     * Close the partition's generation and rename it into journal-archived/, never
     * delete history. Missing source returns an existing archive path or null;
     * a pre-existing archive for a re-registered id is preserved under a suffix.
     */
    archivePartition(): string | null;
    /**
     * Roll a just-archived partition back into the active journal tree — the
     * removeProject rollback when the durable registry `unregister` fails AFTER a
     * successful archive (Ф2 finding 4). Moves `archivedPath` back to
     * `partitionDir` and reopens a fresh generation so the partition is usable
     * again. Throws (leaving the archive in place) when the active slot is already
     * occupied, so the caller can disclose the unrecoverable partial state.
     */
    restoreArchivedPartition(archivedPath: string): void;
    private openGeneration;
    private resume;
    private completeFromReceipt;
    private reconcilePrepared;
    private inspection;
    private enterRecovery;
    private observeFingerprint;
    private stableFingerprint;
    private clearSlots;
    private assertStarted;
    private assertOpen;
}
//# sourceMappingURL=journal-manager.d.ts.map