terrascale 0.3.0

package/types/admin.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Administrative operations require the admitted regional management contract.
+ * @returns {never}
+ */
+export function requireTerraScaleAdministration(): never;
+export { TerraScaleCapabilityUnavailableError } from "./management-contracts.js";

package/types/better-auth.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Production Better Auth persistence is required but blocked by security authority
+ * and catalog/credential admission. Local development uses the explicit ./local
+ * SQLite factory pinned to Better Auth 1.7.2.
+ * @returns {never}
+ */
+export function requireTerraScaleBetterAuth(): never;
+export { terraScaleReleaseBlockers, TerraScaleCapabilityUnavailableError } from "./management-contracts.js";

package/types/config.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared fetch signature; native database and hosted identity credentials stay distinct.
+ * @typedef {(input: RequestInfo | URL, init?: RequestInit) => Promise<Response>} FetchLike
+ */
+/**
+ * @typedef {string | (() => Promise<string | undefined> | string | undefined)} AccessTokenProvider
+ */
+/**
+ * `requestTimeoutMs`: one deadline covers discovery, credentials, requests, bodies and retry delays.
+ * @typedef {{
+ *   readonly apiBaseUrl: string;
+ *   readonly accessToken?: AccessTokenProvider;
+ *   readonly fetch?: FetchLike;
+ *   readonly maxRetryAttempts?: number | undefined;
+ *   readonly retryDelayMs?: number | undefined;
+ *   readonly requestTimeoutMs?: number | undefined;
+ * }} TsAuthRuntimeConfig
+ */
+/**
+ * @typedef {{
+ *   readonly apiBaseUrl: string;
+ *   readonly maxRetryAttempts: number;
+ *   readonly retryDelayMs: number;
+ *   readonly requestTimeoutMs: number;
+ * }} ResolvedTsAuthRuntimeConfig
+ */
+/**
+ * @param {TsAuthRuntimeConfig} config
+ * @returns {ResolvedTsAuthRuntimeConfig}
+ */
+export function resolveTsAuthRuntimeConfig(config: TsAuthRuntimeConfig): ResolvedTsAuthRuntimeConfig;
+/**
+ * @param {AccessTokenProvider | undefined} provider
+ * @returns {Promise<string | undefined>}
+ */
+export function resolveAccessToken(provider: AccessTokenProvider | undefined): Promise<string | undefined>;
+/**
+ * Shared fetch signature; native database and hosted identity credentials stay distinct.
+ */
+export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type AccessTokenProvider = string | (() => Promise<string | undefined> | string | undefined);
+/**
+ * `requestTimeoutMs`: one deadline covers discovery, credentials, requests, bodies and retry delays.
+ */
+export type TsAuthRuntimeConfig = {
+    readonly apiBaseUrl: string;
+    readonly accessToken?: AccessTokenProvider;
+    readonly fetch?: FetchLike;
+    readonly maxRetryAttempts?: number | undefined;
+    readonly retryDelayMs?: number | undefined;
+    readonly requestTimeoutMs?: number | undefined;
+};
+export type ResolvedTsAuthRuntimeConfig = {
+    readonly apiBaseUrl: string;
+    readonly maxRetryAttempts: number;
+    readonly retryDelayMs: number;
+    readonly requestTimeoutMs: number;
+};

