import { type NextStepDirective, type PauseUntilSignalDirective } from '@sapiom/agent';
import type { StepDispatchRequest, StepDispatcher } from './dispatch.js';
import type { ExecutionState, StepRow } from './execution-state.js';
import type { AgentRunnerCore } from './runner-core.js';
import type { ExecutionStore, StartExecutionArgs } from './stores.js';
export declare function resetIdCounter(): void;
export declare class InMemoryExecutionStore implements ExecutionStore {
    private readonly executions;
    private readonly steps;
    private readonly stepsById;
    private readonly maxStepOrder;
    getExecution(executionId: string): ExecutionState | undefined;
    allExecutions(): ExecutionState[];
    startExecution(args: StartExecutionArgs): Promise<string>;
    loadExecution(executionId: string): Promise<ExecutionState | null>;
    prepareResume(args: {
        executionId: string;
        fromStepName: string;
        fromStepInput: unknown;
    }): Promise<void>;
    nextStepOrder(executionId: string): Promise<number>;
    startStep(args: {
        executionId: string;
        stepName: string;
        stepOrder: number;
        attempt: number;
        input: unknown;
        status: 'dispatched' | 'running';
    }): Promise<string>;
    findStepRow(executionId: string, stepOrder: number, attempt: number): Promise<StepRow | null>;
    findStepRowById(stepRowId: string): Promise<StepRow | null>;
    completeStep(args: {
        stepRowId: string;
        output: unknown;
        nextDirective: NextStepDirective;
        sharedStateAfter: Record<string, unknown>;
        logs?: unknown;
    }): Promise<void>;
    failStep(args: {
        stepRowId: string;
        error: unknown;
        sharedStateAfter: Record<string, unknown>;
        logs?: unknown;
    }): Promise<void>;
    failActiveDispatchedStep(args: {
        executionId: string;
        expectedVersion: number;
        stepRowId: string;
        error: unknown;
        sharedState: Record<string, unknown>;
        logs?: unknown;
    }): Promise<boolean>;
    markStepDispatched(args: {
        executionId: string;
        expectedVersion: number;
        stepRowId: string;
        deadlineAt: Date;
    }): Promise<boolean>;
    transitionToStep(args: {
        executionId: string;
        expectedVersion: number;
        nextStep: string;
        nextStepInput: unknown;
        sharedState: Record<string, unknown>;
    }): Promise<boolean>;
    retainStepForRetry(args: {
        executionId: string;
        expectedVersion: number;
        sharedState: Record<string, unknown>;
    }): Promise<boolean>;
    pauseExecution(args: {
        executionId: string;
        expectedVersion: number;
        directive: PauseUntilSignalDirective;
        sharedState: Record<string, unknown>;
    }): Promise<boolean>;
    completeExecution(args: {
        executionId: string;
        expectedVersion: number;
        output: unknown;
        sharedState: Record<string, unknown>;
    }): Promise<boolean>;
    failExecution(args: {
        executionId: string;
        expectedVersion: number;
        error: unknown;
        output?: unknown;
        sharedState: Record<string, unknown>;
    }): Promise<boolean>;
}
export declare class SyncInProcessDispatcher implements StepDispatcher {
    private bodies;
    private core;
    private maxAttemptsPerStep;
    setCore(core: AgentRunnerCore): void;
    setMaxAttempts(max: number): void;
    setSyncBody(stepName: string, body: (input: unknown) => Promise<{
        output: unknown;
        directive: NextStepDirective;
    }>): void;
    dispatch(request: StepDispatchRequest): Promise<void>;
}