import * as fs from "node:fs";
import { Store, type Failure, ProtocolError } from "./store.js";
import type { Options, Limits, CommitEvent, RequestContext, StagedFile } from "./contracts.js";
export type { Options, Limits, AuthResult } from "./contracts.js";
interface SessionRow {
    id: string;
    token: string;
    epoch: number;
    state: string;
    target: string;
    context: string;
    meta: string;
    max_files: number;
    max_bytes: number;
    expires: number;
    published: string;
    declared_files: number;
    declared_dirs: number;
    declared_bytes: number;
    confirmed_bytes: number;
    base_dir: string;
    map_files: number;
    mapped: number;
    auto_publish: number;
    client_publish: number;
    hook_status: string;
    overwrite: number;
    conflict: number;
    failure: string;
}
interface Active {
    done: Promise<void>;
    cancelled: Promise<void>;
    finish: () => void;
    abort: () => void;
}
export type Part = [string, number, number, number, number];
export interface Manifest {
    files: Part[];
    dirs: string[];
}
export interface Batch {
    id: string;
    sid: string;
    epoch: number;
    active: Active;
    manifest?: Manifest;
    signature?: string;
    entries?: {
        item: Part;
        filePath: string;
        skip: boolean;
    }[];
}
export declare class Engine {
    readonly store: Store;
    readonly limits: Limits;
    readonly options: Options;
    private runtimes;
    private timer?;
    private closed;
    private publishLock;
    private cleanups;
    constructor(options: Options);
    private runtime;
    row(id: string): SessionRow;
    authenticate(id: string, token: string): SessionRow;
    private touch;
    private report;
    create(input: {
        protocol?: unknown;
        targetDir?: unknown;
        meta?: unknown;
        overwrite?: unknown;
    }, headers: Record<string, string>, request?: RequestContext): Promise<{
        id: `${string}-${string}-${string}-${string}-${string}`;
        token: string;
        epoch: number;
        limits: Limits;
    }>;
    staging(id: string): string;
    payload(id: string, file: string): string;
    destination(row: SessionRow, file: string): string;
    getSession(id: string): CommitEvent & {
        state: string;
        processing: string;
    };
    listStaged(id: string): Generator<StagedFile>;
    openStaged(id: string, file: string): fs.ReadStream;
    snapshot(id: string): {
        id: string;
        epoch: number;
        state: string;
        files: number;
        bytes: number;
        confirmedBytes: number;
        asks: {
            id: string;
            message: string;
            choices: string[];
            answer: null;
        }[];
        published: string[];
        publishedCount: number;
        publishedNext: string | null;
        clientPublish: boolean;
        processing: string;
        overwrite: boolean;
        overwriteRequired: boolean;
        error: Failure | null;
    };
    private needsOverwrite;
    questions(id: string): {
        id: string;
        message: string;
        choices: string[];
        answer: null;
    }[];
    recordFailure(id: string, error: unknown, phase: string): ProtocolError;
    private clearFailure;
    subscribe(id: string, listener: (state: unknown) => void): () => boolean;
    private emit;
    private conflicts;
    setProperties(id: string, properties: {
        overwrite?: unknown;
    }): Promise<{
        id: string;
        epoch: number;
        state: string;
        files: number;
        bytes: number;
        confirmedBytes: number;
        asks: {
            id: string;
            message: string;
            choices: string[];
            answer: null;
        }[];
        published: string[];
        publishedCount: number;
        publishedNext: string | null;
        clientPublish: boolean;
        processing: string;
        overwrite: boolean;
        overwriteRequired: boolean;
        error: Failure | null;
    }>;
    answer(id: string, question: string, choice: string): Promise<{
        id: string;
        epoch: number;
        state: string;
        files: number;
        bytes: number;
        confirmedBytes: number;
        asks: {
            id: string;
            message: string;
            choices: string[];
            answer: null;
        }[];
        published: string[];
        publishedCount: number;
        publishedNext: string | null;
        clientPublish: boolean;
        processing: string;
        overwrite: boolean;
        overwriteRequired: boolean;
        error: Failure | null;
    }>;
    begin(id: string, epoch: number, batchId: string, abort: () => void): Promise<Batch>;
    receipt(id: string, batchId: string): any;
    private nodes;
    publishedPage(id: string, after?: string): {
        files: string[];
        next: string | null;
    };
    rangeStatus(id: string, data: {
        epoch: number;
        files: Part[];
    }): {
        received: boolean[];
        confirmedBytes: number;
    };
    private checkName;
    private mappedDestination;
    prepare(batch: Batch, raw: unknown): Promise<any>;
    complete(batch: Batch): Promise<{
        id: string;
        parts: number;
        bytes: number;
        confirmedBytes: number;
    }>;
    end(batch: Batch): void;
    resume(id: string): Promise<{
        limits: Limits;
        id: string;
        epoch: number;
        state: string;
        files: number;
        bytes: number;
        confirmedBytes: number;
        asks: {
            id: string;
            message: string;
            choices: string[];
            answer: null;
        }[];
        published: string[];
        publishedCount: number;
        publishedNext: string | null;
        clientPublish: boolean;
        processing: string;
        overwrite: boolean;
        overwriteRequired: boolean;
        error: Failure | null;
    }>;
    resumePage(id: string, after?: string, limit?: number): {
        files: {
            path: string;
            size: number;
            mtime: number;
            offsets: number[];
        }[];
        next: string | null;
    };
    commit(id: string, totals: {
        files: number;
        dirs: number;
        bytes: number;
    }): Promise<{
        id: string;
        epoch: number;
        state: string;
        files: number;
        bytes: number;
        confirmedBytes: number;
        asks: {
            id: string;
            message: string;
            choices: string[];
            answer: null;
        }[];
        published: string[];
        publishedCount: number;
        publishedNext: string | null;
        clientPublish: boolean;
        processing: string;
        overwrite: boolean;
        overwriteRequired: boolean;
        error: Failure | null;
    }>;
    retryCommitted(id: string): Promise<{
        id: string;
        epoch: number;
        state: string;
        files: number;
        bytes: number;
        confirmedBytes: number;
        asks: {
            id: string;
            message: string;
            choices: string[];
            answer: null;
        }[];
        published: string[];
        publishedCount: number;
        publishedNext: string | null;
        clientPublish: boolean;
        processing: string;
        overwrite: boolean;
        overwriteRequired: boolean;
        error: Failure | null;
    }>;
    private preparePlan;
    preparePublish(id: string): Promise<{
        id: string;
        epoch: number;
        state: string;
        files: number;
        bytes: number;
        confirmedBytes: number;
        asks: {
            id: string;
            message: string;
            choices: string[];
            answer: null;
        }[];
        published: string[];
        publishedCount: number;
        publishedNext: string | null;
        clientPublish: boolean;
        processing: string;
        overwrite: boolean;
        overwriteRequired: boolean;
        error: Failure | null;
    }>;
    publishFromClient(id: string): Promise<{
        id: string;
        epoch: number;
        state: string;
        files: number;
        bytes: number;
        confirmedBytes: number;
        asks: {
            id: string;
            message: string;
            choices: string[];
            answer: null;
        }[];
        published: string[];
        publishedCount: number;
        publishedNext: string | null;
        clientPublish: boolean;
        processing: string;
        overwrite: boolean;
        overwriteRequired: boolean;
        error: Failure | null;
    }>;
    publish(id: string, beforeMove?: () => void): Promise<{
        id: string;
        epoch: number;
        state: string;
        files: number;
        bytes: number;
        confirmedBytes: number;
        asks: {
            id: string;
            message: string;
            choices: string[];
            answer: null;
        }[];
        published: string[];
        publishedCount: number;
        publishedNext: string | null;
        clientPublish: boolean;
        processing: string;
        overwrite: boolean;
        overwriteRequired: boolean;
        error: Failure | null;
    }>;
    private publishImpl;
    cancel(id: string): Promise<{
        id: string;
        epoch: number;
        state: string;
        files: number;
        bytes: number;
        confirmedBytes: number;
        asks: {
            id: string;
            message: string;
            choices: string[];
            answer: null;
        }[];
        published: string[];
        publishedCount: number;
        publishedNext: string | null;
        clientPublish: boolean;
        processing: string;
        overwrite: boolean;
        overwriteRequired: boolean;
        error: Failure | null;
    }>;
    private cancelImpl;
    sweep(now?: number): Promise<number>;
    close(): Promise<void>;
}