package/types/database-codec.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @param {unknown} value
+ * @param {string} [name]
+ * @returns {string}
+ */
+export function requireDatabaseUuid(value: unknown, name?: string): string;
+/**
+ * @param {unknown} value
+ * @param {string} [name]
+ * @param {boolean} [positive]
+ * @returns {bigint}
+ */
+export function requireDatabaseU64(value: unknown, name?: string, positive?: boolean): bigint;
+/**
+ * Typed value encoding preserves numeric field IDs, arrays, bytes, and explicit null.
+ * @param {DatabaseValue} value
+ * @returns {JsonObject}
+ */
+export function encodeDatabaseValue(value: DatabaseValue): JsonObject;
+/**
+ * @param {unknown} value
+ * @returns {DatabaseValue}
+ */
+export function decodeDatabaseValue(value: unknown): DatabaseValue;
+/**
+ * @param {unknown} raw
+ * @returns {DatabasePoint}
+ */
+export function decodeDatabasePoint(raw: unknown): DatabasePoint;
+/**
+ * @param {DatabaseQuery} query
+ * @returns {string}
+ */
+export function encodeDatabaseQuery(query: DatabaseQuery): string;
+/**
+ * @param {unknown} raw
+ * @returns {DatabaseQueryPage}
+ */
+export function decodeDatabaseQueryPage(raw: unknown): DatabaseQueryPage;
+/**
+ * @param {DatabaseSubscriptionRequest} request
+ * @returns {string}
+ */
+export function encodeDatabaseSubscription(request: DatabaseSubscriptionRequest): string;
+/**
+ * @param {unknown} raw
+ * @returns {DatabaseSubscriptionResponse}
+ */
+export function decodeDatabaseSubscription(raw: unknown): DatabaseSubscriptionResponse;
+/**
+ * @param {DatabaseAuthority} authority
+ * @returns {JsonObject}
+ */
+export function encodeDatabaseAuthority(authority: DatabaseAuthority): JsonObject;
+/**
+ * @param {unknown} raw
+ * @returns {DatabaseAuthority}
+ */
+export function decodeDatabaseAuthority(raw: unknown): DatabaseAuthority;
+/**
+ * @param {unknown} raw
+ * @returns {DatabaseCommitReceipt}
+ */
+export function decodeDatabaseCommitReceipt(raw: unknown): DatabaseCommitReceipt;
+/**
+ * @param {DatabaseTransactionIdentity} identity
+ * @returns {string}
+ */
+export function encodeDatabaseStatus(identity: DatabaseTransactionIdentity): string;
+/**
+ * @param {unknown} raw
+ * @returns {DatabaseTransactionStatus}
+ */
+export function decodeDatabaseStatus(raw: unknown): DatabaseTransactionStatus;
+/**
+ * Reject duplicate JSON members and unbounded syntax before typed response decoding.
+ * @param {Uint8Array} bytes
+ * @returns {unknown}
+ */
+export function parseDatabaseJson(bytes: Uint8Array): unknown;
+/**
+ * Build and snapshot the exact logical effect before awaiting WebCrypto.
+ * @param {DatabaseScope} scope
+ * @param {DatabaseCommit} commit
+ * @returns {Promise<{ readonly body: string; readonly effect_digest: string }>}
+ */
+export function encodeDatabaseCommit(scope: DatabaseScope, commit: DatabaseCommit): Promise<{
+    readonly body: string;
+    readonly effect_digest: string;
+}>;
+export type Budget = {
+    nodes: number;
+};
+export type Json = null | boolean | number | string | JsonArray | JsonObject;
+export type JsonArray = readonly Json[];
+export type JsonObject = {
+    readonly [key: string]: Json;
+};
+export type RecordValue = Record<string, unknown>;
+import type { DatabaseValue } from "./database-types.js";
+import type { DatabasePoint } from "./database-types.js";
+import type { DatabaseQuery } from "./database-types.js";
+import type { DatabaseQueryPage } from "./database-types.js";
+import type { DatabaseSubscriptionRequest } from "./database-types.js";
+import type { DatabaseSubscriptionResponse } from "./database-types.js";
+import type { DatabaseAuthority } from "./database-types.js";
+import type { DatabaseCommitReceipt } from "./database-types.js";
+import type { DatabaseTransactionIdentity } from "./database-types.js";
+import type { DatabaseTransactionStatus } from "./database-types.js";
+import type { DatabaseScope } from "./database-types.js";
+import type { DatabaseCommit } from "./database-types.js";

package/types/database-types.d.ts

