export type Row = {
    id: string;
    created_at?: string;
    updated_at?: string;
    created_by?: string;
    /** The row's place in its environment's change sequence (raised by every write). */
    _seq?: number;
    [column: string]: unknown;
};
/**
 * A row of a view with joins (CONTRACT.md "View joins"): each joined row is
 * nested under its join's name, e.g. `db.view<JoinedRow<{ question: Row }>>("my_answers")`
 * then `row.question.text`. The joined table's column read rules apply to
 * the nested row too: a column the caller may not read is absent.
 */
export type JoinedRow<J extends Record<string, Row>> = Row & J;
export type Where = Record<string, unknown>;
/**
 * An atomic operator in update values (CONTRACT.md "Concurrency-safe writes"),
 * computed by the server from the stored value. Build them with `db.inc(n)`,
 * `db.dec(n)`, `db.min(v)`, `db.max(v)`, `db.append(v)`, `db.remove(v)`.
 */
export type UpdateOperator = {
    $inc: number;
} | {
    $dec: number;
} | {
    $min: number | string;
} | {
    $max: number | string;
} | {
    $append: unknown;
} | {
    $remove: unknown;
} | {
    $set: unknown;
};
/** A comparison in `expect` (a plain value means equality). */
export type ExpectComparison = {
    $eq: unknown;
} | {
    $ne: unknown;
} | {
    $gt: number | string;
} | {
    $gte: number | string;
} | {
    $lt: number | string;
} | {
    $lte: number | string;
};
/** What must hold on the row at write time: column -> value (equality) or a comparison. */
export type Expect = Record<string, unknown>;
/** One op of `db.transact`. `id` (and a column value) may be `{ $ref: "<ref of an earlier insert>" }`. */
export type TransactOp = {
    op: "insert";
    table: string;
    values: Record<string, unknown>;
    ifAbsent?: Where;
    ref?: string;
} | {
    op: "update";
    table: string;
    id: string | {
        $ref: string;
    };
    values: Record<string, unknown>;
    expect?: Expect;
} | {
    op: "delete";
    table: string;
    id: string | {
        $ref: string;
    };
    expect?: Expect;
} | {
    op: "check";
    table: string;
    id: string | {
        $ref: string;
    };
    expect: Expect;
};
/** The model call of an action with `ai` (CONTRACT.md "AI calls in actions"). */
export type ActionAiResult = 
/**
 * Waited for: the answer. `stopReason` "max_tokens" = the text was cut.
 * With `tools.webSearch`: `sources` (the pages it cites - show them) and `usage.webSearches`.
 */
{
    status: "done";
    text: string;
    stopReason: string;
    usage: {
        inputTokens: number | null;
        outputTokens: number | null;
        webSearches?: number | null;
    };
    sources?: {
        url: string;
        title: string;
    }[];
    traceId: number;
}
/** The call failed (the steps, if any, committed). `error` names the cause. */
 | {
    status: "failed";
    error: string;
    traceId: number;
}
/** With `saveTo`: running in the background; the row changes when it ends. */
 | {
    status: "queued";
    id: string;
};
/** What `db.action` resolves with (CONTRACT.md "Actions"). */
export interface ActionResult<R = Row> {
    /** One entry per step, in order: its row, or null when your read rule does not let you see it. */
    results: {
        row: R | null;
    }[];
    /** The action's own trace row. */
    traceId: number;
    /** The steps' trace rows, in step order. */
    traceIds: number[];
    /** The model call, when the action has `ai`. */
    ai?: ActionAiResult;
}
export interface TransactResult<R = Row> {
    /** One entry per op, in order: the row written (or checked; the deleted row for a delete). */
    results: {
        row: R;
    }[];
    traceIds: number[];
}
export interface UpdateWithRetryOptions {
    /** Attempts in all (default 5). */
    attempts?: number;
    /** Milliseconds to wait after the n-th conflict (default: random, up to 200 ms x 2^n; the row is read again after a wait). */
    delayMs?: (attempt: number) => number;
}
export interface QueryOptions {
    /**
     * Column -> value (equality) or operators: `$eq $ne $gt $gte $lt $lte $in
     * $nin $like $ilike $null`, `$contains` (json: an array holding a value, an
     * object holding a sub-object); `$and` / `$or` nest filters. A location
     * column: `$near: { column, lat, lng, km }` (top level; rows then carry
     * `_distance` in km, and `orderBy: "_distance"` sorts by it).
     */
    where?: Where;
    /** A column, or several: `"due,-created_at"` or `["due", "-created_at"]` (`-` = descending). */
    orderBy?: string | string[];
    desc?: boolean;
    limit?: number;
}
export interface SubscribeOptions {
    where?: Where;
}
/** A view's query (CONTRACT.md "Views"): its params, a `where` on its filter columns, a sort on its sort columns, a limit. */
export interface ViewOptions {
    params?: Record<string, unknown>;
    where?: Where;
    orderBy?: string | string[];
    desc?: boolean;
    limit?: number;
}
export interface ViewResult<R = Row> {
    rows: R[];
    traceId: number;
}
/** What `subscribe` takes besides a table name: a view and its params. */
export interface ViewTarget {
    view: string;
    params?: Record<string, unknown>;
}
/** `resyncing`: the realtime tier is catching up after lost history or a `resync` (rows are reloaded). */
export type ConnectionStatus = "connecting" | "open" | "reconnecting" | "resyncing" | "closed";
/** Which socket live data uses: the server's /v1/live, or the realtime tier (from GET /v1/meta). */
export type Transport = "inproc" | "centrifugo";
/** Someone connected to a table's live lane (`db.presence`), or who sent a live message. */
export interface PresenceEntry {
    id: string;
    name?: string;
    role: string;
}
export interface Change<R = Row> {
    op: "insert" | "update" | "delete";
    /** For deletes the server may send only `{ id }`. */
    row: R;
}
export interface SubscribeHandlers<R = Row> {
    /** Full result set. Sent first, and again after every reconnect: treat it as a reset. */
    onRows?(rows: R[]): void;
    onChange?(change: Change<R>): void;
    onError?(error: DabadataError): void;
    onStatus?(status: ConnectionStatus): void;
}
export interface Subscription {
    readonly id: string;
    /** The table, or for a view subscription the view's name. */
    readonly table: string;
    /** Set for a view subscription. */
    readonly view?: string;
    close(): void;
}
/** A token pair from POST /v1/users/token or /v1/users/refresh. */
export interface TokenSet {
    token: string;
    expiresAt: string;
    refreshToken: string;
    refreshExpiresAt: string;
}
/** Where `db.auth` keeps the signed-in user's tokens. */
export type AuthStorage = "local" | "memory";
/** A hosted end user (`GET /v1/auth/users/me`). */
export interface AuthUser {
    id: string;
    email: string;
    name: string | null;
    role: string;
    emailVerified: boolean;
    /** False until the account has a password (after a sign-in link, an invite, or a social sign-up): offer `update({ password })`. */
    hasPassword: boolean;
    createdAt: string;
}
/** A pending invite the signed-in user sent (`GET /v1/auth/users/invites`). */
export interface Invite {
    /** The invited user's id (what `cancelInvite` takes). */
    id: string;
    email: string;
    name: string | null;
    role: string;
    /** When the invite link was made. */
    createdAt: string;
    expiresAt: string;
}
/** A sign-in provider of hosted users (the browser flow through the hosted pages). */
export type AuthProvider = "google" | "apple" | "microsoft" | "github" | "gitlab" | "discord" | "linkedin" | "slack";
/** The providers whose ID tokens `signInWithIdToken` takes. */
export type IdTokenProvider = "google" | "apple";
/** `GET /v1/auth/users/providers`: the providers whose browser flow is on, and the hosted pages' base URL. */
export interface AuthProviders {
    /** In the server's order; ids this client does not know are left out. */
    providers: AuthProvider[];
    /** `<public URL>/auth/<env>/`, ending in "/". */
    page: string;
}
/** Why `onAuthChange` fired. */
export type AuthChangeEvent = "signIn" | "signOut" | "refresh" | "update";
/** A user as the project (and an app admin) sees it: the end-user shape plus its state. */
export interface ManagedUser extends AuthUser {
    disabled: boolean;
    lastSignInAt: string | null;
    /** The social providers linked to the user (google, github, ...). */
    providers: AuthProvider[];
}
/** One page of `db.auth.admin.listUsers`: newest first; `next` is the `after` of the next page, or null. */
export interface UserList {
    users: ManagedUser[];
    next: string | null;
}
/**
 * Managing the project's users from the app (`db.auth.admin`), for signed-in
 * users who pass the project's `auth.users.manage` rule. A manager may not
 * change their own role, disable or delete themselves, and only touches (and
 * gives) the roles of `auth.users.manageRoles`. Rejects with DabadataError
 * (`unauthorized`, `manage_not_allowed`, `role_not_allowed`,
 * `self_not_allowed`, `not found`, `validation`).
 */
