import { Effect } from 'effect';
import type { Tool } from '../tool/tool';
import type { EvalCheckpointArtifact, EvaluationArtifact } from './artifact';
import { TraceStorageService, type TraceStorageApi } from './storage';
export type ReplayMode = 'retry' | 'skip' | 'restart';
export interface ReplayOptions {
    fromCheckpoint?: number;
    mode?: ReplayMode;
}
export interface ReplayDependencies {
    storage: Pick<TraceStorageApi, 'get'>;
    runtime: ReplayRuntimeAdapter;
    configPath?: string;
}
export interface ReplayRuntimeAdapter {
    initializeFromConfig: (configPath: string, options: {
        toolExecutors?: Map<string, Tool['execute']>;
    }) => Promise<void>;
    resumeFromCheckpoint: (input: ReplayResumeInput) => Effect.Effect<unknown> | Promise<unknown> | unknown;
}
export interface ReplayResumeInput {
    runId: string;
    pipelineId: string;
    mode: ReplayMode;
    checkpoint: EvalCheckpointArtifact;
    contextSnapshot: Record<string, unknown>;
    toolExecutors: Map<string, Tool['execute']>;
}
export interface ReplayResult {
    traceId: string;
    runId: string;
    checkpointStep: number;
    mode: ReplayMode;
    output: unknown;
    outputHash: string;
}
export declare function deterministicReplayHash(value: unknown): string;
export declare function runEffectWithTestClock<A, E>(effect: Effect.Effect<A, E>, adjustmentsMs: ReadonlyArray<number>): Promise<A>;
export declare function withTestClock<A, E>(effect: Effect.Effect<A, E>, adjustmentsMs: ReadonlyArray<number>): Effect.Effect<A, E>;
export declare function deriveClockAdjustmentsFromOffsets(offsetsMs: ReadonlyArray<number>, extraMs?: number): ReadonlyArray<number>;
export declare class MissingToolMockResponseError extends Error {
    constructor(toolId: string, callOrdinal: number);
}
export declare class ToolMockSignatureMismatchError extends Error {
    constructor(toolId: string, callOrdinal: number);
}
export interface ReplayToolMocks {
    readonly toolExecutors: Map<string, Tool['execute']>;
    assertConsumed: () => void;
}
export declare function buildReplayToolMocks(artifact: EvaluationArtifact): ReplayToolMocks;
export declare class ReplayTraceNotFoundError extends Error {
    constructor(traceId: string);
}
export declare class ReplayCheckpointNotFoundError extends Error {
    constructor(requestedCheckpoint: number, availableCheckpoints: ReadonlyArray<number>);
}
export declare function createReplayOrchestrator(deps: ReplayDependencies): {
    replay: (traceId: string, options?: ReplayOptions) => Promise<ReplayResult>;
};
export declare const replay: (traceId: string, options: ReplayOptions, dependencies: ReplayDependencies) => Promise<ReplayResult>;
export declare const replayWithStorage: (traceId: string, options: ReplayOptions, runtime: ReplayRuntimeAdapter, configPath: string) => Effect.Effect<ReplayResult, Error, TraceStorageService>;
//# sourceMappingURL=replay.d.ts.map