@@ -0,0 +1,213 @@
+/**
+ * The current TerraBase document protocol uses canonical UUID entity IDs.
+ */
+export type CanonicalUuid = string;
+/**
+ * All 64-bit quantities stay bigint in JavaScript and decimal strings on the wire.
+ */
+export type DatabaseScope = {
+    readonly tenant: CanonicalUuid;
+    readonly database: CanonicalUuid;
+    readonly shard: bigint;
+};
+export type CollectionBinding = {
+    readonly collection: CanonicalUuid;
+    readonly schema_generation: bigint;
+    readonly schema_digest: string;
+};
+export type DatabaseValue = ({
+    readonly type: "null";
+} | {
+    readonly type: "bool";
+    readonly value: boolean;
+} | {
+    readonly type: "i64";
+    readonly value: bigint;
+} | {
+    readonly type: "utf8";
+    readonly value: string;
+} | {
+    readonly type: "bytes";
+    readonly value: Uint8Array;
+} | {
+    readonly type: "map";
+    readonly fields: readonly DatabaseField[];
+} | {
+    readonly type: "array";
+    readonly items: readonly DatabaseValue[];
+});
+/**
+ * Missing fields are omitted; an explicit null remains a typed null value.
+ */
+export type DatabaseField = {
+    readonly id: number;
+    readonly value: DatabaseValue;
+};
+export type DatabaseObserved = {
+    readonly replica: CanonicalUuid;
+    readonly incarnation: string;
+    readonly sequence: bigint;
+};
+export type DatabaseEvent = DatabaseObserved & {
+    readonly database: CanonicalUuid;
+    readonly shard: bigint;
+};
+export type DatabaseAuthority = ({
+    readonly mode: "leaderless";
+} | {
+    readonly mode: "single_writer";
+    readonly generation: bigint;
+    readonly writer: {
+        readonly replica: CanonicalUuid;
+        readonly incarnation: string;
+    };
+});
+export type DatabaseCondition = ({
+    readonly kind: "none";
+} | {
+    readonly kind: "absent";
+} | {
+    readonly kind: "version";
+    readonly version: string;
+});
+export type DatabaseWriteValue = ({
+    readonly kind: "live";
+    readonly fields: readonly DatabaseField[];
+} | {
+    readonly kind: "tombstone";
+});
+export type DatabaseWrite = CollectionBinding & {
+    readonly document: CanonicalUuid;
+    readonly condition: DatabaseCondition;
+    readonly observed: readonly DatabaseObserved[];
+    readonly value: DatabaseWriteValue;
+};
+export type DatabaseTransactionId = {
+    readonly expires_at_unix_ms: bigint;
+    readonly nonce: string;
+};
+export type DatabaseCommit = {
+    readonly transaction_id: DatabaseTransactionId;
+    readonly authority: DatabaseAuthority;
+    readonly writes: readonly DatabaseWrite[];
+};
+export type DatabaseSibling = Omit<CollectionBinding, "collection"> & {
+    readonly event: DatabaseEvent;
+} & DatabaseWriteValue;
+/**
+ * `state_version`: only a unique live or deleted state carries an atomic condition token.
+ */
+export type DatabasePoint = {
+    readonly version: 1;
+    readonly state: "absent" | "deleted" | "value" | "conflict";
+    readonly state_version: string | null;
+    readonly context: readonly DatabaseObserved[];
+    readonly siblings: readonly DatabaseSibling[];
+};
+export type DatabaseQueryValue = Extract<DatabaseValue, {
+    readonly type: "bool" | "i64" | "utf8" | "bytes";
+}>;
+export type DatabaseQueryPredicate = ({
+    readonly op: "equal" | "less_than" | "less_than_or_equal" | "greater_than" | "greater_than_or_equal";
+    readonly path: readonly number[];
+    readonly value: DatabaseQueryValue;
+} | {
+    readonly op: "is_null" | "is_missing";
+    readonly path: readonly number[];
+});
+export type DatabaseQuery = {
+    readonly predicate: DatabaseQueryPredicate;
+    readonly limit: number;
+    readonly cursor?: string;
+};
+export type DatabaseQueryRow = {
+    readonly document: CanonicalUuid;
+    readonly point: DatabasePoint;
+};
+export type DatabaseQueryPage = {
+    readonly version: 1;
+    readonly rows: readonly DatabaseQueryRow[];
+    readonly next_cursor?: string;
+};
+export type DatabaseCommitReceipt = {
+    readonly version: 1;
+    readonly durability: "local_durable" | "object_durable";
+    readonly transaction_id: DatabaseTransactionId;
+    readonly event: DatabaseEvent;
+    readonly commit_sequence: bigint;
+    readonly effect_digest: string;
+    readonly authority: DatabaseAuthority;
+};
+export type DatabaseTransactionIdentity = {
+    readonly transaction_id: DatabaseTransactionId;
+    readonly authority: DatabaseAuthority;
+    readonly effect_digest: string;
+};
+export type DatabaseTransactionStatus = DatabaseTransactionIdentity & {
+    readonly version: 1;
+} & ({
+    readonly state: "committed";
+    readonly outcome: {
+        readonly receipt: DatabaseCommitReceipt;
+    };
+} | {
+    readonly state: "rejected";
+    readonly outcome: {
+        readonly error: {
+            readonly code: "precondition_failed";
+        };
+    };
+} | {
+    readonly state: "pending" | "unknown" | "expired";
+    readonly outcome: null;
+});
+/**
+ * An uncertain request needs status resolution; it is never an aborted transaction.
+ */
+export type DatabaseResult<T> = ({
+    readonly ok: true;
+    readonly status: number;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: {
+        readonly code: string;
+        readonly status?: number;
+        readonly mutation_outcome?: "rejected" | "uncertain" | "unknown";
+        readonly transaction?: DatabaseTransactionIdentity;
+    };
+});
+export type DatabaseSubscriptionRequest = ({
+    readonly phase: "snapshot";
+    readonly predicate: DatabaseQueryPredicate;
+    readonly limit: number;
+    readonly snapshot_cursor?: string;
+} | {
+    readonly phase: "poll";
+    readonly predicate: DatabaseQueryPredicate;
+    readonly poll_cursor: string;
+});
+export type DatabaseSubscriptionEffect = {
+    readonly document: CanonicalUuid;
+    readonly point: DatabasePoint | null;
+};
+export type DatabaseSubscriptionGroup = {
+    readonly sequence: bigint;
+    readonly effects: readonly DatabaseSubscriptionEffect[];
+};
+export type DatabaseSubscriptionResponse = ({
+    readonly version: 1;
+    readonly phase: "snapshot";
+    readonly rows: readonly DatabaseQueryRow[];
+    readonly next_snapshot_cursor: string;
+} | {
+    readonly version: 1;
+    readonly phase: "snapshot";
+    readonly rows: readonly DatabaseQueryRow[];
+    readonly poll_cursor: string;
+} | {
+    readonly version: 1;
+    readonly phase: "poll";
+    readonly groups: readonly DatabaseSubscriptionGroup[];
+    readonly poll_cursor: string;
+});

