import type { BackpressureOptions } from "./backpressure.js";
import { type Task, type TaskStatus } from "./models.js";
import type { ListInput, PurgeInput, SubmitInput, TaskStore } from "./store/base.js";
import { type TaskDef } from "./task.js";
export type SubmitOptions = Omit<SubmitInput, "name" | "payload">;
export interface CallOptions extends SubmitOptions {
    waitTimeoutMs?: number;
    pollMs?: number;
}
/** Options this handle configures on the store it wraps, rather than the
 * store's own constructor arguments. */
export type ClientOptions = Partial<BackpressureOptions>;
/** API-side handle. Thin wrapper over a TaskStore + SDK-orchestrated wait/call. */
export declare class CairnQ {
    private readonly _store;
    constructor(_store: TaskStore, opts?: ClientOptions);
    static sqlite(path: string, opts?: {
        busyTimeoutMs?: number;
    } & ClientOptions): CairnQ;
    /** Multi-host backend. `dsn` is a libpq connection string; requires the
     * optional `pg` package. */
    static postgres(dsn: string, opts?: {
        max?: number;
    } & ClientOptions): CairnQ;
    get store(): TaskStore;
    connect(): Promise<void>;
    close(): Promise<void>;
    /** Enqueue a task. With `maxQueueDepth` configured this blocks while the
     * target queue is at its limit, and raises QueueFull if it stays there for
     * `maxQueueWaitMs` — see QueueDepthGate for why that bound is approximate
     * across several producers. */
    submit(name: string, payload?: unknown, opts?: SubmitOptions): Promise<Task>;
    submit<P, R>(task: TaskDef<P, R>, payload?: P, opts?: SubmitOptions): Promise<Task>;
    /** How many more tasks fit on `queue` under `maxDepth` — 0 once it is full.
     * The non-blocking read behind `maxQueueDepth`, for a producer that would
     * rather shed load or pick another queue than wait. Cheaper than `stats()`:
     * bounded at `maxDepth` index entries instead of aggregating the table. */
    queueDepth(queue: string, maxDepth: number): Promise<number>;
    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>;
    /** Delete terminal tasks that finished more than `olderThanMs` ago and return
     * their ids. Nothing else in CairnQ removes rows, so a long-lived database
     * needs this on a schedule. Each call is bounded by `limit` to keep the write
     * short; loop until it returns fewer than `limit`. */
    purge(input?: PurgeInput): Promise<string[]>;
    /** Task counts per queue, keyed by status and zero-filled across all statuses
     * — `(await stats()).default.queued` is the backlog of a queue. */
    stats(): Promise<Record<string, Record<TaskStatus, number>>>;
    wait(taskId: string, opts?: {
        timeoutMs?: number;
        pollMs?: number;
    }): Promise<Task>;
    /** submit + wait. Resolves with the result on success; rejects with
     * TaskFailed / TaskCanceled / TaskTimeout otherwise. Pass a TaskDef and the
     * resolved value is typed as its Result. */
    call(name: string, payload?: unknown, opts?: CallOptions): Promise<unknown>;
    call<P, R>(task: TaskDef<P, R>, payload?: P, opts?: CallOptions): Promise<R>;
}