/**
 * Database optimistic-lock CAS adapter — version-column / rowversion discipline over host-injected I/O.
 *
 * Uses executeIfUnchanged (conditional-write.ts). Does not invent a parallel outcome shape.
 * Token format is opaque to the guard (string equality only).
 *
 * Token encoding (this adapter only; not interpreted by the core):
 *   db:v1:<version_column_value>
 * Missing / empty version → DB_ABSENT_TOKEN.
 *
 * HONESTY: this adapter never composes SQL and never opens a connection. The host callback
 * performs the UPDATE … WHERE version = $expected (or equivalent) and reports rows_affected
 * or an explicit committed/conflict shape. Same honesty class as host-asserted conditional write.
 *
 * No pg/mysql/sqlite drivers — all I/O is host-injected.
 */
import { tokensEqual, type ExecuteIfUnchangedOutcome, type VersionToken } from '../conditional-write.js';
/** Prefix for this adapter's opaque tokens (equality-only outside this module). */
export declare const DB_VERSION_TOKEN_PREFIX = "db:v1:";
/**
 * Token used when the row has no version yet (insert path) or host reported null.
 * Hosts that measured absence should pass this as expected_token for first write.
 */
export declare const DB_ABSENT_TOKEN: VersionToken;
/**
 * Build a VersionToken from a host-read version column / rowversion / xmin-style value.
 * null / undefined / empty → DB_ABSENT_TOKEN. Numbers are stringified (no format invention).
 */
export declare function createDbVersionToken(version: string | number | bigint | null | undefined): VersionToken;
/** Raw version embedded in a db:v1: token (for host SQL bind params). Absent → null. */
export declare function dbTokenRaw(token: VersionToken | null | undefined): string | null;
/**
 * Host report after attempting an optimistic-lock write.
 * Prefer rows_affected (UPDATE … WHERE version = $expected) or explicit committed/conflict.
 */
export type DbHostWriteReport<T = unknown> = {
    status: 'committed';
    /** Version after write when the host can report it; null/omit when unknown. */
    new_version?: string | number | bigint | null;
    result?: T;
} | {
    /** Optimistic lock lost — zero rows updated. */
    status: 'conflict';
    /** Current version if the host re-read it; omit → null (no invented token). */
    current_version?: string | number | bigint | null;
} | {
    /**
     * Alternate committed shape: rows_affected > 0 means committed.
     * rows_affected === 0 means conflict (mapped to refused).
     */
    rows_affected: number;
    new_version?: string | number | bigint | null;
    result?: T;
};
export type WriteDbIfUnchangedArgs<T = unknown> = {
    /** Token measured before the host decided to write (from createDbVersionToken). */
    expected_token: VersionToken;
    /** Re-read the row version column. Called pre-write and post-write when detect is on. */
    current_version: () => string | number | bigint | null | Promise<string | number | bigint | null>;
    /**
     * Host performs the optimistic-lock mutation (SQL/query builder — never composed here).
     * Receives the raw expected version for the WHERE clause bind.
     */
    write: (ctx: {
        expected_version: string | null;
        expected_token: VersionToken;
    }) => DbHostWriteReport<T> | Promise<DbHostWriteReport<T>>;
    /**
     * Opt-in post-commit detection (default false).
     * When host omits new_version on success, detection is a no-op (cannot know intended post state).
     */
    detect_stale_during_commit?: boolean;
};
export type DbWriteResult<T = unknown> = {
    new_version: string | null;
    result: T | undefined;
    rows_affected?: number;
};
/**
 * Conditional DB write: re-read version; if token matches → host optimistic-lock write.
 *
 * Mapping (host report → ExecuteIfUnchangedOutcome):
 *   committed / rows_affected > 0     → committed
 *   conflict / rows_affected === 0    → refused / stale_version_token
 *                                       current_token from current_version when supplied,
 *                                       else null (no invented token)
 *
 * Wired through executeIfUnchanged — not a parallel path. Never composes SQL.
 */
export declare function writeDbIfUnchanged<T = unknown>(args: WriteDbIfUnchangedArgs<T>): Promise<ExecuteIfUnchangedOutcome<DbWriteResult<T>>>;
/** Re-export equality helper for hosts comparing tokens without importing core module. */
export { tokensEqual };
//# sourceMappingURL=db.d.ts.map