import type { ExpiredRunLeaseCandidatePage, RecoverExpiredRunLeasesResult, RecoveredLeaseRunPage } from "../store.js";
import { Store } from "../store.js";
import type { PoolQueryClient } from "../../generated/storage-kit/query.js";
import type { LoopStorageContract, LoopStorageMethodName } from "./contract.js";
import { type LoopMutationEnvelope, type LoopMutationLookupCaps, type LoopMutationResult, type OperationAuthorityBinding } from "../operation-contract.js";
type M<K extends LoopStorageMethodName> = Store[K] extends (...a: infer A) => infer R ? {
    args: A;
    result: R;
} : never;
export interface TenantStorageContext {
    tenantId: string;
    principalId: string;
    requestId: string;
}
export declare class PostgresLoopStorage implements LoopStorageContract {
    readonly backend = "postgresql";
    readonly supportsRemoteRunners = true;
    readonly tenantId: string;
    readonly principalId: string;
    readonly requestId: string;
    private readonly client;
    constructor(client: PoolQueryClient, context: TenantStorageContext, opts?: {
        contextAlreadyBound?: boolean;
    });
    close(): Promise<void>;
    private assertDaemonLeaseFence;
    private lockWorkflowRun;
    private loadLoop;
    private loadRun;
    private loadRunBySlot;
    private loadDaemonLease;
    private setWorkItemsForLoop;
    private setWorkItemsForWorkflowRun;
    private cascadeWorkItemsForLoopRun;
    private maybeArchiveGeneratedRouteWorkflow;
    createLoop(...args: M<"createLoop">["args"]): Promise<M<"createLoop">["result"]>;
    getLoop(...args: M<"getLoop">["args"]): Promise<M<"getLoop">["result"]>;
    findLoopByName(...args: M<"findLoopByName">["args"]): Promise<M<"findLoopByName">["result"]>;
    requireLoop(...args: M<"requireLoop">["args"]): Promise<M<"requireLoop">["result"]>;
    requireUniqueLoop(...args: M<"requireUniqueLoop">["args"]): Promise<M<"requireUniqueLoop">["result"]>;
    listLoops(...args: M<"listLoops">["args"]): Promise<M<"listLoops">["result"]>;
    dueLoops(...args: M<"dueLoops">["args"]): Promise<M<"dueLoops">["result"]>;
    updateLoop(...args: M<"updateLoop">["args"]): Promise<M<"updateLoop">["result"]>;
    mutateLoop(envelope: LoopMutationEnvelope, authority: OperationAuthorityBinding, opts?: {
        now?: Date;
        leaseMs?: number;
    }): Promise<LoopMutationResult>;
    getLoopMutationResult(authority: OperationAuthorityBinding, operationId: string, stepId: string, caps?: LoopMutationLookupCaps): Promise<LoopMutationResult | undefined>;
    advanceLoopIfCurrent(...args: M<"advanceLoopIfCurrent">["args"]): Promise<M<"advanceLoopIfCurrent">["result"]>;
    tripCircuitBreakerIfCurrent(...args: M<"tripCircuitBreakerIfCurrent">["args"]): Promise<M<"tripCircuitBreakerIfCurrent">["result"]>;
    expireLoopIfCurrent(...args: M<"expireLoopIfCurrent">["args"]): Promise<M<"expireLoopIfCurrent">["result"]>;
    renameLoop(...args: M<"renameLoop">["args"]): Promise<M<"renameLoop">["result"]>;
    archiveLoop(...args: M<"archiveLoop">["args"]): Promise<M<"archiveLoop">["result"]>;
    unarchiveLoop(...args: M<"unarchiveLoop">["args"]): Promise<M<"unarchiveLoop">["result"]>;
    deleteLoop(...args: M<"deleteLoop">["args"]): Promise<M<"deleteLoop">["result"]>;
    private requireLoopIn;
    private requireUniqueLoopIn;
    private requireArchiveMutationLoopIn;
    countLoops(...args: M<"countLoops">["args"]): Promise<M<"countLoops">["result"]>;
    upsertMigrationWorkflow(...args: M<"upsertMigrationWorkflow">["args"]): Promise<M<"upsertMigrationWorkflow">["result"]>;
    upsertMigrationLoop(...args: M<"upsertMigrationLoop">["args"]): Promise<M<"upsertMigrationLoop">["result"]>;
    upsertMigrationRun(...args: M<"upsertMigrationRun">["args"]): Promise<M<"upsertMigrationRun">["result"]>;
    createSkippedRun(...args: M<"createSkippedRun">["args"]): Promise<M<"createSkippedRun">["result"]>;
    getRun(...args: M<"getRun">["args"]): Promise<M<"getRun">["result"]>;
    getRunBySlot(...args: M<"getRunBySlot">["args"]): Promise<M<"getRunBySlot">["result"]>;
    nextRetryableRun(...args: M<"nextRetryableRun">["args"]): Promise<M<"nextRetryableRun">["result"]>;
    /**
     * Remote-safe liveness proxy shared by claimRun and
     * recoverExpiredRunLeasesDetailed. The Postgres backend cannot inspect the
     * original runner's process (it may be a different machine), so a run whose
     * LEASE lapsed within the expired-run grace window — MAX x GRACE (10 min),
     * the same post-expiry budget the sqlite path allows via its live-process
     * deferral ceiling — is treated as possibly-still-executing: steal and
     * abandon are both deferred until the window passes, bounding the
     * duplicate-execution window to the original runner's 3-heartbeat abort
     * (~1.5 lease periods) instead of stealing the instant the lease lapses.
     *
     * The anchor is lease expiry, deliberately not process start: a run executing
     * longer than the grace window at the moment its lease lapses (a transient
     * heartbeat outage, a machine suspend, a long-running loop) would otherwise
     * receive zero post-expiry protection and have its slot stolen mid-execution
     * while the original runner keeps running. Anchoring on the recorded process
     * start consumes the whole budget up front and defeats the fix for exactly
     * those runs. Time-bounded by construction, so a genuinely dead runner is
     * still reclaimed once the window passes — the "expired lease is reclaimable"
     * fence stays intact without a defer counter column.
     */
    private static expiredLeaseWithinGrace;
    /**
     * Claim a specific loop slot for a runner.
     *
     * Divergence from the sqlite Store (documented, not accidental): the sqlite
     * path also consults LOCAL process liveness (`isRecordedProcessAlive`,
     * `hasLiveWorkflowStepProcesses`) before stealing an expired-lease run,
     * because the daemon and the run's child process share a host. On the
     * Postgres/remote backend the claiming runner may be a different machine than
     * the one that holds the (possibly still-live) process, so local pid checks
     * are meaningless. Ownership here is governed by lease expiry plus a bounded
     * grace window: an expired lease whose lapse is older than the expired-run
     * grace window is reclaimable, and an expired lease whose lapse is still
     * inside that window is deferred (see
     * {@link PostgresLoopStorage.expiredLeaseWithinGrace}) so a runner hit by a
     * transient heartbeat outage cannot have its slot stolen mid-execution. The
     * lease/heartbeat contract (plus `FOR UPDATE` row locks) is the remote
     * correctness boundary.
     */
    claimRun(...args: M<"claimRun">["args"]): Promise<M<"claimRun">["result"]>;
    finalizeRun(...args: M<"finalizeRun">["args"]): Promise<M<"finalizeRun">["result"]>;
    heartbeatRunLease(...args: M<"heartbeatRunLease">["args"]): Promise<M<"heartbeatRunLease">["result"]>;
    recordRunProcess(...args: M<"recordRunProcess">["args"]): Promise<M<"recordRunProcess">["result"]>;
    listRuns(...args: M<"listRuns">["args"]): Promise<M<"listRuns">["result"]>;
    listRecoveredLeaseRunsPage(...args: M<"listRecoveredLeaseRunsPage">["args"]): Promise<RecoveredLeaseRunPage>;
    writeRunReceipt(...args: M<"writeRunReceipt">["args"]): Promise<M<"writeRunReceipt">["result"]>;
    getRunReceipt(...args: M<"getRunReceipt">["args"]): Promise<M<"getRunReceipt">["result"]>;
    listRunReceipts(...args: M<"listRunReceipts">["args"]): Promise<M<"listRunReceipts">["result"]>;
    countRuns(...args: M<"countRuns">["args"]): Promise<M<"countRuns">["result"]>;
    recoverExpiredRunLeases(...args: M<"recoverExpiredRunLeases">["args"]): Promise<M<"recoverExpiredRunLeases">["result"]>;
    listExpiredRunLeaseCandidates(expiredBefore?: Date, opts?: {
        limit?: number;
    }): Promise<ExpiredRunLeaseCandidatePage>;
    /**
     * Recover expired run leases. Divergence from sqlite (documented): the remote
     * backend cannot inspect local process liveness, so an expired lease is
     * abandoned unless its lapse is still inside the expired-run grace window
     * (`expiredLeaseWithinGrace`) — such runs are deferred, not abandoned, because
     * the original runner may still be executing on another machine. Abandoning
     * within the window would let the next claim pass mint a new attempt while the
     * original runner is live. The window is time-bounded (MAX x GRACE = 10 min),
     * so a genuinely dead runner is still abandoned once it passes.
     */
    recoverExpiredRunLeasesDetailed(...args: M<"recoverExpiredRunLeasesDetailed">["args"]): Promise<RecoverExpiredRunLeasesResult>;
    pruneHistory(...args: M<"pruneHistory">["args"]): Promise<M<"pruneHistory">["result"]>;
    acquireDaemonLease(...args: M<"acquireDaemonLease">["args"]): Promise<M<"acquireDaemonLease">["result"]>;
    heartbeatDaemonLease(...args: M<"heartbeatDaemonLease">["args"]): Promise<M<"heartbeatDaemonLease">["result"]>;
    releaseDaemonLease(...args: M<"releaseDaemonLease">["args"]): Promise<M<"releaseDaemonLease">["result"]>;
    getDaemonLease(...args: M<"getDaemonLease">["args"]): Promise<M<"getDaemonLease">["result"]>;
    private loadWorkflow;
    getWorkflow(...args: M<"getWorkflow">["args"]): Promise<M<"getWorkflow">["result"]>;
    listWorkflows(...args: M<"listWorkflows">["args"]): Promise<M<"listWorkflows">["result"]>;
    countWorkflows(...args: M<"countWorkflows">["args"]): Promise<M<"countWorkflows">["result"]>;
    getWorkflowInvocation(...args: M<"getWorkflowInvocation">["args"]): Promise<M<"getWorkflowInvocation">["result"]>;
    listWorkflowInvocations(...args: M<"listWorkflowInvocations">["args"]): Promise<M<"listWorkflowInvocations">["result"]>;
    getWorkflowWorkItem(...args: M<"getWorkflowWorkItem">["args"]): Promise<M<"getWorkflowWorkItem">["result"]>;
    listWorkflowWorkItems(...args: M<"listWorkflowWorkItems">["args"]): Promise<M<"listWorkflowWorkItems">["result"]>;
    countActiveWorkflowWorkItems(...args: M<"countActiveWorkflowWorkItems">["args"]): Promise<M<"countActiveWorkflowWorkItems">["result"]>;
    getWorkflowRun(...args: M<"getWorkflowRun">["args"]): Promise<M<"getWorkflowRun">["result"]>;
    listWorkflowRuns(...args: M<"listWorkflowRuns">["args"]): Promise<M<"listWorkflowRuns">["result"]>;
    listWorkflowStepRuns(...args: M<"listWorkflowStepRuns">["args"]): Promise<M<"listWorkflowStepRuns">["result"]>;
    getWorkflowStepRun(...args: M<"getWorkflowStepRun">["args"]): Promise<M<"getWorkflowStepRun">["result"]>;
    listWorkflowEvents(...args: M<"listWorkflowEvents">["args"]): Promise<M<"listWorkflowEvents">["result"]>;
    getGoal(...args: M<"getGoal">["args"]): Promise<M<"getGoal">["result"]>;
    listGoals(...args: M<"listGoals">["args"]): Promise<M<"listGoals">["result"]>;
    listGoalPlanNodes(...args: M<"listGoalPlanNodes">["args"]): Promise<M<"listGoalPlanNodes">["result"]>;
    listGoalRuns(...args: M<"listGoalRuns">["args"]): Promise<M<"listGoalRuns">["result"]>;
    createWorkflow(...args: M<"createWorkflow">["args"]): Promise<M<"createWorkflow">["result"]>;
    archiveWorkflow(...args: M<"archiveWorkflow">["args"]): Promise<M<"archiveWorkflow">["result"]>;
    createWorkflowInvocation(...args: M<"createWorkflowInvocation">["args"]): Promise<M<"createWorkflowInvocation">["result"]>;
    upsertWorkflowWorkItem(...args: M<"upsertWorkflowWorkItem">["args"]): Promise<M<"upsertWorkflowWorkItem">["result"]>;
    admitWorkflowWorkItem(...args: M<"admitWorkflowWorkItem">["args"]): Promise<M<"admitWorkflowWorkItem">["result"]>;
    createGoal(...args: M<"createGoal">["args"]): Promise<M<"createGoal">["result"]>;
    requireGoal(...args: M<"requireGoal">["args"]): Promise<M<"requireGoal">["result"]>;
    findGoalByContext(...args: M<"findGoalByContext">["args"]): Promise<M<"findGoalByContext">["result"]>;
    private mapGoalPlanNode;
    createGoalPlanNodes(...args: M<"createGoalPlanNodes">["args"]): Promise<M<"createGoalPlanNodes">["result"]>;
    updateGoalStatus(...args: M<"updateGoalStatus">["args"]): Promise<M<"updateGoalStatus">["result"]>;
    updateGoalPlanNode(...args: M<"updateGoalPlanNode">["args"]): Promise<M<"updateGoalPlanNode">["result"]>;
    recordGoalEvent(...args: M<"recordGoalEvent">["args"]): Promise<M<"recordGoalEvent">["result"]>;
    requireWorkflow(...args: M<"requireWorkflow">["args"]): Promise<M<"requireWorkflow">["result"]>;
    createWorkflowRun(...args: M<"createWorkflowRun">["args"]): Promise<M<"createWorkflowRun">["result"]>;
    requireWorkflowRun(...args: M<"requireWorkflowRun">["args"]): Promise<M<"requireWorkflowRun">["result"]>;
    isWorkflowRunTerminal(...args: M<"isWorkflowRunTerminal">["args"]): Promise<M<"isWorkflowRunTerminal">["result"]>;
    startWorkflowStepRun(...args: M<"startWorkflowStepRun">["args"]): Promise<M<"startWorkflowStepRun">["result"]>;
    markWorkflowStepPid(...args: M<"markWorkflowStepPid">["args"]): Promise<M<"markWorkflowStepPid">["result"]>;
    recordWorkflowStepProgress(...args: M<"recordWorkflowStepProgress">["args"]): Promise<M<"recordWorkflowStepProgress">["result"]>;
    recoverWorkflowRun(...args: M<"recoverWorkflowRun">["args"]): Promise<M<"recoverWorkflowRun">["result"]>;
    finalizeWorkflowStepRun(...args: M<"finalizeWorkflowStepRun">["args"]): Promise<M<"finalizeWorkflowStepRun">["result"]>;
    skipWorkflowStepRun(...args: M<"skipWorkflowStepRun">["args"]): Promise<M<"skipWorkflowStepRun">["result"]>;
    private setWorkflowWorkItemsForWorkflowRun;
    private demoteNonProductiveWorkItems;
    finalizeWorkflowRun(...args: M<"finalizeWorkflowRun">["args"]): Promise<M<"finalizeWorkflowRun">["result"]>;
    private appendWorkflowEventWithClient;
    appendWorkflowEvent(...args: M<"appendWorkflowEvent">["args"]): Promise<M<"appendWorkflowEvent">["result"]>;
}
export declare function createPostgresLoopStorage(client: PoolQueryClient, context: TenantStorageContext, opts?: {
    contextAlreadyBound?: boolean;
}): PostgresLoopStorage;
export {};