import type { JsonRecord } from "../storage/types";
import { type StateCacheSnapshot } from "../runtime/replay/stateCache";
import { type ClockSequenceInput, type DeterministicUlidHandle, type DeterministicUlidOptions, type FixedClockHandle, type FixedClockOptions } from "./deterministicProviders";
type MaybePromise<T> = T | Promise<T>;
export interface SnapshotJournalEntry {
    seq: number;
    ulid: string;
    recordedAt: string;
    type: string;
    data: JsonRecord;
}
export interface SnapshotStateSummary {
    savedAt: string;
    stateVersion: number;
    journalHead: StateCacheSnapshot["journalHead"];
    pendingEffectsByKind: StateCacheSnapshot["pendingEffectsByKind"];
    effectsByInvocation: StateCacheSnapshot["effectsByInvocation"];
    rebuildReason: StateCacheSnapshot["rebuildReason"];
}
export interface DeterministicRunSnapshot {
    journal: SnapshotJournalEntry[];
    state: SnapshotStateSummary | null;
}
export interface TempDeterministicRun {
    runDir: string;
    cleanup(): Promise<void>;
    restore(): void;
}
export interface TempDeterministicRunOptions {
    processSource: string;
    inputs?: unknown;
    runId?: string;
    request?: string;
    clock?: ClockSequenceInput;
    ulids?: readonly string[];
}
export { installDeterministicUlids, installFixedClock, } from "./deterministicProviders";
export type { ClockSequenceInput, DeterministicUlidHandle, DeterministicUlidOptions, FixedClockHandle, FixedClockOptions, } from "./deterministicProviders";
export interface DeterministicRunHarnessOptions {
    processPath?: string;
    processSource?: string;
    inputs?: unknown;
    runId?: string;
    request?: string;
    exportName?: string;
    clock?: FixedClockOptions;
    ulids?: DeterministicUlidOptions;
}
export interface DeterministicRunHarness {
    runId: string;
    runDir: string;
    runsRoot: string;
    clock: FixedClockHandle;
    ulids: DeterministicUlidHandle;
    cleanup(): Promise<void>;
}
export declare function withDeterministicIds<T>(sequence: readonly string[], fn: () => MaybePromise<T>): Promise<T>;
export declare function withFixedClock<T>(sequenceOrValue: ClockSequenceInput, fn: () => MaybePromise<T>): Promise<T>;
export declare function createTempDeterministicRun(options: TempDeterministicRunOptions): Promise<TempDeterministicRun>;
export declare function snapshotRunState(runDir: string): Promise<DeterministicRunSnapshot>;
export declare function createDeterministicRunHarness(options: DeterministicRunHarnessOptions): Promise<DeterministicRunHarness>;
//# sourceMappingURL=deterministic.d.ts.map