export type FileMutationKind = "write" | "edit";
export interface FilePathIdentity {
    dev: string;
    ino: string;
    mode: string;
    size: string;
    mtimeMs: string;
    ctimeMs: string;
    mtimeNs?: string;
    ctimeNs?: string;
}
export interface FilePathInspection {
    kind: "file" | "directory" | "other";
    identity: FilePathIdentity;
}
export interface FileMutationIntentOperations {
    inspect(path: string, followSymlinks: boolean): Promise<FilePathInspection | undefined>;
    access(path: string, mode: number): Promise<void>;
    copyFileExclusive(sourcePath: string, targetPath: string): Promise<void>;
    hashFile(path: string, signal?: AbortSignal): Promise<string>;
    readPayload(path: string): Promise<string>;
    removeFile(path: string): Promise<void>;
    stagePayload(content: string, ttlMs: number): Promise<string>;
}
export interface FileMutationLease {
    kind: FileMutationKind;
    path: string;
    displayPath: string;
    identity?: FilePathIdentity;
}
export interface FileContentReference {
    contentRef: string;
    byteLength: number;
}
export interface FileMutationPayloadReference {
    payloadRef: string;
    byteLength: number;
}
export type FileMutationPreflightFailureReason = "write_collision" | "edit_missing" | "edit_not_file";
export declare class FileMutationPreflightError extends Error {
    readonly reason: FileMutationPreflightFailureReason;
    constructor(reason: FileMutationPreflightFailureReason, message: string);
}
export declare class FileMutationIdentityError extends Error {
    constructor(displayPath: string);
}
export interface FileMutationIntentControllerOptions {
    operations?: FileMutationIntentOperations;
    contentReferenceLimit?: number;
    contentReferenceTtlMs?: number;
    mutationPayloadLimit?: number;
    mutationPayloadByteLimit?: number;
    mutationPayloadTtlMs?: number;
    now?: () => number;
}
export declare const localFileMutationIntentOperations: FileMutationIntentOperations;
/**
 * Session-owned harness authority for file-mutation preflight, stale-target checks,
 * and bounded exact-content references. It retains only fixed-size metadata; file
 * bytes remain owned by the filesystem.
 */
export declare class FileMutationIntentController {
    private readonly operations;
    private readonly contentReferenceLimit;
    private readonly contentReferenceTtlMs;
    private readonly mutationPayloadLimit;
    private readonly mutationPayloadByteLimit;
    private readonly mutationPayloadTtlMs;
    private readonly now;
    private readonly contentReferences;
    private readonly mutationPayloads;
    private mutationPayloadBytes;
    private lastMutationPayloadExpiresAt;
    private mutationPayloadOperationTail;
    constructor(options?: FileMutationIntentControllerOptions);
    prepare(kind: FileMutationKind, path: string, signal?: AbortSignal, displayPath?: string): Promise<FileMutationLease>;
    assertCurrent(lease: FileMutationLease, signal?: AbortSignal): Promise<void>;
    /**
     * Re-anchor an edit lease to the file's current identity after an observed change.
     * The caller must then re-read and re-validate its content against that same version;
     * the next assertCurrent re-verifies that identity immediately before the caller writes.
     * That re-verification is a point-in-time observation, not a hold on the file: a write by
     * another process landing between it and the caller's write is neither detected nor
     * preserved — the caller's buffer overwrites it and nothing observes the loss afterwards.
     */
    refreshIdentity(lease: FileMutationLease, signal?: AbortSignal): Promise<void>;
    rememberContent(sourcePath: string, content: string): FileContentReference;
    /** True when this session's own earlier mutation produced exactly this content at this path. */
    hasProducedContent(sourcePath: string, content: string): boolean;
    retainMutationPayload(kind: FileMutationKind, payload: string): Promise<FileMutationPayloadReference | undefined>;
    readMutationPayload(payloadRef: string, kind: FileMutationKind, signal?: AbortSignal): Promise<string>;
    assertMutationPayload(payloadRef: string, kind: FileMutationKind, signal?: AbortSignal): Promise<void>;
    assertContentReference(contentRef: string, signal?: AbortSignal): Promise<void>;
    copyMutationPayload(payloadRef: string, targetPath: string, signal?: AbortSignal): Promise<FileContentReference>;
    discardMutationPayload(payloadRef: string): Promise<void>;
    /** Release every payload owned by this controller without touching another controller's files. */
    dispose(): Promise<void>;
    copyReferencedContent(contentRef: string, targetPath: string, signal?: AbortSignal): Promise<FileContentReference>;
    private requireVerifiedContentReference;
    private requireMutationPayload;
    private requireVerifiedMutationPayload;
    private verifySource;
    private copyVerifiedSource;
    private assertCreatableParent;
    private rememberContentDigest;
    private touchContentReference;
    private removeFailedCopy;
    private deleteMutationPayload;
    private runMutationPayloadOperation;
    private pruneExpiredMutationPayloads;
    private pruneExpired;
}
//# sourceMappingURL=file-mutation-intent.d.ts.map