import type { CompiledGraph } from "../core/graph.js";
import { type ArtifactReference, type ExecutionLimits, type GraphCheckpointRef, type GraphEvent, type GraphExecutionState, type SideEffectExecutionState } from "../core/scheduler.js";
export interface GraphExecutionCursor<State> {
    graphId: string;
    graphVersion: string;
    nodeId: string;
    state: State;
    step: number;
}
export interface NodeResult<Event, Output = unknown> {
    event: Event;
    output?: Output;
    evidence?: Record<string, string | number | boolean | null>;
    usage?: {
        observedCostUsd: number | "unknown";
        inputTokens: number | "unknown";
        outputTokens: number | "unknown";
    };
}
export interface GraphRuntime<State, Event, Context> {
    reduce(state: State, event: Event): State;
    resolveEdge(previous: State, event: Event, next: State): string;
    stateNode(state: State): string;
    runNode(nodeId: string, state: State, context: Context): Promise<NodeResult<Event>>;
    isCurrent(cursor: Readonly<GraphExecutionCursor<State>>, context: Context): boolean;
}
export declare function executeGraphStep<State, Event, Context>(graph: CompiledGraph, cursor: Readonly<GraphExecutionCursor<State>>, runtime: GraphRuntime<State, Event, Context>, context: Context): Promise<GraphExecutionCursor<State>>;
export interface ScheduledSideEffect<Event, Output = unknown> {
    class: SideEffectExecutionState["class"];
    requestRef: string;
    idempotencyKey: string;
    checkpointRef?: GraphCheckpointRef;
    routingDecisionId?: string;
    estimatedUsage?: {
        estimatedCostUsd: number | "unknown";
        inputTokens?: number | "unknown";
        outputTokens?: number | "unknown";
    };
    persistResult(result: Readonly<NodeResult<Event, Output>>): Promise<ArtifactReference>;
    recoverResult(reference: Readonly<ArtifactReference>): Promise<NodeResult<Event, Output>>;
    reconcileIntent?(persisted: Readonly<SideEffectExecutionState>): Promise<{
        outcome: "succeeded";
        resultRef: ArtifactReference;
        result: NodeResult<Event, Output>;
    } | {
        outcome: "failed" | "unknown";
    }>;
}
export interface ScheduledGraphPersistence {
    checkpoint(current: Readonly<GraphExecutionState>, event: Readonly<GraphEvent>): Promise<GraphExecutionState>;
}
export interface ScheduledGraphStepOptions<State, Event, Context, Output = unknown> {
    schedulerState: Readonly<GraphExecutionState>;
    limits: ExecutionLimits;
    unattended: boolean;
    now(): string;
    persistence: ScheduledGraphPersistence;
    prepareSideEffect?(nodeId: string, state: Readonly<State>, context: Context): Promise<ScheduledSideEffect<Event, Output>> | ScheduledSideEffect<Event, Output>;
    completion?(result: Readonly<NodeResult<Event, Output>>): {
        artifactRefs: ArtifactReference[];
        validatorResult?: GraphEvent["validatorResult"];
    };
}
export interface ScheduledGraphStepResult<State> {
    cursor: GraphExecutionCursor<State>;
    schedulerState: GraphExecutionState;
}
/**
 * Durable additive runner. The caller owns immutable artifact persistence and
 * append-before-snapshot checkpointing; this function owns admission order and
 * refuses to repeat an ambiguous effect.
 */
export declare function executeScheduledGraphStep<State, Event, Context, Output = unknown>(graph: CompiledGraph, cursor: Readonly<GraphExecutionCursor<State>>, runtime: GraphRuntime<State, Event, Context>, context: Context, options: ScheduledGraphStepOptions<State, Event, Context, Output>): Promise<ScheduledGraphStepResult<State>>;