import type { Automation, AutomationDeps, AutomationEvent, AutomationMetrics, AutomationProductEventRun, AutomationRun, AutomationRunEvent } from '../domain/types.js';
import { type CreateAutomationInput, type UpdateAutomationInput } from '../domain/validation.js';
export declare class AutomationAlreadyRunningError extends Error {
    readonly automationId: string;
    readonly runningRunId?: string;
    constructor(automationId: string, runningRunId?: string);
}
export declare class AutomationAlreadyExistsError extends Error {
    readonly automationId: string;
    constructor(automationId: string);
}
export declare class AutomationService {
    private readonly executor;
    private readonly eventDispatcher;
    private readonly deliveryRouter;
    private timer;
    private stopped;
    private runningScheduler;
    private deps;
    private maxConcurrentRuns;
    private readonly activeRuns;
    private readonly activeRunTasks;
    private readonly heartbeatTimers;
    private readonly leaseOwner;
    setDeps(deps: AutomationDeps): void;
    initialize(options?: {
        maxConcurrentRuns?: number;
    }): Promise<void>;
    stop(): Promise<void>;
    create(input: CreateAutomationInput): Promise<Automation>;
    /** SQLite-only creation; scheduling starts after the caller commits. */
    createAtomically(input: CreateAutomationInput): Automation;
    private applyCreate;
    list(options?: {
        projectId?: string;
    }): Promise<Automation[]>;
    get(id: string): Promise<Automation | null>;
    update(id: string, patch: UpdateAutomationInput): Promise<Automation | null>;
    /** SQLite-only mutation; callers must refresh scheduling after their outer transaction commits. */
    updateAtomically(id: string, patch: UpdateAutomationInput): Automation | null;
    refreshSchedule(): void;
    private applyUpdate;
    remove(id: string): Promise<boolean>;
    /** Persist deletion and cancellation intent together; never abort within a transaction. */
    removeAtomically(id: string): {
        removed: boolean;
        automation?: Automation;
        cancelRunId?: string;
    };
    finishRemoval(cancelRunId?: string): void;
    pause(id: string): Promise<Automation | null>;
    resume(id: string): Promise<Automation | null>;
    runNow(id: string): Promise<AutomationRun>;
    rerunFromRun(runId: string): Promise<AutomationRun>;
    ingestEvent(event: AutomationEvent, targetAutomationIds?: string[]): import("../index.js").AutomationEventIngestResult;
    dispatchEvents(): Promise<number>;
    replayEventAtomically(eventId: string): boolean;
    retryResultDeliveryAtomically(runId: string, destinationKey: string): boolean;
    dispatchRecoveryWork(): void;
    listEventRecords(input?: {
        type?: string;
        source?: string;
        limit?: number;
    }): import("../index.js").AutomationEventRecord[];
    listResultDeliveries(input?: {
        runId?: string;
        status?: 'pending' | 'delivering' | 'retrying' | 'delivered' | 'dead_letter';
        limit?: number;
    }): import("../index.js").AutomationResultDeliveryRecord[];
    private ingestTargetedTrigger;
    queueTriggerAtomically(automationId: string, input: AutomationEvent, executionEvent?: AutomationEvent): AutomationRun;
    queueRunAtomically(id: string, opts?: {
        manual: boolean;
        event?: AutomationEvent;
    }): AutomationRun;
    /** Claim before invoking external work; replays never restart running or completed runs. */
    dispatchQueuedRun(runId: string): void;
    availableRunSlots(): number;
    listRuns(options?: {
        automationId?: string;
        projectId?: string;
        limit?: number;
    }): Promise<AutomationRun[]>;
    listRunsForProductEvent(options: {
        eventType: string;
        source?: string;
        payloadKey?: string;
        payloadValue?: string;
        limit?: number;
    }): Promise<AutomationProductEventRun[]>;
    getRun(runId: string): Promise<AutomationRun | null>;
    listRunEvents(runId: string): Promise<AutomationRunEvent[]>;
    markRunRead(runId: string): Promise<boolean>;
    markAllRunsRead(options?: {
        projectId?: string;
    }): Promise<number>;
    cancelRun(runId: string): Promise<boolean>;
    dispatchCancellation(runId: string): void;
    cancelRunAtomically(runId: string): {
        cancelled: boolean;
        confirmed: boolean;
    };
    getMetrics(): Promise<AutomationMetrics>;
    private recomputeNextRuns;
    private armTimer;
    private onTimer;
    private persistQueuedRun;
    private executeRun;
    private recoverInterruptedRuns;
    private waitForRetry;
    private appendRunEvent;
    private finishAutomationRun;
}