export interface AuthAdminApi {
    /** The users, newest first. `query`: part of an email or name; `limit` 1..1000 (default 100); `after`: the last id of the previous page. */
    listUsers(input?: {
        query?: string;
        limit?: number;
        after?: string;
    }): Promise<UserList>;
    /** Gives the user a role (one of `auth.users.manageRoles`). */
    setRole(id: string, role: string): Promise<ManagedUser>;
    /** Renames the user (null clears the name). */
    setName(id: string, name: string | null): Promise<ManagedUser>;
    /** Disables the user: signed out everywhere, sign-in refused. */
    disable(id: string): Promise<ManagedUser>;
    /** Lets a disabled user sign in again. */
    enable(id: string): Promise<ManagedUser>;
    /** Deletes the user and signs them out everywhere. */
    remove(id: string): Promise<void>;
}
export interface SignUpResult {
    /** The new user when the project does not ask for email verification; null otherwise. */
    user: AuthUser | null;
    /** True when a confirmation link was mailed and sign-in waits for it. */
    verify: boolean;
    /**
     * With `verify`: the one-time secret of this sign-up. The client keeps it
     * (per its `storage`) and `completeLink()` sends it with the confirmation
     * link: only then do the password and name given here survive (a link
     * completed elsewhere still verifies, without them). Null otherwise.
     */
    signupSecret: string | null;
}
/** Hosted end-user accounts of the project (CONTRACT.md "End-user accounts"). Needs `key`. */
export interface AuthApi {
    /** Creates an account. With email verification on, a link is mailed and `verify` is true. */
    signUp(input: {
        email: string;
        password: string;
        name?: string;
        redirectUrl?: string;
    }): Promise<SignUpResult>;
    /** Email + password. Rejects with DabadataError (`invalid_login`, `email_unverified`, `user_disabled`). */
    signIn(input: {
        email: string;
        password: string;
    }): Promise<AuthUser>;
    /** Mails a one-time sign-in link. `redirectUrl` (one of the project's) + `?mode=app` sends it straight to the app. */
    signInWithLink(input: {
        email: string;
        redirectUrl?: string;
    }): Promise<void>;
    /**
     * Which providers have the browser flow on (`GET /v1/auth/users/providers`),
     * and `page`, the hosted pages' base (`<public URL>/auth/<env>/`).
     */
    providers(): Promise<AuthProviders>;
    /**
     * Leaves the page for a provider (Google, Apple, Microsoft, GitHub ...) through the hosted pages
     * (`<page><provider>?redirect=<redirectUrl>`). `redirectUrl` (one of the
     * project's) defaults to the current URL without its fragment; call
     * `completeLink()` there on return. Rejects with DabadataError
     * `provider_not_enabled` when the provider is not in `providers()`, and
     * `unsupported` outside a browser (use `signInWithIdToken` in an app).
     */
    signInWithProvider(provider: AuthProvider, input?: {
        redirectUrl?: string;
    }): Promise<void>;
    /**
     * Signs in with an ID token the app got from Google or Apple itself
     * (Google Identity Services, Sign in with Apple on iOS): `POST
     * /v1/auth/users/idtoken`, then like `signIn`. `nonce` is the raw nonce
     * when the token carries one; `name` is used only when a user is created.
     * Rejects with DabadataError (`invalid_token`, `provider_not_enabled`,
     * `email_missing`, `email_unverified`, `signup_closed`, `user_disabled`,
     * `on_signup_failed`, `validation`, `rate_limited`).
     */
    signInWithIdToken(input: {
        provider: IdTokenProvider;
        idToken: string;
        nonce?: string;
        name?: string;
    }): Promise<AuthUser>;
    /**
     * Finishes a link: reads `#token=...` from the page URL (or `url`), signs in
     * and clears the fragment. Handles the hosted pages' redirect
     * (`#token&refreshToken&expiresAt&refreshExpiresAt`) and app-mode links
     * (`#token=...&type=verify|magic|reset|invite`; reset and invite need
     * `password`). Null when the URL carries no token. A confirmation link
     * sends the kept `signupSecret` (or the one given here) along.
     */
    completeLink(input?: {
        url?: string;
        password?: string;
        signupSecret?: string;
    }): Promise<AuthUser | null>;
    /** Mails a password reset link. */
    resetPassword(input: {
        email: string;
        redirectUrl?: string;
    }): Promise<void>;
    /** Signs out (this session, or every session with `everywhere`), clears the tokens, reconnects as anonymous. */
    signOut(input?: {
        everywhere?: boolean;
    }): Promise<void>;
    /** The signed-in user (cached `GET /v1/auth/users/me`), or null. */
    user(input?: {
        force?: boolean;
    }): Promise<AuthUser | null>;
    /** Called on sign-in, sign-out and token refresh. Returns an unsubscribe function. */
    onAuthChange(cb: (user: AuthUser | null, event: AuthChangeEvent) => void): () => void;
    /**
     * Invites someone as the signed-in user, under the project's
     * `auth.users.invite` rule. Resolves the same whether or not the address
     * already has an account. `role` must be one of `auth.users.invite.roles`;
     * `redirectUrl` (one of the project's, `?mode=app` for the app itself) is
     * where the invite link sends the person. Rejects with DabadataError
     * (`unauthorized`, `invite_not_allowed`, `role_not_allowed`, `validation`,
     * `rate_limited`).
     */
    invite(input: {
        email: string;
        name?: string;
        role?: string;
        redirectUrl?: string;
    }): Promise<void>;
    /** The signed-in user's pending invites, newest first. */
    invites(): Promise<Invite[]>;
    /** Cancels one of the signed-in user's pending invites (`id` from `invites()`). */
    cancelInvite(id: string): Promise<void>;
    /**
     * Changes the signed-in user's name and / or password (`PATCH
     * /v1/auth/users/me`). A new password needs `currentPassword` when the user
     * has one, signs every other session out and answers a new token pair,
     * which the client stores like a sign-in. Resolves with the user;
     * `onAuthChange` fires with "update". Rejects with DabadataError
     * (`unauthorized`, `invalid_login` for a wrong current password,
     * `validation`, `rate_limited`).
     */
    update(input: {
        name?: string | null;
        password?: string;
        currentPassword?: string;
    }): Promise<AuthUser>;
    /** Managing the project's users from the app (the `auth.users.manage` rule). */
    readonly admin: AuthAdminApi;
}
/** A row of `files_<bucket>` (CONTRACT.md "File storage"). */
export interface FileRow {
    id: string;
    name: string;
    /** Bytes. */
    size: number;
    /** MIME type. */
    type: string;
    /** The uploader's user id (null for anonymous uploads). */
    owner: string | null;
    created_at: string;
    updated_at?: string;
    created_by?: string | null;
    _seq?: number;
}
export interface UploadProgress {
    loaded: number;
    total: number;
}
export interface UploadOptions {
    /** The file's name. Default: the File's own name, else "file". */
    name?: string;
    /** MIME type. Default: the Blob's type, else application/octet-stream. */
    type?: string;
    /** Upload progress (uses XMLHttpRequest when it exists; fetch otherwise, which reports only the end). */
    onProgress?: (p: UploadProgress) => void;
    /**
     * Then set a file column of a row to the new file (`update` with the row's
     * rules). The file it replaces is deleted by the server (the column's
     * `onReplace`). When the update is refused, the upload stays and the error
     * is thrown with the uploaded file as `error.file` (retry the attach, or
     * remove it).
     */
    attachTo?: {
        table: string;
        id: string;
        column: string;
    };
}
export interface FileUrl {
    /** Signed, valid until `expiresAt` (5 minutes). */
    url: string;
    expiresAt: string;
    /** Seconds the signed URL is valid (300). Absent from older servers. */
    expiresIn?: number;
    /** Buckets anyone may read: a stable URL (cacheable, fine for <img src>). */
    publicUrl?: string;
}
/** What `watchUrl` and `bindImage` take. */
export interface RenewOptions {
    /** A failed renewal (or, for `bindImage`, a file that fails to load with a fresh URL). */
    onError?: (error: unknown) => void;
}
/** Anything with a `src` that fires `load` / `error`: an <img>, a <video>. */
export interface MediaElementLike {
    src: string;
    addEventListener(type: "load" | "error", listener: () => void): void;
    removeEventListener(type: "load" | "error", listener: () => void): void;
}
/** File storage (`db.storage`): uploads go straight to the object store; rules, trace and live as for rows. */
export interface StorageApi {
    /** Create the upload, PUT the bytes to the presigned URL, complete it -> the file row. */
    upload<R = FileRow>(bucket: string, file: Blob, options?: UploadOptions): Promise<R>;
    /** A URL to show or download the file: the public URL for anyone-read buckets, else a 5-minute signed one. */
    url(bucket: string, id: string): Promise<string>;
    /** The signed URL with its expiry (and the public URL when there is one). */
    signedUrl(bucket: string, id: string): Promise<FileUrl>;
    /**
     * Keeps a URL for the file valid while the page shows it: calls `onUrl` now, and again with a
     * fresh signed URL before each one expires (a public URL is stable: one call). Returns stop().
     */
    watchUrl(bucket: string, id: string, onUrl: (url: string) => void, options?: RenewOptions): () => void;
    /**
     * Shows the file in an <img> or <video>: sets `src`, and sets a fresh URL when loading fails
     * because the signed one expired (long-open pages, lazy images). Returns stop().
     */
    bindImage(el: MediaElementLike, bucket: string, id: string, options?: RenewOptions): () => void;
    /** Deletes the file (the bucket's delete rule). */
    remove(bucket: string, id: string): Promise<{
        id: string;
    }>;
    /** Rows of `files_<bucket>` the caller may read. Live: `db.subscribe("files_<bucket>")`. */
    list<R = FileRow>(bucket: string, options?: QueryOptions): Promise<R[]>;
}
export interface ClientOptions {
    /** Server base URL, e.g. http://127.0.0.1:4600 */
    url: string;
    /**
     * The environment's publishable key (`pk_live_...` / `pk_test_...`). Sent as
     * `X-Api-Key` on every call and `?key=` on the socket. Omit for the
     * server's default project.
     */
    key?: string | null;
    /**
     * Where `db.auth` keeps its tokens: "local" (localStorage, the default when
     * it exists; one entry per url + key) or "memory". A stored session is
     * picked up by the next createClient that gets no `token`.
     */
    storage?: AuthStorage;
    /** User (access) token from POST /v1/users/token. Omit for anonymous calls. */
    token?: string | null;
    /**
     * Refresh token from the same call. With it the client renews the access
     * token by itself: 60 s before `expiresAt`, and on any 401.
     */
    refreshToken?: string | null;
    /** When `token` expires (ISO string or ms since epoch). */
    expiresAt?: string | number | null;
    /** Called with every new pair after a refresh, so the app can persist it. */
    onTokens?: (tokens: TokenSet) => void;
    /** Where refreshes go. Default `<url>/v1/users/refresh`. */
    refreshUrl?: string;
    /** Reconnect delays in ms; the last one repeats. Default 1, 2, 4, 8, then 10 s. */
    reconnectDelays?: number[];
    /** Ping interval in ms. Default 25 s. */
    pingInterval?: number;
    /** Override for tests or non-browser runtimes. */
    fetch?: FetchLike;
    WebSocket?: typeof WebSocket;
    /** For `db.storage.upload` progress. Default: the global one, when there is one. */
    XMLHttpRequest?: typeof XMLHttpRequest;
    /** The live transport. Default "auto": ask GET /v1/meta once. */
    realtime?: "auto" | Transport;
}
export declare class DabadataError extends Error {
    /** HTTP status; 0 for network or socket errors. */
    readonly status: number;
    /** Machine code from the body, e.g. "forbidden", "unauthorized". */
    readonly code?: string;
    /** The rule engine's explanation (403 bodies and denied subscribes). */
    readonly explanation?: string;
    readonly traceId?: number | string;
    readonly body?: unknown;
    /** `storage.upload` with `attachTo` only: the file that was uploaded when the attach was refused. */
    file?: FileRow;
    constructor(message: string, init: {
        status: number;
        code?: string;
        explanation?: string;
        traceId?: number | string;
        body?: unknown;
    });
}
/** The name before the product rename; the same class. */
export { DabadataError as LiveDbError };
export interface DabadataClient {
    /** `ifAbsent`: refuse (409 conflict, with the existing row) when a row with these values exists. */
    insert<R = Row>(table: string, values: Record<string, unknown>, options?: {
        ifAbsent?: Where;
    }): Promise<R>;
    /**
     * Values may be operators (`db.inc(1)`). `expect`: what must hold on the row
     * at write time; otherwise a 409 DabadataError (code "conflict") whose body
     * carries the current row.
     */
    update<R = Row>(table: string, id: string, values: Record<string, unknown>, options?: {
        expect?: Expect;
    }): Promise<R>;
    delete(table: string, id: string, options?: {
        expect?: Expect;
    }): Promise<{
        id: string;
    }>;
    /** Up to 50 ops in one serializable transaction: all or nothing. A failed op rejects with `body.index`. */
    transact<R = Row>(ops: TransactOp[]): Promise<TransactResult<R>>;
    /**
     * Runs the definition's action `name` (POST /v1/actions/<name>): its steps
     * run in one transaction with the server's rights, if you pass its `allow`
     * rule. A refusal rejects with a DabadataError: 403 `forbidden` (the
     * explanation), 400 bad params, 409 `conflict` with `body.index` naming the
     * step that did not hold.
     */
    action<R = Row>(name: string, params?: Record<string, unknown>): Promise<ActionResult<R>>;
    /**
     * Read-modify-write without lost updates: reads the row, computes values
     * with `fn`, writes them with `expect` on the values read, and on a 409
     * conflict computes again from the current row (up to `attempts`). `fn`
     * returning null or undefined writes nothing and resolves with the row.
     */
    updateWithRetry<R = Row>(table: string, id: string, fn: (row: R) => Record<string, unknown> | null | undefined | Promise<Record<string, unknown> | null | undefined>, options?: UpdateWithRetryOptions): Promise<R>;
    /** `{ $inc: n }`: add n (a null column counts as 0). */
    inc(n: number): {
        $inc: number;
    };
    /** `{ $dec: n }`: subtract n. */
    dec(n: number): {
        $dec: number;
    };
    /** `{ $min: v }`: the smaller of the stored value and v. */
    min(v: number | string): {
        $min: number | string;
    };
    /** `{ $max: v }`: the larger of the stored value and v. */
    max(v: number | string): {
        $max: number | string;
    };
    /** `{ $append: v }`: add v to the end of a json array (null starts an empty one). */
    append(v: unknown): {
        $append: unknown;
    };
    /** `{ $remove: v }`: remove every element equal to v from a json array. */
    remove(v: unknown): {
        $remove: unknown;
    };
    query<R = Row>(table: string, options?: QueryOptions): Promise<R[]>;
    /**
     * Reads the definition's view `name` (GET /v1/views/<name>): the rows it
     * lets the caller read, shaped for their role (computed fields included;
     * joined rows nested under their join's name, see JoinedRow).
     * Rejects with a DabadataError: 404 unknown view, 403 `forbidden` (its
     * allow rule), 400 bad params or a where / orderBy on undeclared columns.
     */
    view<R = Row>(name: string, options?: ViewOptions): Promise<ViewResult<R>>;
    /** One row of a view by id (404 when it is not in the view). */
    viewRow<R = Row>(name: string, id: string, options?: {
        params?: Record<string, unknown>;
    }): Promise<{
        row: R;
        traceId: number;
    }>;
    /** A table by name, or a view: `subscribe({ view: "open_questions", params: { round } }, { where }, handlers)`. */
    subscribe<R = Row>(target: string | ViewTarget, options?: SubscribeOptions, handlers?: SubscribeHandlers<R>): Subscription;
    /** Current socket status ("closed" before the first subscribe). */
    readonly status: ConnectionStatus;
    /** The access token in use now (it changes after a refresh). */
    readonly token: string | null;
    /**
     * Swaps the access token (and optionally its expiry). An open socket keeps
     * its identity; the next connect uses the new token.
     */
    setToken(token: string | null, expiresAt?: string | number | null): void;
    /** Refreshes now. Concurrent calls share one request. Rejects with DabadataError. */
    refresh(): Promise<TokenSet>;
    /** Closes the socket and every subscription, and stops the proactive refresh timer (a 401 still refreshes). */
    close(): void;
    /** Hosted end-user accounts (sign up, sign in, links, sign out). */
    readonly auth: AuthApi;
    /** File storage: upload, url, remove, list (CONTRACT.md "File storage"). */
    readonly storage: StorageApi;
    /** The live transport in use (null until GET /v1/meta answered). */
    readonly transport: Transport | null;
    /** Who is looking at a table now (realtime tier: GET /v1/rt/presence). One entry per user. */
    presence(table: string): Promise<PresenceEntry[]>;
    /**
     * Sends an ephemeral message to everyone connected to a table's live lane
     * (typing, cursors). Never stored, never applied as data. Realtime tier only.
     */
    publish(table: string, data: unknown): Promise<void>;
    /** Messages on a table's live lane (`publish` from anyone, this client included). Returns an unsubscribe function. */
    onMessage<T = unknown>(table: string, cb: (data: T, from: PresenceEntry | null) => void): () => void;
}
/**
 * The shape of the file `dabadata types` writes (GET /v1/schema/types):
 * `createClient<Database>(options)` takes it.
 */
