import { type AgentProviderFailure, type AgentProviderRecovery, WorkflowAgentExecutor } from "./agent-execution.js";
import { type PersistedRun, type RunStore, type WorktreeReference } from "./persistence.js";
import { type WorkflowRegistryApi } from "./registry.js";
import { type AgentRecord, type BudgetEvent, type JsonValue, type ModelSpec, type RunState, type WorkflowBridge, type WorkflowCheckpointState, type WorkflowExecution, type WorkflowMetadata, type WorkflowRunContext } from "./types.js";
type WorkflowEventSink = {
    emit: (name: string, payload: unknown) => unknown;
};
export type WorkflowToolUpdate = {
    content: [{
        type: "text";
        text: string;
    }];
    details: {
        runId: string;
        run: import("./persistence.js").PersistedRun;
    };
};
export type WorkflowRunRecord = {
    executor: WorkflowAgentExecutor;
    store: RunStore;
    metadata: WorkflowMetadata;
    model: ModelSpec;
    lifecycle: RunLifecycle;
    budget: import("./budget.js").WorkflowBudgetRuntime;
    abortController: AbortController;
    projectTrusted: () => boolean;
    providerErrorRecovery?: (failure: AgentProviderFailure) => Promise<AgentProviderRecovery>;
    execution?: WorkflowExecution;
    completion?: Promise<unknown>;
    foreground?: boolean;
    checkpointResolvers: Map<string, (value: boolean) => void>;
    update?: (result: WorkflowToolUpdate) => void;
};
export declare class RunLifecycle {
    #private;
    private readonly changed?;
    constructor(state?: RunState, changed?: ((state: RunState, previousState: RunState, reason?: string) => void | Promise<void>) | undefined);
    get state(): RunState;
    enter(): Promise<void>;
    leave(): Promise<void>;
    enterAwaitingInput(): Promise<void>;
    resolveAwaitingInput(): Promise<void>;
    pause(): Promise<void>;
    resume(): Promise<void>;
    providerPause(): Promise<void>;
    terminal(state: "completed" | "failed" | "stopped" | "interrupted" | "budget_exhausted", reason?: string): Promise<void>;
}
export declare class WorkflowEventPublisher {
    #private;
    private readonly sink;
    constructor(sink: WorkflowEventSink | undefined);
    removeRun(runId: string): void;
    seedBudget(runId: string, events: readonly BudgetEvent[] | undefined): void;
    runStarted(store: RunStore, metadata: WorkflowMetadata): Promise<void>;
    runResumed(store: RunStore, metadata: WorkflowMetadata): Promise<void>;
    runState(store: RunStore, metadata: WorkflowMetadata, previousState: RunState, state: RunState, reason?: string): Promise<void>;
    runCompleted(store: RunStore, metadata: WorkflowMetadata, resultPath: string): Promise<void>;
    runFailed(store: RunStore, metadata: WorkflowMetadata, error: unknown, state: "failed" | "stopped" | "interrupted" | "budget_exhausted"): Promise<void>;
    agentState(store: RunStore, metadata: WorkflowMetadata, previous: AgentRecord | undefined, agent: AgentRecord): Promise<void>;
    agentStates(store: RunStore, metadata: WorkflowMetadata, previous: readonly AgentRecord[], current: readonly AgentRecord[]): Promise<void>;
    phase(store: RunStore, metadata: WorkflowMetadata, previousPhase: string | undefined, phase: string): Promise<void>;
    checkpoint(store: RunStore, metadata: WorkflowMetadata, name: string, state: WorkflowCheckpointState): Promise<void>;
    budget(store: RunStore, metadata: WorkflowMetadata, run: Pick<PersistedRun, "budgetEvents">): Promise<void>;
    worktree(store: RunStore, metadata: WorkflowMetadata, worktree: WorktreeReference): Promise<void>;
    private budgetKey;
}
export declare function workflowRunContext(cwd: string, sessionId: string, runId: string, workflow: WorkflowMetadata, args: JsonValue, signal: AbortSignal): Readonly<WorkflowRunContext>;
export declare function nextNamedOccurrence(counters: Map<string, number>, label: string): string;
export declare function withWorkflowFunctions(bridge: WorkflowBridge, store: RunStore, runContext: Readonly<WorkflowRunContext>, registry: WorkflowRegistryApi): WorkflowBridge;
export {};