import type { StepRecord, RunState, RunFilter, RunRef } from './types.js';
export declare class LogConflictError extends Error {
    readonly runId: string;
    readonly expectedIndex: number;
    readonly actualIndex: number;
    constructor(runId: string, expectedIndex: number, actualIndex: number);
}
export declare class SuspendError extends Error {
    readonly waitingFor: string;
    constructor(waitingFor: string);
}
export declare class RunNotFoundError extends Error {
    constructor(runId: string);
}
export declare class StepNotFoundError extends Error {
    constructor(runId: string, key: string);
}
export declare class RunNotTerminalError extends Error {
    readonly runId: string;
    readonly status: RunState['status'];
    constructor(runId: string, status: RunState['status']);
}
export interface DeleteRunOptions {
    force?: boolean;
}
export declare function isTerminalRunStatus(status: RunState['status']): boolean;
export interface StepFinalizePatch {
    status: 'finished' | 'error';
    result?: unknown;
    error?: {
        name: string;
        message: string;
    };
    finishedAt?: number;
}
export interface RunStore {
    appendStep(runId: string, record: StepRecord): Promise<void>;
    finalizeStep(runId: string, key: string, patch: StepFinalizePatch): Promise<void>;
    getSteps(runId: string): Promise<StepRecord[]>;
    getRunState(runId: string): Promise<RunState | null>;
    putRunState(state: RunState): Promise<void>;
    initRun?(state: RunState): Promise<void>;
    pruneStepsBeforeEpoch?(runId: string, keepEpoch: number): Promise<void>;
    reserveSteps?(runId: string, count: number): Promise<number[]>;
    listRuns(filter: RunFilter): AsyncIterable<RunRef>;
    deleteRun(runId: string, options?: DeleteRunOptions): Promise<void>;
}