package/types/database-view.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Native snapshot/poll source shared by React, Svelte and TanStack.
+ * @param {TerraBaseClient} client
+ * @param {DatabaseQueryOptions} options
+ * @returns {DatabaseQuerySource}
+ */
+export function createDatabaseQuery(client: TerraBaseClient, options: DatabaseQueryOptions): DatabaseQuerySource;
+/**
+ * @import { TerraBaseClient } from "./database.js"
+ * @import {
+ *   DatabaseField, DatabasePoint, DatabaseQueryPredicate, DatabaseQueryRow,
+ *   DatabaseResult, DatabaseScope, DatabaseSubscriptionRequest,
+ *   DatabaseSubscriptionResponse, DatabaseValue,
+ * } from "./database-types.js"
+ * @import { ReactiveReset, ReactiveSubscriptionContext } from "./react/core.js"
+ */
+/**
+ * - `limit`: snapshot page size, between 1 and 128.
+ * - `maximumRows`: client memory bound, including all snapshot pages and later inserts.
+ * - `retryLimit`: bounded retries of read transport failures with the identical cursor.
+ * @typedef {{
+ *   readonly collection: string;
+ *   readonly predicate: DatabaseQueryPredicate;
+ *   readonly limit?: number;
+ *   readonly maximumRows?: number;
+ *   readonly pollIntervalMs?: number;
+ *   readonly retryLimit?: number;
+ *   readonly retryDelayMs?: number;
+ * }} DatabaseQueryOptions
+ */
+/**
+ * @typedef {{
+ *   readonly scope: DatabaseScope;
+ *   readonly collection: string;
+ *   readonly predicate: DatabaseQueryPredicate;
+ *   readonly limit: number;
+ * }} DatabaseViewBinding
+ */
+/**
+ * Local generation and server position of one complete authorized cut.
+ * @typedef {{
+ *   readonly generation: number;
+ *   readonly poll_cursor: string;
+ *   readonly sequence?: bigint;
+ * }} DatabaseViewPosition
+ */
+/**
+ * @typedef {{
+ *   readonly rows: readonly DatabaseQueryRow[];
+ *   readonly position: DatabaseViewPosition;
+ * }} DatabaseViewSnapshot
+ */
+/**
+ * `next`: an async consumer can acknowledge publication before the next poll.
+ * @typedef {{
+ *   readonly next: (rows: readonly DatabaseQueryRow[], position: DatabaseViewPosition) => void | Promise<void>;
+ *   readonly error: (error: unknown) => void;
+ *   readonly reset: (reset: ReactiveReset<readonly DatabaseQueryRow[]>) => void;
+ * }} DatabaseQueryCallbacks
+ */
+/**
+ * @typedef {{
+ *   readonly key?: string | readonly unknown[];
+ *   readonly binding: DatabaseViewBinding;
+ *   readonly subscribe: (
+ *     observer: DatabaseQueryCallbacks,
+ *     context: ReactiveSubscriptionContext,
+ *   ) => () => void;
+ * }} DatabaseQuerySource
+ */
+export class DatabaseSubscriptionError extends Error {
+    /**
+     * @param {string} code
+     * @param {Extract<DatabaseResult<never>, { readonly ok: false }>["error"]} [detail]
+     */
+    constructor(code: string, detail?: Extract<DatabaseResult<never>, {
+        readonly ok: false;
+    }>["error"]);
+    /**
+     * @override
+     * @readonly
+     * @type {"DatabaseSubscriptionError"}
+     */
+    override readonly name: "DatabaseSubscriptionError";
+    /**
+     * @readonly
+     * @type {string}
+     */
+    readonly code: string;
+    /**
+     * @readonly
+     * @type {Extract<DatabaseResult<never>, { readonly ok: false }>["error"] | undefined}
+     */
+    readonly detail: Extract<DatabaseResult<never>, {
+        readonly ok: false;
+    }>["error"] | undefined;
+}
+/**
+ * Pure native result reducer. A paged snapshot stays private until its
+ * terminal poll cursor. Poll groups are staged in order and published as one
+ * complete response; invalid input cannot partially replace the prior cut.
+ */
+export class DatabaseSubscriptionView {
+    /**
+     * @param {DatabaseScope} scope
+     * @param {Pick<DatabaseQueryOptions, "collection" | "predicate" | "limit" | "maximumRows">} options
+     */
+    constructor(scope: DatabaseScope, options: Pick<DatabaseQueryOptions, "collection" | "predicate" | "limit" | "maximumRows">);
+    /**
+     * @readonly
+     * @type {DatabaseViewBinding}
+     */
+    readonly binding: DatabaseViewBinding;
+    /** @returns {DatabaseViewSnapshot | undefined} */
+    getSnapshot(): DatabaseViewSnapshot | undefined;
+    /** @returns {DatabaseSubscriptionRequest} */
+    getRequest(): DatabaseSubscriptionRequest;
+    /**
+     * Discard every opaque position; the next request starts a fresh cut.
+     * @returns {void}
+     */
+    restart(): void;
+    /**
+     * @param {DatabaseSubscriptionResponse} response
+     * @returns {DatabaseViewSnapshot | undefined}
+     */
+    apply(response: DatabaseSubscriptionResponse): DatabaseViewSnapshot | undefined;
+    #private;
+}
+/**
+ * - `limit`: snapshot page size, between 1 and 128.
+ * - `maximumRows`: client memory bound, including all snapshot pages and later inserts.
+ * - `retryLimit`: bounded retries of read transport failures with the identical cursor.
+ */
+export type DatabaseQueryOptions = {
+    readonly collection: string;
+    readonly predicate: DatabaseQueryPredicate;
+    readonly limit?: number;
+    readonly maximumRows?: number;
+    readonly pollIntervalMs?: number;
+    readonly retryLimit?: number;
+    readonly retryDelayMs?: number;
+};
+export type DatabaseViewBinding = {
+    readonly scope: DatabaseScope;
+    readonly collection: string;
+    readonly predicate: DatabaseQueryPredicate;
+    readonly limit: number;
+};
+/**
+ * Local generation and server position of one complete authorized cut.
+ */
+export type DatabaseViewPosition = {
+    readonly generation: number;
+    readonly poll_cursor: string;
+    readonly sequence?: bigint;
+};
+export type DatabaseViewSnapshot = {
+    readonly rows: readonly DatabaseQueryRow[];
+    readonly position: DatabaseViewPosition;
+};
+/**
+ * `next`: an async consumer can acknowledge publication before the next poll.
+ */
+export type DatabaseQueryCallbacks = {
+    readonly next: (rows: readonly DatabaseQueryRow[], position: DatabaseViewPosition) => void | Promise<void>;
+    readonly error: (error: unknown) => void;
+    readonly reset: (reset: ReactiveReset<readonly DatabaseQueryRow[]>) => void;
+};
+export type DatabaseQuerySource = {
+    readonly key?: string | readonly unknown[];
+    readonly binding: DatabaseViewBinding;
+    readonly subscribe: (observer: DatabaseQueryCallbacks, context: ReactiveSubscriptionContext) => () => void;
+};
+import type { TerraBaseClient } from "./database.js";
+import type { DatabaseResult } from "./database-types.js";
+import type { DatabaseSubscriptionRequest } from "./database-types.js";
+import type { DatabaseSubscriptionResponse } from "./database-types.js";
+import type { DatabaseScope } from "./database-types.js";
+import type { DatabaseQueryPredicate } from "./database-types.js";
+import type { DatabaseQueryRow } from "./database-types.js";
+import type { ReactiveReset } from "./react/core.js";
+import type { ReactiveSubscriptionContext } from "./react/core.js";

