import { type HistoryDiagnostic, type HistoryEntry, type StorageFaultPoint } from "./history.js";
import type { ConfigV1 } from "./types.js";
export type ConfigSource = "active" | "default" | "history";
export interface ConfigSnapshot {
    readonly generation: number;
    readonly savedAt?: string;
    readonly config: ConfigV1;
    readonly source: ConfigSource;
}
export type ConfigLoadStatus = "missing" | "valid" | "recovered" | "corrupt";
export interface ConfigLoadResult {
    readonly status: ConfigLoadStatus;
    readonly snapshot?: ConfigSnapshot;
    readonly repairRequired: boolean;
    readonly diagnostics: readonly string[];
}
export interface ConfigMutationResult {
    readonly changed: boolean;
    readonly activated: boolean;
    readonly generation: number;
    readonly previousGeneration?: number;
    readonly historyPath?: string;
    readonly warnings: readonly string[];
}
export type ConfigAuditAction = "initialize" | "save" | "update" | "restore" | "import" | "recover";
export interface ConfigAuditEvent {
    readonly action: ConfigAuditAction;
    readonly generation: number;
    readonly previousGeneration?: number;
    readonly timestamp: string;
}
export interface HistoryListResult {
    readonly entries: readonly HistoryEntry[];
    readonly diagnostics: readonly HistoryDiagnostic[];
}
export interface ImportPreview {
    readonly config: ConfigV1;
    readonly changed: boolean;
    readonly before?: string;
    readonly after: string;
    readonly expectedGeneration?: number;
}
export interface StorageFaultHooks {
    readonly fault?: (point: StorageFaultPoint) => void | Promise<void>;
    readonly id?: () => string;
    readonly now?: () => string;
}
export interface ConfigStoreOptions {
    readonly root: string;
    readonly defaults?: () => ConfigV1;
    readonly clock?: () => Date;
    readonly maxImportBytes?: number;
    readonly hooks?: StorageFaultHooks;
    /** Optional no-content post-commit audit boundary; M1 provides no durable sink. */
    readonly onAudit?: (event: ConfigAuditEvent) => void | Promise<void>;
    /** Optional pure migration for old storage/config fixtures. */
    readonly migrateConfig?: (value: unknown) => unknown;
}
export type ConfigMutator = (draft: ConfigV1) => ConfigV1 | void | Promise<ConfigV1 | void>;
export declare class ConfigStore {
    private readonly root;
    private readonly defaults;
    private readonly clock;
    private readonly maxImportBytes;
    private readonly hooks;
    private readonly onAudit;
    private readonly migrateConfig;
    private queue;
    constructor(options: ConfigStoreOptions);
    /** Read active state. This method never repairs or overwrites files. */
    load(): Promise<ConfigLoadResult>;
    /** Write defaults only when no active configuration exists. */
    initialize(config?: ConfigV1): Promise<ConfigMutationResult>;
    save(config: ConfigV1, options?: {
        readonly expectedGeneration?: number;
    }): Promise<ConfigMutationResult>;
    /** Apply a synchronous/async mutation to the latest queued generation. */
    update(mutator: ConfigMutator): Promise<ConfigMutationResult>;
    listHistory(): Promise<HistoryListResult>;
    restore(generation: number, options?: {
        readonly expectedGeneration?: number;
    }): Promise<ConfigMutationResult>;
    /** Quarantine and repair an invalid active file using the newest valid history. */
    recover(): Promise<ConfigLoadResult>;
    export(): Promise<string>;
    previewImport(input: string | unknown): Promise<ImportPreview>;
    activateImport(input: string | unknown | ImportPreview, options: {
        readonly confirmed: boolean;
        readonly expectedGeneration?: number;
    }): Promise<ConfigMutationResult>;
    private enqueue;
    private validateCandidate;
    private validateStored;
    private readActive;
    private loadUnlocked;
    private readHistoryUnlocked;
    private snapshot;
    private serializeStored;
    private parseImport;
    private isStoredEnvelope;
    private currentSchemaValue;
    private commit;
    private nextGeneration;
    private assertExpected;
    private nowIso;
    private emitAudit;
    private persistenceError;
    private recoveryError;
}
export declare function removeTemporaryStorageFiles(root: string): Promise<void>;