import { DamlLfValueDefinition } from "../../daml-lf/model/daml-lf-value-definition.js";
import { IDamlLfReplayEffect, IDamlLfTraceSink } from "../../daml-lf/interpreter/daml-lf-trace-sink.interface.js";
import { IDamlLfReplayEnvironment, IDamlLfReplayEvaluationResult } from "../../daml-lf/interpreter/daml-lf-evaluator.js";
import { ReplayScope } from "../session/replay-scope.js";
import { ReplaySessionMetadata } from "../session/replay-session-metadata.js";
import { ReplayStep } from "../session/replay-step.js";
import { ILedgerReplayEnvironment, IReplayTransactionSnapshot } from "./ledger-replay-environment-builder.js";
import { ResolvedReplayEntrypointDefinition } from "./replay-entrypoint-definition-resolver.js";
import { ReplaySessionRequest } from "../session/replay-session-request.js";
import { DamlSourceMapper } from "../source/daml-source-mapper.js";
import { DamlLfTemplateId } from "../../daml-lf/model/daml-lf-template-id.js";
interface IReplayUpdateLoader {
    loadOrThrowAsync(offset: string): Promise<IReplayTransactionSnapshot>;
}
interface IReplayEnvironmentBuilder {
    buildOrThrowAsync(snapshot: IReplayTransactionSnapshot): Promise<ILedgerReplayEnvironment>;
}
interface IReplayDefinitionResolver {
    resolveEntrypointDefinitionOrThrow(entrypoint: IReplayTransactionSnapshot["entrypoint"]): ResolvedReplayEntrypointDefinition;
    resolveChoiceDefinitionOrThrow?(templateId: DamlLfTemplateId, choiceName: string): ResolvedReplayEntrypointDefinition;
}
interface IReplayEvaluator {
    evaluateReplayEntrypointOrThrow(definition: DamlLfValueDefinition, environment: IDamlLfReplayEnvironment, traceSink?: IDamlLfTraceSink): IDamlLfReplayEvaluationResult;
}
interface IReplayDeterminismValidator {
    validateOrThrow(snapshot: IReplayTransactionSnapshot, replayedEffects: readonly IDamlLfReplayEffect[]): void;
}
export interface ILoadedReplaySession {
    readonly sessionId: string;
    readonly metadata: ReplaySessionMetadata;
    readonly steps: readonly ReplayStep[];
    readonly scopesByStep: readonly (readonly ReplayScope[])[];
    readonly currentStepIndex: number;
}
export declare class LedgerReplaySessionLoader {
    private readonly dependencies;
    constructor(dependencies: {
        updateLoader: IReplayUpdateLoader;
        environmentBuilder: IReplayEnvironmentBuilder;
        definitionResolver: IReplayDefinitionResolver;
        sourceMapper?: DamlSourceMapper;
        evaluator: IReplayEvaluator;
        determinismValidator: IReplayDeterminismValidator;
        sessionIdFactory?: () => string;
    });
    loadOrThrowAsync(request: ReplaySessionRequest): Promise<ILoadedReplaySession>;
    private projectReplaySteps;
    private projectRawReplaySteps;
    private projectNavigableReplaySteps;
    private createSourceLocationKey;
    private createVisibleExpressionKey;
    private shouldRetainDefinitionTransition;
    private shouldRetainExpressionStep;
    private hasVisibleLocalsChange;
    private isMeaningfulDebuggerExpression;
    private isMeaningfulDefinitionExpression;
    private toReplayPhase;
    private createValuePreview;
    private createStateDelta;
    private stringifyRuntimeValue;
    private rememberFrameScope;
    private createContractTypeIndex;
    private rememberStateEffectContractType;
    private resolveRuntimeValueContractType;
    private formatTemplateType;
    private prepareStackForStep;
    private finalizeStackForStep;
    private pushFrameIfMissing;
    private popFrameIfTop;
    private cloneScope;
    private resolveFrameName;
    private isGeneratedHelperDefinitionName;
    private formatGeneratedHelperLabel;
    private formatExecutableFrameLabel;
    private formatReplayEffectFrameLabel;
    private createSourceLocation;
}
export {};