/**
 * Common durable execution persistence adapter. Concrete storage backends only implement atomic
 * insert/CAS/scan/lease primitives; these views supply the effect, approval, saga, and worker APIs.
 */
import type { ApprovalStore, DurableEffectStore, ReconciliationScanOptions, ReconciliationScanPage, SagaStore } from "./durable-execution.js";
import type { ReconciliationLease, ReconciliationLeaseStore } from "./reconciliation-worker.js";
export type DurableRecordKind = "effect" | "approval" | "saga";
export interface DurableRecordBackend {
    create(kind: DurableRecordKind, id: string, record: {
        readonly version: number;
        readonly state?: string;
        readonly updatedAt?: number;
    }): Promise<boolean>;
    get<T extends {
        readonly version: number;
    }>(kind: DurableRecordKind, id: string): Promise<T | undefined>;
    compareAndSet(kind: DurableRecordKind, id: string, expectedVersion: number, record: {
        readonly version: number;
        readonly state?: string;
        readonly updatedAt?: number;
    }): Promise<boolean>;
    scan<T extends {
        readonly state: string;
        readonly updatedAt: number;
    }>(kind: DurableRecordKind, input: ReconciliationScanOptions<string>): Promise<ReconciliationScanPage<T>>;
    acquireLease(input: {
        readonly name: string;
        readonly owner: string;
        readonly now: number;
        readonly leaseMs: number;
    }): Promise<ReconciliationLease | undefined>;
    renewLease(input: {
        readonly name: string;
        readonly owner: string;
        readonly token: string;
        readonly now: number;
        readonly leaseMs: number;
    }): Promise<boolean>;
    checkpointLease(input: {
        readonly name: string;
        readonly owner: string;
        readonly token: string;
        readonly cursor?: string;
    }): Promise<boolean>;
    releaseLease(input: {
        readonly name: string;
        readonly owner: string;
        readonly token: string;
    }): Promise<boolean>;
}
export interface DurableExecutionAdapter {
    readonly effects: DurableEffectStore;
    readonly approvals: ApprovalStore;
    readonly sagas: SagaStore;
    readonly leases: ReconciliationLeaseStore;
}
export declare function createDurableExecutionAdapter(backend: DurableRecordBackend): DurableExecutionAdapter;
/** Deterministic reference backend for tests and adapter conformance; not for production. */
export declare class MemoryDurableRecordBackend implements DurableRecordBackend {
    private readonly records;
    private readonly leases;
    private key;
    create(kind: DurableRecordKind, id: string, record: {
        readonly version: number;
        readonly state?: string;
        readonly updatedAt?: number;
    }): Promise<boolean>;
    get<T extends {
        readonly version: number;
    }>(kind: DurableRecordKind, id: string): Promise<T | undefined>;
    compareAndSet(kind: DurableRecordKind, id: string, expectedVersion: number, record: {
        readonly version: number;
        readonly state?: string;
        readonly updatedAt?: number;
    }): Promise<boolean>;
    scan<T extends {
        readonly state: string;
        readonly updatedAt: number;
    }>(kind: DurableRecordKind, input: ReconciliationScanOptions<string>): Promise<ReconciliationScanPage<T>>;
    acquireLease(input: Parameters<DurableRecordBackend["acquireLease"]>[0]): Promise<ReconciliationLease | undefined>;
    renewLease(input: Parameters<DurableRecordBackend["renewLease"]>[0]): Promise<boolean>;
    checkpointLease(input: Parameters<DurableRecordBackend["checkpointLease"]>[0]): Promise<boolean>;
    releaseLease(input: Parameters<DurableRecordBackend["releaseLease"]>[0]): Promise<boolean>;
}
export interface DurableExecutionConformanceResult {
    readonly effects: true;
    readonly approvals: true;
    readonly sagas: true;
    readonly leases: true;
}
/** Runtime-independent conformance suite reusable by adapter authors and CI. */
export declare function runDurableExecutionAdapterConformance(adapter: DurableExecutionAdapter): Promise<DurableExecutionConformanceResult>;
export interface PostgresQueryResult {
    readonly rows: readonly Record<string, unknown>[];
    readonly rowCount?: number;
}
export interface PostgresClient {
    query(sql: string, values?: readonly unknown[]): Promise<PostgresQueryResult>;
}
export declare class PostgresDurableRecordBackend implements DurableRecordBackend {
    private readonly client;
    readonly recordsTable: string;
    readonly leasesTable: string;
    constructor(client: PostgresClient, options?: {
        readonly tablePrefix?: string;
    });
    migrate(): Promise<void>;
    create(kind: DurableRecordKind, id: string, record: {
        readonly version: number;
        readonly state?: string;
        readonly updatedAt?: number;
    }): Promise<boolean>;
    get<T extends {
        readonly version: number;
    }>(kind: DurableRecordKind, id: string): Promise<T | undefined>;
    compareAndSet(kind: DurableRecordKind, id: string, expectedVersion: number, record: {
        readonly version: number;
        readonly state?: string;
        readonly updatedAt?: number;
    }): Promise<boolean>;
    scan<T extends {
        readonly state: string;
        readonly updatedAt: number;
    }>(kind: DurableRecordKind, input: ReconciliationScanOptions<string>): Promise<ReconciliationScanPage<T>>;
    acquireLease(input: Parameters<DurableRecordBackend["acquireLease"]>[0]): Promise<ReconciliationLease | undefined>;
    renewLease(input: Parameters<DurableRecordBackend["renewLease"]>[0]): Promise<boolean>;
    checkpointLease(input: Parameters<DurableRecordBackend["checkpointLease"]>[0]): Promise<boolean>;
    releaseLease(input: Parameters<DurableRecordBackend["releaseLease"]>[0]): Promise<boolean>;
}
export declare class PostgresDurableExecutionAdapter implements DurableExecutionAdapter {
    readonly effects: DurableEffectStore;
    readonly approvals: ApprovalStore;
    readonly sagas: SagaStore;
    readonly leases: ReconciliationLeaseStore;
    readonly backend: PostgresDurableRecordBackend;
    constructor(client: PostgresClient, options?: {
        readonly tablePrefix?: string;
    });
    migrate(): Promise<void>;
}
export interface SQLiteRunResult {
    readonly changes: number;
}
export interface SQLiteStatement {
    run(...values: readonly unknown[]): SQLiteRunResult;
    get(...values: readonly unknown[]): Record<string, unknown> | null | undefined;
    all(...values: readonly unknown[]): readonly (Record<string, unknown> | undefined)[];
}
export interface SQLiteClient {
    exec(sql: string): unknown;
    query(sql: string): SQLiteStatement;
}
export declare class SQLiteDurableRecordBackend implements DurableRecordBackend {
    private readonly client;
    readonly recordsTable: string;
    readonly leasesTable: string;
    constructor(client: SQLiteClient, options?: {
        readonly tablePrefix?: string;
    });
    migrate(): void;
    create(kind: DurableRecordKind, id: string, record: {
        readonly version: number;
        readonly state?: string;
        readonly updatedAt?: number;
    }): Promise<boolean>;
    get<T extends {
        readonly version: number;
    }>(kind: DurableRecordKind, id: string): Promise<T | undefined>;
    compareAndSet(kind: DurableRecordKind, id: string, expectedVersion: number, record: {
        readonly version: number;
        readonly state?: string;
        readonly updatedAt?: number;
    }): Promise<boolean>;
    scan<T extends {
        readonly state: string;
        readonly updatedAt: number;
    }>(kind: DurableRecordKind, input: ReconciliationScanOptions<string>): Promise<ReconciliationScanPage<T>>;
    acquireLease(input: Parameters<DurableRecordBackend["acquireLease"]>[0]): Promise<ReconciliationLease | undefined>;
    renewLease(input: Parameters<DurableRecordBackend["renewLease"]>[0]): Promise<boolean>;
    checkpointLease(input: Parameters<DurableRecordBackend["checkpointLease"]>[0]): Promise<boolean>;
    releaseLease(input: Parameters<DurableRecordBackend["releaseLease"]>[0]): Promise<boolean>;
}
export declare class SQLiteDurableExecutionAdapter implements DurableExecutionAdapter {
    readonly effects: DurableEffectStore;
    readonly approvals: ApprovalStore;
    readonly sagas: SagaStore;
    readonly leases: ReconciliationLeaseStore;
    readonly backend: SQLiteDurableRecordBackend;
    constructor(client: SQLiteClient, options?: {
        readonly tablePrefix?: string;
    });
    migrate(): void;
}
export interface DurableObjectStorageTransaction {
    get<T = unknown>(key: string): Promise<T | undefined>;
    put<T = unknown>(key: string, value: T): Promise<void>;
    list<T = unknown>(options?: {
        readonly prefix?: string;
        readonly startAfter?: string;
        readonly limit?: number;
    }): Promise<Map<string, T>>;
}
export interface DurableObjectStorage extends DurableObjectStorageTransaction {
    transaction<T>(closure: (transaction: DurableObjectStorageTransaction) => Promise<T>): Promise<T>;
}
export declare class DurableObjectRecordBackend implements DurableRecordBackend {
    private readonly storage;
    constructor(storage: DurableObjectStorage);
    private recordKey;
    private leaseKey;
    create(kind: DurableRecordKind, id: string, record: {
        readonly version: number;
        readonly state?: string;
        readonly updatedAt?: number;
    }): Promise<boolean>;
    get<T extends {
        readonly version: number;
    }>(kind: DurableRecordKind, id: string): Promise<T | undefined>;
    compareAndSet(kind: DurableRecordKind, id: string, expectedVersion: number, record: {
        readonly version: number;
        readonly state?: string;
        readonly updatedAt?: number;
    }): Promise<boolean>;
    scan<T extends {
        readonly state: string;
        readonly updatedAt: number;
    }>(kind: DurableRecordKind, input: ReconciliationScanOptions<string>): Promise<ReconciliationScanPage<T>>;
    acquireLease(input: Parameters<DurableRecordBackend["acquireLease"]>[0]): Promise<ReconciliationLease | undefined>;
    renewLease(input: Parameters<DurableRecordBackend["renewLease"]>[0]): Promise<boolean>;
    checkpointLease(input: Parameters<DurableRecordBackend["checkpointLease"]>[0]): Promise<boolean>;
    releaseLease(input: Parameters<DurableRecordBackend["releaseLease"]>[0]): Promise<boolean>;
}
export declare class DurableObjectExecutionAdapter implements DurableExecutionAdapter {
    readonly effects: DurableEffectStore;
    readonly approvals: ApprovalStore;
    readonly sagas: SagaStore;
    readonly leases: ReconciliationLeaseStore;
    readonly backend: DurableObjectRecordBackend;
    constructor(storage: DurableObjectStorage);
}
//# sourceMappingURL=durable-adapters.d.ts.map