export interface DatabaseShape {
    tables: Record<string, {
        row: object;
        insert: object;
        update: object;
    }>;
    views: Record<string, {
        row: object;
        params: object;
    }>;
    actions: Record<string, {
        params: object;
    }>;
}
type TableName<DB extends DatabaseShape> = keyof DB["tables"] & string;
type ViewName<DB extends DatabaseShape> = keyof DB["views"] & string;
type ActionName<DB extends DatabaseShape> = keyof DB["actions"] & string;
type RowOf<DB extends DatabaseShape, T extends TableName<DB>> = DB["tables"][T]["row"];
/** Update values of a table: each column's value, or an operator (`db.inc(1)`, ...). */
export type UpdateValuesOf<U> = {
    [K in keyof U]?: U[K] | UpdateOperator;
};
/** A filter on a row's columns: a value (equality) or operators (`{ $gt: 5 }`); `$and` / `$or` nest; `$near` for a location. */
export type WhereOf<R> = {
    [K in keyof R]?: R[K] | null | Record<string, unknown>;
} & {
    $and?: WhereOf<R>[];
    $or?: WhereOf<R>[];
    $near?: {
        column: keyof R & string;
        lat: number;
        lng: number;
        km: number;
    };
};
/** A sort column of a row: `"due"` or `"-due"` (descending); `_distance` after a `$near`. A list for several (no comma string). */
export type OrderByOf<R> = (keyof R & string) | `-${keyof R & string}` | "_distance" | "-_distance";
export interface TypedQueryOptions<R> extends Omit<QueryOptions, "where" | "orderBy"> {
    where?: WhereOf<R>;
    orderBy?: OrderByOf<R> | OrderByOf<R>[];
}
export interface TypedViewOptions<V extends {
    row: object;
    params: object;
}> extends Omit<ViewOptions, "params" | "where" | "orderBy"> {
    params?: V["params"];
    where?: WhereOf<V["row"]>;
    orderBy?: OrderByOf<V["row"]> | OrderByOf<V["row"]>[];
}
/** An action without required params may be called without them. */
type ParamsArg<P> = {} extends P ? [params?: P] : [params: P];
/** The methods `createClient<Database>()` types by the definition; the rest is the untyped client's. */
export interface TypedTableMethods<DB extends DatabaseShape> {
    insert<T extends TableName<DB>>(table: T, values: DB["tables"][T]["insert"], options?: {
        ifAbsent?: WhereOf<RowOf<DB, T>>;
    }): Promise<RowOf<DB, T>>;
    update<T extends TableName<DB>>(table: T, id: string, values: UpdateValuesOf<DB["tables"][T]["update"]>, options?: {
        expect?: Expect;
    }): Promise<RowOf<DB, T>>;
    delete<T extends TableName<DB>>(table: T, id: string, options?: {
        expect?: Expect;
    }): Promise<{
        id: string;
    }>;
    query<T extends TableName<DB>>(table: T, options?: TypedQueryOptions<RowOf<DB, T>>): Promise<RowOf<DB, T>[]>;
    updateWithRetry<T extends TableName<DB>>(table: T, id: string, fn: (row: RowOf<DB, T>) => UpdateValuesOf<DB["tables"][T]["update"]> | null | undefined | Promise<UpdateValuesOf<DB["tables"][T]["update"]> | null | undefined>, options?: UpdateWithRetryOptions): Promise<RowOf<DB, T>>;
    view<V extends ViewName<DB>>(name: V, options?: TypedViewOptions<DB["views"][V]>): Promise<ViewResult<DB["views"][V]["row"]>>;
    viewRow<V extends ViewName<DB>>(name: V, id: string, options?: {
        params?: DB["views"][V]["params"];
    }): Promise<{
        row: DB["views"][V]["row"];
        traceId: number;
    }>;
    action<A extends ActionName<DB>>(name: A, ...params: ParamsArg<DB["actions"][A]["params"]>): Promise<ActionResult<Row>>;
    subscribe<T extends TableName<DB>>(table: T, options?: {
        where?: WhereOf<RowOf<DB, T>>;
    }, handlers?: SubscribeHandlers<RowOf<DB, T>>): Subscription;
    subscribe<V extends ViewName<DB>>(target: {
        view: V;
        params?: DB["views"][V]["params"];
    }, options?: {
        where?: WhereOf<DB["views"][V]["row"]>;
    }, handlers?: SubscribeHandlers<DB["views"][V]["row"]>): Subscription;
}
type TypedKeys = "insert" | "update" | "delete" | "query" | "updateWithRetry" | "view" | "viewRow" | "action" | "subscribe";
/** A client typed by a generated `Database`: `createClient<Database>(options)`. */
export type TypedClient<DB extends DatabaseShape> = Omit<DabadataClient, TypedKeys> & TypedTableMethods<DB>;
export type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
/** The name before the product rename. */
export type LiveDbClient = DabadataClient;
/**
 * A client for one environment. `createClient<Database>(options)` with the
 * file `dabadata types` writes types table, view and action names, values
 * and rows (CONTRACT.md "Typed tables for JS/TS"); without it every name is
 * a string. Same object at runtime either way.
 */
export declare function createClient(options: ClientOptions): DabadataClient;
export declare function createClient<DB extends DatabaseShape>(options: ClientOptions): TypedClient<DB>;