package/types/database.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @param {TerraBaseClientConfig} config
+ * @returns {TerraBaseClient}
+ */
+export function createTerraBaseClient(config: TerraBaseClientConfig): TerraBaseClient;
+/** Current scoped document client. All mutations are server commits in one declared shard. */
+export class TerraBaseClient {
+    /** @param {TerraBaseClientConfig} config */
+    constructor(config: TerraBaseClientConfig);
+    /** @returns {DatabaseScope} */
+    get scope(): DatabaseScope;
+    /**
+     * @param {string} collection
+     * @param {string} document
+     * @param {DatabaseRequestOptions} [options]
+     * @returns {Promise<DatabaseResult<DatabasePoint>>}
+     */
+    read(collection: string, document: string, options?: DatabaseRequestOptions): Promise<DatabaseResult<DatabasePoint>>;
+    /**
+     * @param {string} collection
+     * @param {DatabaseQuery} query
+     * @param {DatabaseRequestOptions} [options]
+     * @returns {Promise<DatabaseResult<DatabaseQueryPage>>}
+     */
+    query(collection: string, query: DatabaseQuery, options?: DatabaseRequestOptions): Promise<DatabaseResult<DatabaseQueryPage>>;
+    /**
+     * @param {string} collection
+     * @param {DatabaseSubscriptionRequest} request
+     * @param {DatabaseRequestOptions} [options]
+     * @returns {Promise<DatabaseResult<DatabaseSubscriptionResponse>>}
+     */
+    subscription(collection: string, request: DatabaseSubscriptionRequest, options?: DatabaseRequestOptions): Promise<DatabaseResult<DatabaseSubscriptionResponse>>;
+    /**
+     * Prepare once and retain this identity for exact retry and durable status resolution.
+     * @param {DatabaseCommit} commit
+     * @returns {Promise<PreparedDatabaseCommit>}
+     */
+    prepareCommit(commit: DatabaseCommit): Promise<PreparedDatabaseCommit>;
+    /**
+     * @param {PreparedDatabaseCommit} prepared
+     * @param {DatabaseRequestOptions} [options]
+     * @returns {Promise<DatabaseResult<DatabaseCommitReceipt>>}
+     */
+    commit(prepared: PreparedDatabaseCommit, options?: DatabaseRequestOptions): Promise<DatabaseResult<DatabaseCommitReceipt>>;
+    /**
+     * Unknown, pending and expired outcomes remain unresolved; an absent document proves no abort.
+     * @param {DatabaseTransactionIdentity} identity
+     * @param {DatabaseRequestOptions} [options]
+     * @returns {Promise<DatabaseResult<DatabaseTransactionStatus>>}
+     */
+    transactionStatus(identity: DatabaseTransactionIdentity, options?: DatabaseRequestOptions): Promise<DatabaseResult<DatabaseTransactionStatus>>;
+    #private;
+}
+/**
+ * - `apiKey`: native service key used for authenticated Atlas discovery and the selected regional listener.
+ * - `endpoint`: a provisioned direct origin. Omit to use authenticated native Atlas discovery.
+ * - `discoveryTimeoutMs`: bounds the canonical Atlas request within the complete operation deadline.
+ */
+export type TerraBaseClientConfig = DatabaseScope & {
+    readonly apiKey: string | (() => string | Promise<string>);
+    readonly endpoint?: string;
+    readonly discoveryTimeoutMs?: number;
+    readonly requestTimeoutMs?: number;
+    readonly fetch?: FetchLike;
+};
+export type DatabaseRequestOptions = {
+    readonly signal?: AbortSignal;
+};
+export type PreparedDatabaseCommit = DatabaseTransactionIdentity & {
+    readonly [preparedBrand]: true;
+};
+import type { DatabaseScope } from "./database-types.js";
+import type { DatabasePoint } from "./database-types.js";
+import type { DatabaseResult } from "./database-types.js";
+import type { DatabaseQuery } from "./database-types.js";
+import type { DatabaseQueryPage } from "./database-types.js";
+import type { DatabaseSubscriptionRequest } from "./database-types.js";
+import type { DatabaseSubscriptionResponse } from "./database-types.js";
+import type { DatabaseCommit } from "./database-types.js";
+import type { DatabaseCommitReceipt } from "./database-types.js";
+import type { DatabaseTransactionIdentity } from "./database-types.js";
+import type { DatabaseTransactionStatus } from "./database-types.js";
+import type { FetchLike } from "./config.js";
+/**
+ * - `apiKey`: native service key used for authenticated Atlas discovery and the selected regional listener.
+ * - `endpoint`: a provisioned direct origin. Omit to use authenticated native Atlas discovery.
+ * - `discoveryTimeoutMs`: bounds the canonical Atlas request within the complete operation deadline.
+ * @typedef {DatabaseScope & {
+ *   readonly apiKey: string | (() => string | Promise<string>);
+ *   readonly endpoint?: string;
+ *   readonly discoveryTimeoutMs?: number;
+ *   readonly requestTimeoutMs?: number;
+ *   readonly fetch?: FetchLike;
+ * }} TerraBaseClientConfig
+ */
+/** @typedef {{ readonly signal?: AbortSignal }} DatabaseRequestOptions */
+declare const preparedBrand: unique symbol;
+export {};