import type { NextStepDirective, PauseUntilSignalDirective, AgentManifest } from '@sapiom/agent';
import type { ExecutionState, StepRow } from './execution-state.js';
export interface StartExecutionArgs {
    readonly workflowName: string;
    readonly organizationId: string | null;
    readonly tenantId: string | null;
    readonly input: unknown;
    readonly entryStep: string;
    readonly entryStepInput: unknown;
    readonly idempotencyKey?: string;
    readonly manifest: AgentManifest;
    readonly definitionId?: string | null;
    readonly buildRunId?: string | null;
    readonly scopedApiKeyId?: string | null;
}
export interface ExecutionStore {
    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 interface SpanSpec {
    readonly name: string;
    readonly attributes?: Record<string, unknown>;
}
export interface RuntimeObserver {
    withSpan<T>(span: SpanSpec, fn: () => Promise<T>): Promise<T>;
    count(metric: {
        name: string;
        attributes?: Record<string, unknown>;
    }): void;
    onTerminal?(executionId: string, kind: 'completed' | 'failed'): Promise<void>;
    openRun?(args: {
        executionId: string;
        workflowName: string;
        tenantId: string;
    }): Promise<void>;
    openStep?(args: {
        executionId: string;
        stepName: string;
        stepRowId: string;
        tenantId: string;
    }): Promise<void>;
    completeStep?(args: {
        stepRowId: string;
        outcome: 'success' | 'error';
    }): Promise<void>;
    completeRun?(args: {
        executionId: string;
        outcome: 'success' | 'error';
    }): Promise<void>;
}
export declare const NOOP_OBSERVER: RuntimeObserver;
export interface RuntimeAnalytics {
    track(eventType: string, data?: Record<string, unknown>): void;
}