import { z } from 'zod';
import { type JsonValue, type WorkflowNodeOutput } from './model.js';
import { type ResolvedEmployeeConfig, type WorkflowApprovalRecord, type WorkflowAttemptRecord, type WorkflowError, type WorkflowChildRunSummary, type WorkflowNodeRunRecord, type WorkflowRunDetail, type WorkflowRunRecord } from './runtime.js';
import type { WorkflowRunSummary } from './repository.js';
type WorkflowSqliteConnection = ConstructorParameters<typeof import('./repository.js').WorkflowRepository>[0];
declare const mutationSchemas: {
    readonly error: z.ZodObject<{
        code: z.ZodString;
        message: z.ZodString;
        retryable: z.ZodBoolean;
        nodeId: z.ZodOptional<z.ZodString>;
        attempt: z.ZodOptional<z.ZodNumber>;
        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPreprocess<z.ZodCustom<JsonValue, JsonValue>>>>;
    }, z.core.$strict>;
    readonly output: z.ZodObject<{
        text: z.ZodString;
        fields: z.ZodRecord<z.ZodString, z.ZodPreprocess<z.ZodCustom<JsonValue, JsonValue>>>;
        employeeId: z.ZodOptional<z.ZodString>;
        engine: z.ZodOptional<z.ZodString>;
        model: z.ZodOptional<z.ZodString>;
        sessionId: z.ZodOptional<z.ZodString>;
        choice: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>;
    readonly resolved: z.ZodObject<{
        employeeId: z.ZodString;
        engine: z.ZodString;
        model: z.ZodOptional<z.ZodString>;
        effort: z.ZodOptional<z.ZodEnum<{
            low: "low";
            medium: "medium";
            high: "high";
            xhigh: "xhigh";
        }>>;
        retry: z.ZodObject<{
            attempts: z.ZodNumber;
            delaySeconds: z.ZodNumber;
            backoff: z.ZodEnum<{
                fixed: "fixed";
                exponential: "exponential";
            }>;
        }, z.core.$strict>;
        timeoutMinutes: z.ZodOptional<z.ZodNumber>;
        continuedFrom: z.ZodOptional<z.ZodObject<{
            sessionId: z.ZodString;
            engineSessionId: z.ZodString;
        }, z.core.$strict>>;
        substitutedFrom: z.ZodOptional<z.ZodObject<{
            engine: z.ZodString;
            reason: z.ZodString;
        }, z.core.$strict>>;
    }, z.core.$strict>;
    readonly approval: z.ZodObject<{
        runId: z.ZodString;
        nodeId: z.ZodString;
        status: z.ZodEnum<{
            pending: "pending";
            approved: "approved";
            rejected: "rejected";
        }>;
        requestedAt: z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
        approverRef: z.ZodOptional<z.ZodString>;
        decidedAt: z.ZodOptional<z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>>;
        decidedBy: z.ZodOptional<z.ZodString>;
        decision: z.ZodOptional<z.ZodEnum<{
            reject: "reject";
            approve: "approve";
        }>>;
        reason: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>;
};
export declare function validateMutationValue(kind: keyof typeof mutationSchemas, value: unknown): void;
export interface RunRow {
    id: unknown;
    workflow_id: unknown;
    workflow_title: unknown;
    definition_revision: unknown;
    definition_json: unknown;
    input_json: unknown;
    trigger_json: unknown;
    status: unknown;
    revision: unknown;
    idempotency_key: unknown;
    invocation_session_id: unknown;
    cancel_requested_at: unknown;
    started_at: unknown;
    ended_at: unknown;
    error_json: unknown;
}
interface NodeRow {
    run_id: unknown;
    node_id: unknown;
    node_type: unknown;
    status: unknown;
    activated: unknown;
    resolved_config_json: unknown;
    input_json: unknown;
    output_json: unknown;
    error_json: unknown;
    resume_at: unknown;
    started_at: unknown;
    ended_at: unknown;
}
export interface AttemptRow {
    run_id: unknown;
    node_id: unknown;
    attempt: unknown;
    session_id: unknown;
    status: unknown;
    resolved_config_json: unknown;
    input_json: unknown;
    output_json: unknown;
    error_json: unknown;
    started_at: unknown;
    ended_at: unknown;
    reminders_sent: unknown;
    stop_nudges_sent: unknown;
    next_reminder_at: unknown;
    extensions: unknown;
    last_extension_reason: unknown;
    pending_output_error: unknown;
    last_processed_turn: unknown;
    prompt_text: unknown;
}
interface ApprovalRow {
    run_id: unknown;
    node_id: unknown;
    status: unknown;
    requested_at: unknown;
    approver_ref: unknown;
    decided_at: unknown;
    decided_by: unknown;
    decision: unknown;
    reason: unknown;
}
export interface NormalizedRunListQuery {
    limit: number;
    cursor?: {
        startedAt: string;
        id: string;
    };
    status?: string;
    triggerKind?: string;
    startedFrom?: string;
    startedTo?: string;
    text?: string;
}
export declare function decodeRun(row: RunRow): WorkflowRunRecord;
export declare function decodeNode(row: NodeRow): WorkflowNodeRunRecord;
export declare function decodeAttempt(row: AttemptRow): WorkflowAttemptRecord;
export declare function decodeApproval(row: ApprovalRow): WorkflowApprovalRecord;
export declare function readRun(db: WorkflowSqliteConnection, runId: string): WorkflowRunRecord | null;
export declare function readNode(db: WorkflowSqliteConnection, runId: string, nodeId: string): WorkflowNodeRunRecord | null;
export declare function readRunByIdempotency(db: WorkflowSqliteConnection, workflowId: string, key: string): WorkflowRunRecord | null;
export declare function readWorkflowCallByIdempotency(db: WorkflowSqliteConnection, key: string): WorkflowRunRecord | null;
export declare function equivalentRun(run: WorkflowRunRecord, input: Record<string, JsonValue>, trigger: WorkflowRunRecord['trigger'], invocation?: string): boolean;
export declare function insertRun(db: WorkflowSqliteConnection, run: WorkflowRunRecord): void;
export declare function readRunDetail(db: WorkflowSqliteConnection, workflowId: string, runId: string): WorkflowRunDetail | null;
export declare function readRunsByCaller(db: WorkflowSqliteConnection, parentRunId: string, nodeId: string): WorkflowChildRunSummary[];
export declare function listRunSummaries(db: WorkflowSqliteConnection, workflowId: string, query: NormalizedRunListQuery): WorkflowRunSummary[];
export declare function readAttempt(db: WorkflowSqliteConnection, runId: string, nodeId: string, attempt: number): WorkflowAttemptRecord | null;
export declare function readAttempts(db: WorkflowSqliteConnection, runId: string, nodeId: string): WorkflowAttemptRecord[];
export declare function readAttemptBySession(db: WorkflowSqliteConnection, sessionId: string): WorkflowAttemptRecord | null;
export declare function readAttemptByRetryKey(db: WorkflowSqliteConnection, runId: string, key: string): WorkflowAttemptRecord | null;
export declare function readDueReminders(db: WorkflowSqliteConnection, now: string, limit: number): WorkflowAttemptRecord[];
export declare function readNextDueReminder(db: WorkflowSqliteConnection): {
    runId: string;
    nodeId: string;
    attempt: number;
    nextReminderAt: string;
} | null;
export declare function readNextDueTimeout(db: WorkflowSqliteConnection): string | null;
export declare function readRecoverableRuns(db: WorkflowSqliteConnection): WorkflowRunRecord[];
export declare function readDueWaits(db: WorkflowSqliteConnection, now: string, limit: number): WorkflowNodeRunRecord[];
export declare function readNextDueWait(db: WorkflowSqliteConnection): WorkflowNodeRunRecord | null;
export declare function jsonColumn(value: JsonValue | WorkflowNodeOutput | WorkflowError | ResolvedEmployeeConfig | undefined): string | null;
export {};
//# sourceMappingURL=repository-runs.d.ts.map