import { type Task } from "../models.js";
import type { ListInput, SubmitInput, TaskStore } from "./base.js";
/**
 * Translate the protocol's named-parameter SQL (`:name`) into Postgres positional
 * placeholders (`$1`), collapsing each DISTINCT name to ONE slot — statements reuse
 * a name across CASE branches / IS NULL guards (e.g. list.sql). SQL comments are
 * stripped first so a `:name` mentioned in a header comment (e.g. "now + :lease_ms")
 * never leaks into the parameter list. Exported for unit testing.
 */
export declare function toPositional(sql: string, params: Record<string, unknown>): {
    text: string;
    values: unknown[];
};
/**
 * PostgresStore — asyncpg's TS counterpart: a `pg` Pool executing the shared
 * cairnq-protocol SQL (postgres dialect). Multi-host capable — unlike SQLite this
 * coordinates API and worker processes across machines through one database. Time
 * comes from the DB clock (now()), claim uses FOR UPDATE SKIP LOCKED, JSON columns
 * are jsonb (bound as JSON text, read back as objects by rowToTask's adaptive parse).
 */
export declare class PostgresStore implements TaskStore {
    private readonly dsn;
    private readonly opts;
    private pool;
    private connecting;
    private readonly statements;
    constructor(dsn: string, opts?: {
        max?: number;
    });
    connect(): Promise<void>;
    close(): Promise<void>;
    private ensure;
    private doConnect;
    private applyMigrations;
    private readProtocolVersion;
    protocolVersion(): Promise<number>;
    private run;
    private runOn;
    private tx;
    private ownedWrite;
    submit(input: SubmitInput): Promise<Task>;
    get(taskId: string): Promise<Task | null>;
    getByKey(key: string): Promise<Task | null>;
    list(input?: ListInput): Promise<Task[]>;
    cancel(taskId: string): Promise<Task | null>;
    cancelByKey(key: string): Promise<Task | null>;
    retry(taskId: string, opts?: {
        resetAttempt?: boolean;
    }): Promise<Task | null>;
    retryByKey(key: string, opts?: {
        resetAttempt?: boolean;
    }): Promise<Task | null>;
    claim(input: {
        queues: string[];
        workerId: string;
        leaseMs?: number;
        limit?: number;
    }): Promise<Task[]>;
    heartbeat(input: {
        taskId: string;
        workerId: string;
        leaseMs?: number;
    }): Promise<Task>;
    progress(input: {
        taskId: string;
        workerId: string;
        progress: number | null;
        message: string | null;
    }): Promise<Task>;
    succeed(input: {
        taskId: string;
        workerId: string;
        result: unknown;
    }): Promise<Task>;
    complete(input: {
        taskId: string;
        workerId: string;
        result: unknown;
    }): Promise<Task>;
    fail(input: {
        taskId: string;
        workerId: string;
        error: unknown;
        retryable?: boolean;
        delayMs?: number;
    }): Promise<Task>;
}