import type { ApprovalDecision, Checkpoint, RunFilter, WorkflowQueueItem, WorkflowRun, WorkflowStatus } from "../../types.js";
import { type PersistedPendingApproval, type WorkflowBackend, type WorkflowRunObservation, type WorkflowRunStateSnapshot, type WorkflowRunUpdate } from "../types.js";
export type { RedisAdapter } from "../../../platform/adapters/redis/index.js";
export type { RedisBackendConfig } from "./types.js";
import type { RedisBackendConfig } from "./types.js";
/** Implement redis backend. */
export declare class RedisBackend implements WorkflowBackend {
    /** The run-update scripts merge context and node-state maps by key. */
    readonly supportsRunPatchKeyMerge = true;
    private client;
    private connectionPromise;
    private config;
    private initialized;
    /** Per-run lock tokens for ownership-checked release/extend (Redlock pattern). */
    private lockValues;
    /**
     * Stream message IDs this consumer has read but not yet acknowledged, keyed
     * by runId. Populated in {@link dequeue} and consumed by {@link acknowledge}
     * so we can XACK the exact PEL entry (a runId may map to more than one
     * pending message if it was requeued and re-read before acking).
     */
    private pendingMessageIds;
    private runObservationClosers;
    constructor(config?: RedisBackendConfig);
    private storagePrefix;
    private runKey;
    private checkpointsKey;
    private approvalsKey;
    private runObservationKey;
    private runObservationApprovalsKey;
    private statusIndexKey;
    private workflowIndexKey;
    /**
     * Set of every run id. Maintained on create/delete so unfiltered listRuns and
     * countRuns can enumerate runs via SMEMBERS instead of a keyspace-wide
     * KEYS scan (which blocks the Redis event loop).
     */
    private allRunsIndexKey;
    /** Enumerate only runs explicitly indexed in the current storage schema. */
    private enumerateAllRunIds;
    private lockKey;
    private claimKey;
    private serializeRun;
    private serializeRunPatch;
    private serializeCheckpoint;
    private serializeApproval;
    private appendIfStatusAndWorker;
    private deserializeRun;
    private ensureClient;
    private createConnection;
    initialize(): Promise<void>;
    createRun(run: WorkflowRun): Promise<void>;
    getRun(runId: string): Promise<WorkflowRun | null>;
    updateRun(runId: string, patch: WorkflowRunUpdate): Promise<void>;
    updateRunIfStatus(runId: string, expectedStatuses: WorkflowStatus[], patch: WorkflowRunUpdate): Promise<boolean>;
    updateRunIfStatusAndWorker(runId: string, expectedStatuses: WorkflowStatus[], expectedWorkerId: string, patch: WorkflowRunUpdate): Promise<boolean>;
    /**
     * Replace context and node-state maps with a snapshot, only while status
     * and (optionally) worker ownership match. Same atomic script as the
     * conditional patch, with the replace-maps flag set: checkpoint restore
     * must drop keys written after the snapshot, which the merge retains.
     */
    restoreRunStateIfStatus(runId: string, expectedStatuses: WorkflowStatus[], snapshot: WorkflowRunStateSnapshot, expectedWorkerId?: string): Promise<boolean>;
    private updateRunConditionally;
    deleteRun(runId: string): Promise<void>;
    listRuns(filter: RunFilter): Promise<WorkflowRun[]>;
    countRuns(filter: RunFilter): Promise<number>;
    saveCheckpoint(runId: string, checkpoint: Checkpoint): Promise<void>;
    saveCheckpointIfStatusAndWorker(storageRunId: string, ownershipRunId: string, expectedStatuses: WorkflowStatus[], expectedWorkerId: string, checkpoint: Checkpoint): Promise<boolean>;
    getLatestCheckpoint(runId: string): Promise<Checkpoint | null>;
    getCheckpoints(runId: string): Promise<Checkpoint[]>;
    savePendingApproval(runId: string, approval: PersistedPendingApproval): Promise<void>;
    savePendingApprovalIfAbsent(runId: string, approval: PersistedPendingApproval): Promise<boolean>;
    private savePendingApprovalRecord;
    private approvalListFullError;
    savePendingApprovalIfStatusAndWorker(runId: string, expectedStatuses: WorkflowStatus[], expectedWorkerId: string, approval: PersistedPendingApproval): Promise<boolean>;
    private parseApproval;
    private getApprovals;
    getPendingApprovals(runId: string): Promise<PersistedPendingApproval[]>;
    getPendingApproval(runId: string, approvalId: string): Promise<PersistedPendingApproval | null>;
    updatePendingApproval(runId: string, approvalId: string, patch: Partial<PersistedPendingApproval>): Promise<void>;
    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;
    }>>;
    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>;
    openRunObservation(runId: string, options?: {
        signal?: AbortSignal;
    }): Promise<WorkflowRunObservation | null>;
    healthCheck(): Promise<boolean>;
    destroy(): Promise<void>;
}
//# sourceMappingURL=index.d.ts.map