import type { ApprovalDecision, Checkpoint, RunFilter, WorkflowQueueItem, WorkflowRun } from "../types.js";
import { type BackendConfig, type PersistedPendingApproval, type PersistedPendingEventWait, type RunEventDeliveryClaim, type RunEventEnvelope, type WorkflowBackend, type WorkflowRunObservation, type WorkflowRunStateSnapshot, type WorkflowRunUpdate } from "./types.js";
/**
 * Memory backend configuration
 */
interface MemoryBackendConfig extends BackendConfig {
    /** Maximum queue size (default: 10000) */
    maxQueueSize?: number;
}
/** Implement memory backend. */
export declare class MemoryBackend implements WorkflowBackend {
    /** updateRun patches merge context and node-state maps by key. */
    readonly supportsRunPatchKeyMerge = true;
    private runs;
    private checkpoints;
    private approvals;
    private eventWaits;
    private runEvents;
    private nextRunEventPublicationOrder;
    private runEventClaims;
    private queue;
    private locks;
    private stalledClaims;
    private runRevisions;
    private runObservers;
    private config;
    constructor(config?: MemoryBackendConfig);
    createRun(run: WorkflowRun): Promise<void>;
    getRun(runId: string): Promise<WorkflowRun | null>;
    updateRun(runId: string, patch: WorkflowRunUpdate): Promise<void>;
    updateRunIfStatus(runId: string, expectedStatuses: WorkflowRun["status"][], patch: Partial<WorkflowRun>): Promise<boolean>;
    updateRunIfStatusAndWorker(runId: string, expectedStatuses: WorkflowRun["status"][], expectedWorkerId: string, patch: Partial<WorkflowRun>): Promise<boolean>;
    restoreRunStateIfStatus(runId: string, expectedStatuses: WorkflowRun["status"][], snapshot: WorkflowRunStateSnapshot, expectedWorkerId?: string): Promise<boolean>;
    deleteRun(runId: string): Promise<void>;
    openRunObservation(runId: string, options?: {
        signal?: AbortSignal;
    }): Promise<WorkflowRunObservation | null>;
    private publishRunObservation;
    private closeRunObservers;
    listRuns(filter: RunFilter): Promise<WorkflowRun[]>;
    countRuns(filter: RunFilter): Promise<number>;
    saveCheckpoint(runId: string, checkpoint: Checkpoint): Promise<void>;
    saveCheckpointIfStatusAndWorker(storageRunId: string, ownershipRunId: string, expectedStatuses: WorkflowRun["status"][], expectedWorkerId: string, checkpoint: Checkpoint): Promise<boolean>;
    getLatestCheckpoint(runId: string): Promise<Checkpoint | null>;
    getCheckpoints(runId: string): Promise<Checkpoint[]>;
    deleteCheckpoint(runId: string, checkpointId: string): Promise<void>;
    deleteCheckpoints(runId: string, checkpointIds: string[]): Promise<void>;
    savePendingApproval(runId: string, approval: PersistedPendingApproval): Promise<void>;
    savePendingApprovalIfAbsent(runId: string, approval: PersistedPendingApproval): Promise<boolean>;
    savePendingApprovalIfStatusAndWorker(runId: string, expectedStatuses: WorkflowRun["status"][], expectedWorkerId: string, approval: PersistedPendingApproval): Promise<boolean>;
    updatePendingApproval(runId: string, approvalId: string, patch: Partial<PersistedPendingApproval>): Promise<void>;
    getPendingApprovals(runId: string): Promise<PersistedPendingApproval[]>;
    getPendingApproval(runId: string, approvalId: string): Promise<PersistedPendingApproval | null>;
    updateApproval(runId: string, approvalId: string, decision: ApprovalDecision): Promise<boolean>;
    listApprovalDecisionClaims(runId?: string): Promise<Array<{
        runId: string;
        approval: PersistedPendingApproval;
    }>>;
    reserveApprovalDecisionClaim(runId: string, approvalId: string, recoveryClaimId: string, claimedAt: Date, staleBefore: Date): Promise<boolean>;
    releaseApprovalDecisionClaim(runId: string, approvalId: string, recoveryClaimId: string): Promise<void>;
    finalizeApprovalDecision(runId: string, approvalId: string, recoveryClaimId?: string): Promise<void>;
    listPendingApprovals(filter?: {
        workflowId?: string;
        approver?: string;
        status?: "pending" | "expired";
    }): Promise<Array<{
        runId: string;
        approval: PersistedPendingApproval;
    }>>;
    savePendingEventWait(runId: string, wait: PersistedPendingEventWait): Promise<void>;
    savePendingEventWaitIfStatusAndWorker(runId: string, expectedStatuses: WorkflowRun["status"][], expectedWorkerId: string, wait: PersistedPendingEventWait): Promise<boolean>;
    getPendingEventWaits(runId: string): Promise<PersistedPendingEventWait[]>;
    listPendingEventWaits(): Promise<Array<{
        runId: string;
        wait: PersistedPendingEventWait;
    }>>;
    resolvePendingEventWait(runId: string, waitId: string, status: "delivered" | "expired" | "cancelled"): Promise<boolean>;
    restorePendingEventWait(runId: string, waitId: string): Promise<boolean>;
    listTimedEventWaitClaims(runId?: string): Promise<PersistedPendingEventWait[]>;
    reserveTimedEventWaitClaim(runId: string, waitId: string, claimedAt: Date, staleBefore: Date): Promise<boolean>;
    finalizeTimedEventWaitClaim(runId: string, waitId: string): Promise<void>;
    appendRunEvent(runId: string, event: RunEventEnvelope): Promise<void>;
    removeRunEvent(runId: string, eventId: string): Promise<boolean>;
    /**
     * Drop the oldest mailboxes that no wait can ever claim from again, once the
     * mailbox count is over its bound. Publishing to a run id before the run
     * exists is supported, so a caller publishing to ids that never become runs
     * would otherwise accumulate mailboxes forever, and a run that reached a
     * completed or cancelled will never park on anything again, so its buffered
     * events are equally unclaimable. Failed runs remain retryable and retain
     * their mail just like active runs.
     */
    private evictOrphanRunEventMailboxes;
    takeRunEvent(runId: string, eventName: string): Promise<RunEventEnvelope | null>;
    peekRunEvent(runId: string, eventName: string): Promise<RunEventEnvelope | null>;
    /** Claim the oldest matching event and its pending wait as one synchronous mutation. */
    claimRunEventForWait(runId: string, waitId: string, eventName: string, publishedBefore?: Date): Promise<RunEventEnvelope | null>;
    listRunEventDeliveryClaims(runId?: string): Promise<RunEventDeliveryClaim[]>;
    reserveRunEventDeliveryClaim(runId: string, waitId: string, eventId: string, claimedAt: Date, staleBefore: Date): Promise<boolean>;
    restoreRunEvent(runId: string, event: RunEventEnvelope): Promise<void>;
    /**
     * Undo a claimed-but-undelivered delivery: the wait returns to pending and
     * the event to its publication-order mailbox position as one step.
     *
     * Every mutation is one synchronous in-memory state transition, so callers
     * cannot observe the restored wait before its event returns to the mailbox.
     * A durable backend must implement this as a single atomic operation (a
     * transaction or script) instead.
     */
    restoreRunEventDelivery(runId: string, waitId: string, event: RunEventEnvelope): Promise<boolean>;
    finalizeRunEventDelivery(runId: string, eventId: string, delivered: boolean): Promise<void>;
    hasRunEventDeliveryReceipt(runId: string, eventId: string): Promise<boolean>;
    private persistRunEventDeliveryReceipts;
    private releaseRunEventClaim;
    private deleteEmptyRunEventMailbox;
    enqueue(job: WorkflowQueueItem): Promise<void>;
    dequeue(): Promise<WorkflowQueueItem | null>;
    acknowledge(runId: string): Promise<void>;
    nack(runId: string): Promise<void>;
    acquireLock(runId: string, duration: number): Promise<string | null>;
    releaseLock(runId: string, lockId?: string): Promise<void>;
    extendLock(runId: string, duration: number, lockId?: string): Promise<boolean>;
    isLocked(runId: string): Promise<boolean>;
    findStalledRuns(stalledThreshold: number): Promise<WorkflowRun[]>;
    claimStalledRun(runId: string, workerId: string, stalledThreshold: number): Promise<boolean>;
    initialize(): Promise<void>;
    healthCheck(): Promise<boolean>;
    destroy(): Promise<void>;
    getStats(): {
        runs: number;
        checkpoints: number;
        approvals: number;
        queueLength: number;
        locks: number;
    };
    clear(): Promise<void>;
}
export {};
//# sourceMappingURL=memory.d.ts.map