@palbase/backend 17.3.0 → 18.0.0

package/dist/{index-J1tnAnFj.d.ts → endpoint-B0LpZixz.d.cts}

@@ -1,4 +1,3 @@
-import { Tables, TableTypes } from './db/env.js';
 import { ZodSchema, z } from 'zod';
 
 /** Supported HTTP methods for endpoints. */
@@ -216,7 +215,7 @@ interface TxWireOp {
     lock?: "update";
     guard?: TxWireGuard;
 }
-/** The request body of `POST /internal-api/db/tx`. */
+/** The plan the engine executes on the request's own transaction. */
 interface TxPlanBody {
     ops: TxWireOp[];
 }
@@ -225,7 +224,7 @@ interface TxPlanOpResult {
     rows: Record<string, unknown>[];
     rows_affected: number;
 }
-/** The response body of `POST /internal-api/db/tx`. */
+/** One result per op, in plan order. */
 interface TxPlanResponse {
     results: TxPlanOpResult[];
 }
@@ -430,11 +429,31 @@ declare function dec(by: number): TxColumnExpr;
  * (e.g. `new Conflict("locked", "title_locked", { retryAfter: 30 })`). It rides
  * through to the iOS typed enum's associated value.
  */
+/**
+ * The brand that identifies an HttpError ACROSS SDK instances.
+ *
+ * A process legitimately holds more than one copy of this SDK — the runtime
+ * loads the engine from its own node_modules while the tenant's bundle carries
+ * an inlined copy, which is why the controller registry and the error registry
+ * are both anchored on `Symbol.for`. The one place that did not follow the
+ * pattern was the engine's catch: `err instanceof HttpError` compares CLASS
+ * IDENTITY, so a `throw new NotFound()` from the bundle's copy did not match
+ * the engine's copy and every typed error in every deployed backend degraded to
+ * `500 internal_error`. Measured through the edge on a real deploy: a route
+ * throwing `NotFound` answered 500 while the runtime's own log printed the
+ * error object with `status: 404` right beside it.
+ *
+ * `Symbol.for` puts this in the cross-realm registry, so every copy of the SDK
+ * agrees on it by VALUE rather than by identity.
+ */
+declare const HTTP_ERROR_BRAND: unique symbol;
 declare class HttpError extends Error {
     readonly status: number;
     readonly error: string;
     readonly errorDescription: string;
     readonly data?: unknown;
+    /** See {@link HTTP_ERROR_BRAND} — how the engine recognises this across SDK copies. */
+    readonly [HTTP_ERROR_BRAND] = true;
     constructor(status: number, error: string, errorDescription: string, data?: unknown);
     /**
      * Serialize to the standard Palbase error response format.
@@ -685,14 +704,28 @@ interface PalbaseBatchSetOverridesResult {
 }
 /** File object returned by storage operations. */
 interface PalbaseFileObject {
+    /** The object's path inside its bucket. `name` is the same value. */
+    path: string;
     name: string;
-    id: string;
     bucket: string;
-    createdAt: string;
-    updatedAt: string;
     size: number;
     contentType: string;
-    metadata: Record<string, unknown>;
+    /** SHA-256 of the stored bytes, computed as they were written. */
+    checksum: string;
+    /** Present for images: the decoded dimensions of the ORIGINAL. */
+    width?: number;
+    height?: number;
+    /**
+     * A ThumbHash — a few dozen bytes that render as a blurred preview while the
+     * real image loads, with no second request to fetch it.
+     */
+    thumbhash?: string;
+    /**
+     * Declared rendition name → the URL that serves it. Produced at upload from
+     * what `config/storage.ts` declared, so this is a lookup rather than a
+     * transform anyone pays for per request.
+     */
+    variants: Record<string, string>;
 }
 /** Storage signed URL response. */
 interface PalbaseSignedUrlResponse {
@@ -1367,10 +1400,33 @@ interface PalbaseBucketClient {
     upload(path: string, file: Blob | ArrayBuffer | ReadableStream, options?: PalbaseUploadOptions): Promise<PalbaseResult<PalbaseFileObject>>;
     /** Download a file as a Blob. */
     download(path: string): Promise<PalbaseResult<Blob>>;
-    /** Construct the public URL for a file (sync — no network call). */
-    getPublicUrl(path: string, options?: PalbaseTransformOptions): string;
-    /** Create a time-limited signed URL. */
-    createSignedUrl(path: string, expiresIn: number): Promise<PalbaseResult<PalbaseSignedUrlResponse>>;
+    /**
+     * The public URL for an object, or for one of its declared renditions.
+     *
+     * `variant` names a rendition from `config/storage.ts` — NOT arbitrary
+     * dimensions. Renditions are produced at upload and served as immutable
+     * objects, so a URL here costs nothing to serve and caches forever; an
+     * arbitrary size would be a transform on the request path, one public URL
+     * away from a CPU amplification attack.
+     *
+     * Asking for a variant the bucket does not declare is an error rather than a
+     * silent fall back to the original: an app that requested a 200px thumbnail
+     * and quietly received a 5 MB photograph works, looks right, and is found
+     * months later on a bandwidth bill.
+     */
+    getPublicUrl(path: string, options?: {
+        variant?: string;
+    }): string;
+    /**
+     * A time-limited URL for a private object.
+     *
+     * The duration is NAMED (`{ expiresIn: "1h" }`) rather than a bare number,
+     * because "3600" reads as seconds to whoever wrote it and as minutes to
+     * whoever maintains it. Same human spelling `fileSizeLimit` takes.
+     */
+    createSignedUrl(path: string, options: {
+        expiresIn: string;
+    }): Promise<PalbaseResult<PalbaseSignedUrlResponse>>;
     /** List objects in the bucket (optionally filtered by prefix). */
     list(prefix?: string, options?: PalbaseListOptions): Promise<PalbaseResult<PalbaseFileObject[]>>;
     /** Delete one or more objects. */
@@ -1448,6 +1504,21 @@ interface PalbaseFlagsClient {
     getVariant(flagName: string, context?: PalbaseFlagContext): Promise<PalbaseResult<PalbaseFlagVariant>>;
     /** Get all flags for the project. */
     getAll(context?: PalbaseFlagContext): Promise<PalbaseResult<PalbaseFlag[]>>;
+    /**
+     * Resolve a flag's value, with an optional fallback.
+     *
+     * `get(key)` · `get(key, default)` · `get(key, ctx)` · `get(key, default, ctx)`.
+     * The default is substituted when the flag is absent AND when the flags
+     * service is unreachable — a product that hides a feature because a lookup
+     * timed out is behaving correctly.
+     *
+     * Declared here as of 2026-08-15. The client has always had it and its tests
+     * have always covered it, but the interface did not: `Flags.get("x")` was a
+     * type error in a handler and worked at runtime. That is the same gap as
+     * `Documents.doc(...)` — declared and never implemented — seen from the other
+     * side, and moving the implementation into this package is what surfaced it.
+     */
+    get(flagName: string, defaultOrContext?: PalbaseFlagValue | PalbaseFlagContext, maybeContext?: PalbaseFlagContext): Promise<PalbaseResult<PalbaseFlagValue>>;
     /**
      * Set (or replace) a single feature-flag override for the CURRENT REQUEST
      * USER. No userId argument — the override is bound to the signed-in user the
@@ -1745,7 +1816,8 @@ interface DBOps {
 /** Database client interface injected into endpoint context. */
 interface DBClient extends DBOps {
     /**
-     * Run a whole transaction in ONE request (`POST /internal-api/db/tx`).
+     * Run a whole transaction as ONE plan, executed on the request's own
+     * transaction inside a savepoint.
      *
      * The low-level seam behind `Database.transaction(plan)`: the SDK builds the
      * plan, this sends it, and the broker executes every operation inside a single
@@ -1782,6 +1854,22 @@ interface Logger {
  * value (objects, arrays, numbers, booleans, strings) round-trips. `get<T>`
  * therefore returns `T | null` rather than `string | null`.
  */
+/**
+ * The tenant's secrets, as a controller sees them.
+ *
+ * `get` answers null for a name this tenant has not set — including every name
+ * the STACK holds, which is not an accident of storage but the shape of the
+ * surface: the runtime is handed a tenant client, and there is no route that
+ * returns a platform secret's value at all. Tenant code cannot read the keys
+ * the stack signs with, by mistake or on purpose.
+ *
+ * Reads are cheap. The value is held in the process and dropped when the deploy
+ * pointer reports a new secrets generation, so a rotated secret arrives without
+ * a restart and a hot path pays a map lookup.
+ */
+interface SecretsService {
+    get(name: string): Promise<string | null>;
+}
 interface CacheClient {
     /** Read a value. Returns `null` on a cache miss. */
     get<T = unknown>(key: string): Promise<T | null>;
@@ -1826,6 +1914,11 @@ interface PalbaseQuerySnapshot<T = Record<string, unknown>> {
     docs: PalbaseDocumentSnapshot<T>[];
     empty: boolean;
     size: number;
+    /** Firestore-shaped change list. Every document of a one-shot read is "added". */
+    docChanges(): Array<{
+        type: "added";
+        doc: PalbaseDocumentSnapshot<T>;
+    }>;
 }
 /** Comparison operators supported by docs.where(). */
 type PalbaseWhereOperator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "in" | "array-contains";
@@ -1836,6 +1929,8 @@ interface PalbaseDocumentRef<T = Record<string, unknown>> {
     get(): Promise<PalbaseResult<PalbaseDocumentSnapshot<T>>>;
     update(data: Partial<T>): Promise<PalbaseResult<void>>;
     delete(): Promise<PalbaseResult<void>>;
+    /** A subcollection of this document — `rooms/1` → `rooms/1/messages`. */
+    collection<C extends Record<string, unknown> = Record<string, unknown>>(name: string): PalbaseCollectionRef<C>;
 }
 /** Collection reference exposed by Documents.collection(...). */
 interface PalbaseCollectionRef<T = Record<string, unknown>> {
@@ -1849,8 +1944,22 @@ interface PalbaseCollectionRef<T = Record<string, unknown>> {
 }
 /** Docs client surface available on the Documents singleton. */
 interface PalbaseDocsClient {
-    collection<T = Record<string, unknown>>(path: string): PalbaseCollectionRef<T>;
-    doc<T = Record<string, unknown>>(path: string): PalbaseDocumentRef<T>;
+    collection<T extends Record<string, unknown> = Record<string, unknown>>(path: string): PalbaseCollectionRef<T>;
+    doc<T extends Record<string, unknown> = Record<string, unknown>>(path: string): PalbaseDocumentRef<T>;
+    /**
+     * Apply up to 500 writes in one call.
+     *
+     * Declared here because the client has always offered it: an interface that
+     * described less than the implementation is how `Documents.doc(...)` came to
+     * be declared and never implemented — the gap this whole move exists to close.
+     */
+    batch(operations: Array<{
+        op: "set" | "update" | "delete";
+        ref: {
+            path: string;
+        };
+        data?: unknown;
+    }>): Promise<PalbaseResult<void>>;
 }
 /** Calling-client metadata, derived from request headers.
  *
@@ -2002,656 +2111,4 @@ type Middleware = (ctx: MiddlewareContext, next: () => Promise<void>) => Promise
  */
 type AuthSpec = boolean | Partial<AuthConfig>;
 
-/** On delete action for foreign key references. */
-type OnDeleteAction = 'cascade' | 'set null' | 'restrict' | 'no action';
-/**
- * The ON DELETE actions permitted on a foreign key to the built-in auth users
- * (`auth.users`). Both let a user's rows be removed (`cascade`) or detached
- * (`set null`) when the account is erased; `restrict` / `no action` would BLOCK
- * erasure and are therefore excluded. This is the CLIENT-SIDE mirror of the
- * server's auth-FK deletion policy — the server (validateAuthUserFK) is the real
- * boundary, this narrows the type so the common mistake is caught at compile time.
- */
-type AuthUserOnDelete = Extract<OnDeleteAction, 'cascade' | 'set null'>;
-/** Column type identifiers. */
-type ColumnType = 'uuid' | 'text' | 'integer' | 'bigint' | 'numeric' | 'boolean' | 'timestamp' | 'jsonb' | 'enum';
-/** Base column definition shared by all column types. */
-interface ColumnDef {
-    type: ColumnType;
-    nullable: boolean;
-    primaryKey: boolean;
-    defaultValue?: unknown;
-    defaultRandom?: boolean;
-    defaultNow?: boolean;
-    references?: {
-        table: string;
-        column: string;
-    };
-    onDeleteAction?: OnDeleteAction;
-    enumName?: string;
-    enumValues?: string[];
-    unique?: boolean;
-}
-declare const __colKind: unique symbol;
-declare const __colNullable: unique symbol;
-declare const __colHasDefault: unique symbol;
-declare const __colEnumValues: unique symbol;
-declare const __colPayload: unique symbol;
-/**
- * Fluent column builder with phantom type params:
- *  K — ColumnType literal (e.g. "text", "integer")
- *  N — boolean: true when nullable() has been called last (false = NOT NULL)
- *  D — boolean: true when a default has been set
- *  E — enum value union (never for non-enum columns)
- *  P — jsonb payload shape (unknown unless jsonb<T>() supplied one)
- *
- * All five params have defaults so bare `ColumnBuilder` (no args) still
- * satisfies `Record<string, ColumnBuilder>` in schema.ts without modification.
- *
- * The five `declare readonly` brand fields carry the phantom types into the
- * structural shape so that conditional types like ColValue<C> can discriminate
- * on K without requiring runtime values on those fields.
- */
-declare class ColumnBuilder<K extends ColumnType = ColumnType, N extends boolean = boolean, D extends boolean = boolean, E = unknown, P = unknown> {
-    readonly [__colKind]: K;
-    readonly [__colNullable]: N;
-    readonly [__colHasDefault]: D;
-    readonly [__colEnumValues]: E;
-    readonly [__colPayload]: P;
-    readonly _def: ColumnDef;
-    constructor(type: K, existingDef?: ColumnDef);
-    /** Mark this column as the primary key. */
-    primaryKey(): ColumnBuilder<K, N, D, E, P>;
-    /** Mark this column as NOT NULL (default). */
-    notNull(): ColumnBuilder<K, false, D, E, P>;
-    /** Allow NULL values. */
-    nullable(): ColumnBuilder<K, true, D, E, P>;
-    /** Set a default value. */
-    default(value: unknown): ColumnBuilder<K, N, true, E, P>;
-    /** UUID: generate a random default (gen_random_uuid()). */
-    defaultRandom(): ColumnBuilder<K, N, true, E, P>;
-    /** Timestamp: default to now(). */
-    defaultNow(): ColumnBuilder<K, N, true, E, P>;
-    /** Add a foreign key reference. */
-    references(table: string, column: string): ColumnBuilder<K, N, D, E, P>;
-    /**
-     * Add a real DB-level foreign key to the built-in auth users
-     * (`REFERENCES auth.users(id)`), so a column like `user_id` gets true
-     * database cascade/integrity instead of app-layer-only. Sugar for
-     * `.references("auth.users", "id")`.
-     *
-     * `auth.users` lives in the SAME tenant database (palauth-owned), so this is
-     * a genuine cross-schema integrity constraint scoped to THIS tenant's users.
-     * The referenced `auth.users.id` is `text` (palauth ids are `usr_<uuid>`), so
-     * the referencing column must be `text()` too.
-     *
-     * ON DELETE is REQUIRED here and may only be `cascade` or `set null`: an
-     * account-erasure request must never be blocked by a lingering FK, so
-     * `restrict` / `no action` are not accepted (they don't type-check). Example:
-     * `text().notNull().referencesAuthUser("cascade")`, or
-     * `text().nullable().referencesAuthUser("set null")`. The server
-     * (validateAuthUserFK) enforces this — and the remaining rules the type can't
-     * express (referencing column is text, `set null` needs a nullable column) —
-     * as the real boundary; this signature is the compile-time DX mirror.
-     */
-    referencesAuthUser(onDelete: AuthUserOnDelete): ColumnBuilder<K, N, D, E, P>;
-    /**
-     * Add a real DB-level foreign key to the canonical, server-minted installation
-     * anchor (`REFERENCES auth.installations(id)`) — the app-scoped verified-device
-     * root (`ins_...`). Sugar for `.references("auth.installations", "id")`.
-     *
-     * An installation is an APP INSTALL, not a user: this FK is NOT user ownership.
-     * A user-owned row STILL needs its own `.referencesAuthUser(...)` FK so account
-     * erasure removes it — an installation reference alone does not tie a row to a
-     * user's deletion. Use this only for install-scoped state (device prefs, push
-     * routing, …), alongside a separate auth-user FK where the row is user-owned.
-     *
-     * `auth.installations` lives in the SAME tenant DB (palauth-owned); its `id` is
-     * `text` (`ins_<uuid>`), so the referencing column must be `text()` too. ON
-     * DELETE is REQUIRED and may only be `cascade` or `set null` (same allowed set
-     * as an auth-user FK): an installation revoke / orphan cleanup must never be
-     * blocked by a lingering FK. The server (validateAuthAnchorFK) is the real
-     * boundary; this signature is the compile-time DX mirror.
-     */
-    referencesInstallation(onDelete: AuthUserOnDelete): ColumnBuilder<K, N, D, E, P>;
-    /** Set the ON DELETE action for a foreign key reference. */
-    onDelete(action: OnDeleteAction): ColumnBuilder<K, N, D, E, P>;
-    /** Add a single-column UNIQUE constraint. */
-    unique(): ColumnBuilder<K, N, D, E, P>;
-}
-/**
- * Extracts the TypeScript value type for a column, respecting nullability.
- * - "uuid" | "text" | "timestamp" | "bigint" | "numeric" → string (or string | null when N = true)
- *   Note: bigint/numeric surface as string — JS number loses precision past 2^53,
- *   and pgx/PostgREST serialize int8/numeric as strings. App code uses
- *   BigInt(row.amount) for bigint, or a decimal lib for numeric.
- * - "integer" → number
- * - "boolean" → boolean
- * - "jsonb" → P (the dev-supplied payload shape from jsonb<T>(), else unknown)
- * - "enum" → E (the union of literal values)
- */
-type ColValue<C> = C extends ColumnBuilder<'uuid' | 'text' | 'timestamp' | 'bigint' | 'numeric', infer N, infer _D, infer _E, infer _P> ? N extends true ? string | null : string : C extends ColumnBuilder<'integer', infer N, infer _D, infer _E, infer _P> ? N extends true ? number | null : number : C extends ColumnBuilder<'boolean', infer N, infer _D, infer _E, infer _P> ? N extends true ? boolean | null : boolean : C extends ColumnBuilder<'jsonb', infer N, infer _D, infer _E, infer P> ? N extends true ? P | null : P : C extends ColumnBuilder<'enum', infer N, infer _D, infer E, infer _P> ? N extends true ? E | null : E : never;
-/**
- * True when a column is optional on INSERT:
- *  - nullable columns (N = true) — the DB allows NULL so the field may be omitted
- *  - columns with a default (D = true) — the DB fills in the value when absent
- */
-type ColIsOptionalOnInsert<C> = C extends ColumnBuilder<infer _K, true, infer _D, infer _E> ? true : C extends ColumnBuilder<infer _K, infer _N, true, infer _E> ? true : false;
-/** Create a UUID column. */
-declare function uuid(): ColumnBuilder<'uuid', false, false, never>;
-/** Create a TEXT column. */
-declare function text(): ColumnBuilder<'text', false, false, never>;
-/** Create an INTEGER column. Emits int4 (max ~2.1B). */
-declare function integer(): ColumnBuilder<'integer', false, false, never>;
-/**
- * Create a BIGINT column (Postgres int8, max ~9.2×10^18).
- * Surfaces as `string` in row/insert types — JS number loses precision past 2^53
- * and pgx/PostgREST serialize int8 as a JSON string. Use BigInt(row.column) in app code.
- */
-declare function bigint(): ColumnBuilder<'bigint', false, false, never>;
-/**
- * Create a NUMERIC column (Postgres `numeric`/`decimal`, arbitrary precision).
- * For exact fractional values (money with cents as a decimal, rates, weights)
- * where int4/int8 don't fit. Surfaces as `string` in row/insert types — JS
- * number can't hold arbitrary-precision decimals without rounding, and
- * pgx/PostgREST serialize numeric as a JSON string. Parse with a decimal lib
- * (or BigInt for scaled integers) in app code.
- */
-declare function numeric(): ColumnBuilder<'numeric', false, false, never>;
-/** Create a BOOLEAN column. */
-declare function boolean(): ColumnBuilder<'boolean', false, false, never>;
-/** Create a TIMESTAMP column. */
-declare function timestamp(): ColumnBuilder<'timestamp', false, false, never>;
-/**
- * Create a JSONB column. Pass a payload type to make the generated row/insert
- * type concrete instead of `unknown`:
- *
- *   tags: jsonb<string[]>()           // row.tags: string[]
- *   meta: jsonb<{ tier: string }>()   // row.meta: { tier: string }
- *   raw:  jsonb()                      // row.raw: unknown (back-compat)
- *
- * The runtime accepts a plain JS object/array directly (no JSON.stringify); the
- * generic only refines the TYPE the env codegen emits.
- */
-declare function jsonb<T = unknown>(): ColumnBuilder<'jsonb', false, false, never, T>;
-/**
- * Create an ENUM column.
- * @param name   The PostgreSQL enum type name (used in DDL).
- * @param values A readonly tuple of valid string values — kept `const` so the
- *               union `V[number]` is as narrow as possible.
- */
-declare function enumType<const V extends readonly string[]>(name: string, values: V): ColumnBuilder<'enum', false, false, V[number]>;
-
-/**
- * policy.ts — the RLS policy authoring DSL.
- *
- * `policy(name)` returns a fluent builder that mirrors the `ColumnBuilder`
- * style in columns.ts: each chainable method mutates the underlying
- * definition and returns the builder so calls compose. The terminal value is
- * a plain {@link PolicyDef} — the exact JSON shape the runtime's
- * `schema_extract.js` reads off the bundled module and the Go side parses into
- * `PolicyJSON` (CONTRACT-POLICY).
- *
- * @example
- * import { policy } from "@palbase/backend";
- *
- * policy("owner_select")
- *   .for("select")
- *   .to("authenticated")
- *   .using("owner = (select auth.uid())");
- */
-/** The SQL command a policy applies to. `"all"` covers SELECT/INSERT/UPDATE/DELETE. */
-type PolicyCommand = "all" | "select" | "insert" | "update" | "delete";
-/** Whether a policy is permissive (OR-combined, the default) or restrictive
- * (AND-combined). Mirrors Postgres `CREATE POLICY ... AS PERMISSIVE|RESTRICTIVE`. */
-type PolicyMode = "permissive" | "restrictive";
-/**
- * The compiled, serializable policy definition — the EXACT shape consumed by
- * `schema_extract.js` → Go `PolicyJSON` (CONTRACT-POLICY).
- *
- * - `roles`: the DB roles this policy applies to (`TO` clause). An empty array
- *   means the policy applies to PUBLIC (all roles) — the Postgres default.
- * - `using`: the `USING (...)` row-visibility expression, or `null` when none.
- * - `withCheck`: the `WITH CHECK (...)` write-validation expression, or `null`.
- * - `permissive`: `true` for `AS PERMISSIVE` (default), `false` for restrictive.
- */
-interface PolicyDef {
-    name: string;
-    command: PolicyCommand;
-    roles: string[];
-    using: string | null;
-    withCheck: string | null;
-    permissive: boolean;
-}
-/**
- * Fluent RLS policy builder.
- *
- * Defaults (documented, applied at construction):
- *  - `command`: `"all"` — applies to every SQL command unless `.for(...)` narrows it.
- *  - `roles`: `["authenticated"]` — the common case is "rule applies to signed-in
- *    users". Call `.to(...)` to override; pass `.to()` with no roles (or never
- *    call it after a reset) to target PUBLIC.
- *  - `using` / `withCheck`: `null` — no row filter / write check until set.
- *  - `permissive`: `true` — `AS PERMISSIVE` (policies OR together).
- *
- * Each method mutates `_def` in place and returns `this`, so the chain is a
- * single builder instance (no per-call allocation, like a tagged-template
- * compile target). The terminal `PolicyDef` is read directly off `_def` by
- * `schema_extract.js`.
- */
-declare class PolicyBuilder {
-    readonly _def: PolicyDef;
-    constructor(name: string);
-    /** Restrict the policy to a single SQL command (default `"all"`). */
-    for(command: PolicyCommand): this;
-    /**
-     * Set the DB roles the policy applies to (the `TO` clause), replacing any
-     * previously-set roles. Call with no arguments to target PUBLIC (all roles).
-     *
-     * @example
-     * policy("p").to("authenticated")
-     * policy("p").to("authenticated", "service_role")
-     * policy("p").to() // PUBLIC
-     */
-    to(...roles: string[]): this;
-    /** Set the `USING (...)` row-visibility expression (raw SQL). */
-    using(sqlExpr: string): this;
-    /** Set the `WITH CHECK (...)` write-validation expression (raw SQL). */
-    withCheck(sqlExpr: string): this;
-    /** Set the policy mode: `"permissive"` (default, OR-combined) or
-     * `"restrictive"` (AND-combined). */
-    as(mode: PolicyMode): this;
-}
-/**
- * Start authoring an RLS policy. Returns a {@link PolicyBuilder}; the resulting
- * `PolicyBuilder` is accepted directly in a table's `policies: [...]` array
- * (its `_def` is read at schema-extract time).
- *
- * @param name The policy name. Palbase reconciliation keys policies by
- *             `(table, name)`, so names must be unique per table.
- */
-declare function policy(name: string): PolicyBuilder;
-
-/**
- * Postgres extensions a Palbase project can enable from its schema.
- *
- * Extensions are config-as-code: declare them in `defineSchema({ extensions })`
- * and the deploy installs them (CREATE EXTENSION … SCHEMA extensions) using the
- * deploy path's privileged connection. They are NOT toggled live from Studio —
- * CREATE EXTENSION requires a superuser role that only the deploy path holds.
- *
- * The list is an allowlist (a string-literal union) so editors autocomplete the
- * supported names and a typo fails typecheck. It is intentionally extensible:
- * add a name here (+ confirm the base image ships it) to support more.
- */
-declare const PALBASE_EXTENSIONS: readonly ["vector", "pg_trgm", "unaccent", "citext", "postgis", "cube", "earthdistance", "hstore", "ltree", "btree_gist", "pg_cron", "pgcrypto", "uuid-ossp"];
-/** A Postgres extension supported by Palbase (allowlist union). */
-type PalbaseExtension = (typeof PALBASE_EXTENSIONS)[number];
-/**
- * Extensions that depend on another extension. The deploy installs
- * dependencies first; declaring `earthdistance` without `cube` still works
- * because the deploy resolves the order, but listing both is clearer.
- */
-declare const EXTENSION_DEPENDENCIES: Partial<Record<PalbaseExtension, PalbaseExtension[]>>;
-/** Runtime guard: is `name` a supported Palbase extension? */
-declare function isPalbaseExtension(name: string): name is PalbaseExtension;
-
-/**
- * A named raw-SQL DDL object declared in db/schema.ts for anything the typed DSL
- * cannot express (EXCLUDE, CHECK, partial/expression indexes, triggers, views).
- * The deploy emits `up` verbatim on the privileged DDL connection — same trust
- * posture as policy().using(). Tracked by NAME (not by diffing the body), so a
- * changed body needs a new name or an explicit drop+add.
- */
-interface RawConstraintDef {
-    name: string;
-    up: string;
-    down?: string;
-}
-declare function raw(name: string, up: string, opts?: {
-    down?: string;
-}): RawConstraintDef;
-
-/**
- * A map of column builders keyed by column name — the value you write under
- * the `columns` key of `defineSchema({ tables: { <name>: { columns } } })`.
- *
- * The default `Record<string, ColumnBuilder>` keeps bare references compiling
- * without a type argument.
- */
-type ColumnMap = Record<string, ColumnBuilder>;
-/**
- * The author-facing value written under each table key:
- * `{ columns, rls?, policies? }`.
- *
- * - `columns`: the column map (required).
- * - `rls`: enable + FORCE row-level security on this table. **Defaults to
- *   `true`**, and is forced on when `policies` is non-empty. A table with RLS
- *   and no policies is deny-all, which is the starting state: nothing reads it
- *   until a policy says who may. Set `rls: false` only for a genuinely public
- *   table — it is an explicit opt-out that a reviewer can grep for, not
- *   something you get by forgetting.
- * - `policies`: the RLS policies for this table, authored with `policy(name)`.
- *   Each entry may be a {@link PolicyBuilder} (the normal `policy(...)` chain)
- *   or a raw {@link PolicyDef} object.
- *
- * The `C` type parameter preserves the precise per-column phantom types so the
- * typed `Database.tables.*` surface keeps inferring insert/row shapes.
- */
-interface TableInput<C extends ColumnMap = ColumnMap> {
-    columns: C;
-    rls?: boolean;
-    policies?: (PolicyBuilder | PolicyDef)[];
-    /** Composite/named primary key (ordered column names). Omit for single-column inline .primaryKey(). */
-    primaryKey?: string[];
-    /** Named multi-column UNIQUE constraints. */
-    unique?: {
-        name: string;
-        columns: string[];
-    }[];
-    /** Named raw-SQL DDL objects (EXCLUDE, triggers, views) that the typed DSL cannot express. */
-    raw?: RawConstraintDef[];
-    /**
-     * Named first-class CHECK constraints. Diffed by NAME with a BODY compare:
-     * a changed `expr` (after pg normalization) recreates the constraint
-     * (DROP + ADD). `expr` is trusted SQL emitted verbatim (like policy USING),
-     * `name` is identifier-validated.
-     */
-    checks?: {
-        name: string;
-        expr: string;
-    }[];
-    /**
-     * Plain (non-unique) btree indexes over an ordered column list, emitted as
-     * standalone `CREATE INDEX [IF NOT EXISTS] name ON table (col1, col2)`
-     * statements (NOT a table clause — a separate migration statement category).
-     * Structural compare by NAME (no expression normalization). `name` and each
-     * column are identifier-validated by the Go differ.
-     *
-     * Scope: columns-only plain btree. Partial (`where`) and expression indexes
-     * are a deliberate follow-up — modelling them needs the same raw-SQL
-     * normalization round-trip CHECK uses (Task 10), so they are NOT in this
-     * type yet to avoid a half-working partial-index path.
-     */
-    indexes?: {
-        name: string;
-        columns: string[];
-    }[];
-}
-/**
- * A table definition — the runtime value the Go runtime's `schema_extract.js`
- * reads. It keys tables by `tableDef.name`, reads `tableDef.columns` for the
- * column DDL, and `tableDef.rls` + `tableDef.policies` for RLS.
- *
- * `defineSchema` derives `name` from the object key, so authors never repeat
- * the table name. `rls`/`policies` are always present after normalization
- * (defaulted to `true`/`[]`).
- *
- * The `C` type parameter preserves the precise per-column phantom types so that
- * downstream mapped types (InsertShape, RowShape) can discriminate on them.
- */
-interface TableDef<C extends ColumnMap = ColumnMap> {
-    name: string;
-    columns: C;
-    rls: boolean;
-    policies: PolicyDef[];
-    primaryKey?: string[];
-    unique?: {
-        name: string;
-        columns: string[];
-    }[];
-    /** Named raw-SQL DDL objects emitted verbatim on deploy. Tracked by name. */
-    raw?: RawConstraintDef[];
-    /** Named first-class CHECK constraints. Diffed by name + (normalized) body. */
-    checks?: {
-        name: string;
-        expr: string;
-    }[];
-    /** Plain btree indexes (columns-only), emitted as standalone CREATE INDEX. Diffed by name. */
-    indexes?: {
-        name: string;
-        columns: string[];
-    }[];
-}
-/**
- * A schema definition containing multiple tables, keyed by table name.
- *
- * The `T` type parameter preserves the exact `TableDef<...>` type for each
- * table so that `SchemaDef["tables"]["rooms"]` resolves to the precise
- * `TableDef<{ id: ColumnBuilder<'uuid', false, true, never>; ... }>`.
- */
-interface SchemaDef<T extends Record<string, TableDef> = Record<string, TableDef>> {
-    tables: T;
-    /** Postgres extensions to install on deploy. Normalized to `[]` when absent. */
-    extensions: PalbaseExtension[];
-}
-/** The author-facing input to `defineSchema` — a `tables` map whose keys are
- * the table names and whose values are `{ columns, rls?, policies? }`, plus an
- * optional `extensions` allowlist. */
-interface SchemaInput<T extends Record<string, TableInput> = Record<string, TableInput>> {
-    tables: T;
-    /**
-     * Postgres extensions to enable for this project, e.g. `["vector"]`.
-     * Config-as-code: installed by the deploy (CREATE EXTENSION … SCHEMA
-     * extensions) with the privileged deploy connection. The type is an
-     * allowlist union, so unsupported names fail typecheck.
-     */
-    extensions?: PalbaseExtension[];
-}
-/** Map the author's `{ tables: { <name>: { columns } } }` input to the
- * `{ tables: { <name>: TableDef<columns> } }` runtime/type shape, threading the
- * per-table column map `T[K]["columns"]` so column-level inference survives. */
-type TablesFromInput<T extends Record<string, TableInput>> = {
-    [K in keyof T]: TableDef<T[K]["columns"]>;
-};
-/**
- * Define a schema. The table NAME comes from the object key. Each table value
- * is `{ columns, rls?, policies? }`:
- *
- *   export default defineSchema({
- *     tables: {
- *       todos: {
- *         columns: {
- *           id:    uuid().primaryKey().defaultRandom(),
- *           owner: text().notNull(),
- *           title: text().notNull(),
- *         },
- *         rls: true,
- *         policies: [
- *           policy("owner_all").for("all").to("authenticated")
- *             .using("owner = (select auth.uid())")
- *             .withCheck("owner = (select auth.uid())"),
- *         ],
- *       },
- *     },
- *   });
- *
- * The returned value is
- * `{ tables: { todos: { name, columns, rls, policies } } }` — the exact shape
- * the runtime schema extractor parses. Per-column phantom types are preserved
- * so `Database.tables.todos.insert({...})` stays typed.
- *
- * RLS normalization: `rls` defaults to **`true`**, `policies` to `[]`. A table
- * that declares neither is therefore deny-all — nothing reads it until a policy
- * says who may, which is the safe starting point rather than a bug. Declare
- * `rls: false` for a genuinely public table; that is an explicit, greppable
- * statement of intent instead of an omission. When `policies` is non-empty,
- * `rls` is forced on (ENABLE + FORCE) regardless of the declared flag — a table
- * with policies must have RLS enabled or the policies would be inert.
- */
-declare function defineSchema<T extends Record<string, TableInput>>(input: SchemaInput<T>): SchemaDef<TablesFromInput<T>>;
-
-/**
- * typed-db.ts — Task 2: TypedDB schema-derived insert/row shapes.
- *
- * Derives INSERT and full-row TypeScript types from a `defineSchema()` result
- * and wraps the untyped runtime `DBClient` with a typed facade.
- *
- * No value-any. No `as unknown as X`. The two narrow `as` casts in
- * `makeTypedTable` are safe because:
- *  - `data as Record<string, unknown>`: InsertShape<T> maps string keys to
- *    typed values; all value types are subsets of `unknown`, so the cast is
- *    structurally sound.
- *  - `result as RowShape<T>`: The runtime DBClient returns `Record<string,
- *    unknown>` which is the erased form of the typed row; we're narrowing back
- *    to the precise shape that the schema declared.
- * Both casts are narrowing only (not widening) and correctness is guaranteed
- * by the schema the caller provides.
- */
-
-/** Keys of C whose columns are required on INSERT (not nullable, no default). */
-type RequiredKeys<C> = {
-    [K in keyof C]: ColIsOptionalOnInsert<C[K]> extends true ? never : K;
-}[keyof C];
-/** Keys of C whose columns are optional on INSERT (nullable or has a default). */
-type OptionalKeys<C> = {
-    [K in keyof C]: ColIsOptionalOnInsert<C[K]> extends true ? K : never;
-}[keyof C];
-/**
- * The TypeScript type for an INSERT payload for table `T`.
- * - Required: columns that are NOT NULL and have no DB-level default.
- * - Optional: columns that are nullable or carry a default.
- *
- * When all columns are optional, `RequiredKeys<C>` resolves to `never` and
- * the first part becomes `{}`, which is a neutral element for `&`.
- */
-type InsertShape<T extends TableDef> = {
-    [K in RequiredKeys<T["columns"]>]: ColValue<T["columns"][K]>;
-} & {
-    [K in OptionalKeys<T["columns"]>]?: ColValue<T["columns"][K]>;
-};
-/**
- * The TypeScript type for a full row returned by the DB for table `T`.
- * Every column is present; nullable columns resolve to `T | null`.
- */
-type RowShape<T extends TableDef> = {
-    [K in keyof T["columns"]]: ColValue<T["columns"][K]>;
-};
-/** A typed table accessor that mirrors the runtime DBClient surface. */
-interface TypedTable<T extends TableDef> {
-    insert(data: InsertShape<T>): Promise<RowShape<T>>;
-    /** Update the row by id; resolves to the updated row, or `null` if no row
-     * matched (absent or RLS-hidden) — an idempotent outcome, mirroring
-     * `findById`. The runtime returns a null row rather than throwing. */
-    update(id: string, data: Partial<InsertShape<T>>): Promise<RowShape<T> | null>;
-    delete(id: string): Promise<void>;
-    findById(id: string): Promise<RowShape<T> | null>;
-    findMany(query?: Partial<RowShape<T>>): Promise<RowShape<T>[]>;
-}
-/** A typed DB facade covering all tables declared in schema `S`. */
-interface TypedDB<S extends SchemaDef> {
-    tables: {
-        [K in keyof S["tables"]]: TypedTable<S["tables"][K]>;
-    };
-    /** Run a transaction plan. See {@link EnvTypedDatabase.transaction}. */
-    transaction<T>(fn: (tx: TypedTx<S>) => T extends Promise<unknown> ? never : T): Promise<Materialized<T>>;
-}
-/** The plan-building handle a `TypedDB<S>` transaction callback receives: the
- * schema's tables, expressed as plan operations rather than awaited calls. */
-type TypedTx<S extends SchemaDef> = TxPlanHandle<{
-    [K in keyof S["tables"]]: TxTable<RowShape<S["tables"][K]>, InsertShape<S["tables"][K]>>;
-}>;
-/**
- * Wraps a raw `DBClient` with the type-safe `TypedDB<S>` facade derived from
- * the provided schema. No behavior change for the direct ops — all calls
- * delegate to `raw` with the table name as a plain string.
- *
- * `transaction` does NOT delegate to a per-op client: the callback describes a
- * plan against a fresh {@link TxPlanBuilder}, and the whole plan travels in one
- * `raw.txPlan` call. The schema is used only for its table NAMES; the values
- * are typed by `S` at compile time and are plain strings at run time.
- *
- * The `as` casts are single structural narrowings from a dynamically-built
- * object to the precise mapped type (TS cannot infer the mapped-type result
- * through `Object.keys` iteration) — see the module-level doc comment.
- */
-declare function makeTypedDB<S extends SchemaDef>(schema: S, raw: DBClient): TypedDB<S>;
-/** A typed table accessor derived from one env `Tables` entry's flat shapes. */
-interface EnvTypedTable<T extends TableTypes> {
-    insert(data: T["insert"]): Promise<T["row"]>;
-    /** Update the row by id; resolves to the updated row, or `null` if no row
-     * matched (absent or RLS-hidden) — an idempotent outcome, mirroring
-     * `findById`. The runtime returns a null row rather than throwing. */
-    update(id: string, data: Partial<T["insert"]>): Promise<T["row"] | null>;
-    delete(id: string): Promise<void>;
-    findById(id: string): Promise<T["row"] | null>;
-    findMany(query?: Partial<T["row"]>): Promise<T["row"][]>;
-}
-/** The `tables` map exposed on `Database`/`tx`, keyed by the env `Tables`
- * interface. When no schema is declared `Tables` is empty, so `tables` is an
- * empty object — accessing `.tables.foo` is then a compile error (no member). */
-type EnvTables = {
-    [K in keyof Tables]: EnvTypedTable<Tables[K]>;
-};
-/** The project's tables as PLAN operations, keyed by the env `Tables`
- * interface. The transaction twin of {@link EnvTables}. */
-type TxTables = {
-    [K in keyof Tables]: TxTable<Tables[K]["row"], Tables[K]["insert"]>;
-};
-/**
- * The handle a `Database.transaction(…)` callback receives.
- *
- * Tables only — no `query`, no `findById`, no `asService`. A read whose value
- * the plan does not write belongs outside the transaction, where it costs one
- * round trip and is an ordinary value you can branch on.
- */
-type TxPlan = TxPlanHandle<TxTables>;
-/**
- * The RLS-bypass sibling returned by `Database.asService()`. Same typed surface
- * as {@link EnvTypedDatabase} — `tables`, the raw string ops, and a typed
- * `transaction` — but it does NOT re-expose `asService` (no double-bypass).
- * Every op it performs runs as the `service_role` (BYPASSRLS).
- */
-interface EnvServiceDatabase extends Omit<DBClient, "txPlan" | "asService"> {
-    tables: EnvTables;
-    transaction<T>(fn: (tx: TxPlan) => T extends Promise<unknown> ? never : T): Promise<Materialized<T>>;
-}
-/**
- * The typed-by-default Database surface: the raw string-keyed `DBClient` ops
- * PLUS a `tables` map typed against the project's generated `palbase-env.d.ts`,
- * a `transaction` that runs a whole plan in one request, and `asService()` for
- * the explicit RLS-bypass sibling.
- *
- * The low-level `txPlan` op is deliberately NOT re-exposed here: `transaction`
- * is the surface, and a hand-built plan would bypass the ref/guard machinery
- * that makes one safe to write.
- */
-interface EnvTypedDatabase extends Omit<DBClient, "txPlan" | "asService"> {
-    tables: EnvTables;
-    /**
-     * Run a transaction. The callback DESCRIBES the operations; the whole
-     * description travels in one request and the broker runs it inside a single
-     * transaction — committing when it finishes, rolling back on any failure.
-     *
-     * The callback is SYNCHRONOUS: nothing has run when it returns, so there is
-     * nothing to await. `async` on it and `await` inside it are compile errors.
-     * Values a later operation needs are {@link Ref}s, written straight into the
-     * next operation; values the CALLER needs are returned and substituted before
-     * this promise resolves.
-     *
-     * @example
-     * const { statementId } = await Database.transaction((tx) => {
-     *   const st = tx.tables.statements
-     *     .insert({ household_id: hid, file_sha256: sha, status: "reviewing" })
-     *     .expectOne(new Internal("statement insert failed"));
-     *
-     *   tx.tables.statement_lines.insertMany(
-     *     lines.map((l) => ({ statement_id: st.id, category: resolveCategory(l) })),
-     *   );
-     *
-     *   return { statementId: st.id };
-     * });
-     */
-    transaction<T>(fn: (tx: TxPlan) => T extends Promise<unknown> ? never : T): Promise<Materialized<T>>;
-    /**
-     * Return a sibling that bypasses RLS by running as the `service_role`. Use
-     * sparingly and explicitly — the default `Database.*` path is RLS-enforced.
-     *
-     * @example
-     * const all = await Database.asService().tables.todos.findMany({});
-     * const rows = await Database.asService().query("SELECT * FROM todos");
-     */
-    asService(): EnvServiceDatabase;
-}
-
-export { type PalbaseBindDeviceParams as $, type AuthSpec as A, BadRequest as B, type CacheClient as C, type DBClient as D, type EnvTypedDatabase as E, type FileContext as F, PalError as G, HttpError as H, type InsertShape as I, type PalbaseAnalyticsClient as J, type PalbaseAnalyticsManagementNamespace as K, type Logger as L, type Materialized as M, NotFound as N, type OnDeleteAction as O, type PalbaseDocsClient as P, type PalbaseAnalyticsProperties as Q, type RateLimitConfig as R, type SchemaDef as S, type PalbaseAnalyticsQueryNamespace as T, type PalbaseAttestAndroidParams as U, type PalbaseAttestAndroidResult as V, type PalbaseAttestiOSParams as W, type PalbaseAttestiOSResult as X, type PalbaseAuthClient as Y, type PalbaseBatchOverrideOperation as Z, type PalbaseBatchSetOverridesResult as _, type PalbaseFlagsClient as a, type PalbaseSignedUrlResponse as a$, type PalbaseBucketClient as a0, type PalbaseClearAllOverridesResult as a1, type PalbaseClearOverrideResult as a2, type PalbaseCohortQueryInput as a3, type PalbaseCohortResult as a4, type PalbaseCollectionRef as a5, type PalbaseCountQueryInput as a6, type PalbaseCountResult as a7, type PalbaseCreateLinkParams as a8, type PalbaseDeviceInfo as a9, type PalbaseInboxSendResponse as aA, type PalbaseInitialLink as aB, type PalbaseInvokeOptions as aC, type PalbaseLink as aD, type PalbaseLinkAnalytics as aE, type PalbaseLinkDetails as aF, type PalbaseLinksClient as aG, type PalbaseListLinksOptions as aH, type PalbaseListLinksResult as aI, type PalbaseListOptions as aJ, type PalbaseMatchParams as aK, type PalbaseMultiChannelResponse as aL, type PalbaseOverviewResult as aM, type PalbasePreferences as aN, type PalbasePreferencesClient as aO, type PalbasePushClient as aP, type PalbasePushSendParams as aQ, type PalbasePushSendResponse as aR, type PalbaseQrCodeOptions as aS, type PalbaseQuerySnapshot as aT, type PalbaseRegisterDeviceParams as aU, type PalbaseResult as aV, type PalbaseRetentionQueryInput as aW, type PalbaseRetentionResult as aX, type PalbaseSession as aY, type PalbaseSetOverrideResult as aZ, type PalbaseSetOverridesResult as a_, type PalbaseDeviceTokenView as aa, type PalbaseDocumentRef as ab, type PalbaseDocumentSnapshot as ac, type PalbaseEmailClient as ad, type PalbaseEmailSendParams as ae, type PalbaseEmailSendResponse as af, type PalbaseEventNamesResult as ag, type PalbaseEventsQueryInput as ah, type PalbaseEventsResult as ai, type PalbaseExtension as aj, type PalbaseFileObject as ak, type PalbaseFlag as al, type PalbaseFlagContext as am, type PalbaseFlagSource as an, type PalbaseFlagValue as ao, type PalbaseFlagVariant as ap, type PalbaseFlagsServiceClient as aq, type PalbaseFunctionsClient as ar, type PalbaseFunnelQueryInput as as, type PalbaseFunnelResult as at, type PalbaseIdentifyTraits as au, type PalbaseInboxClient as av, type PalbaseInboxListOptions as aw, type PalbaseInboxListResult as ax, type PalbaseInboxMessage as ay, type PalbaseInboxSendParams as az, type PalbaseNotificationsClient as b, jsonb as b$, type PalbaseSmsClient as b0, type PalbaseSmsSendParams as b1, type PalbaseSmsSendResponse as b2, type PalbaseTransformOptions as b3, type PalbaseUpdateLinkParams as b4, type PalbaseUploadOptions as b5, type PalbaseUser as b6, type PalbaseUserDetailResult as b7, type PalbaseUsersQueryInput as b8, type PalbaseUsersResult as b9, type TxRows as bA, type TxSelectOptions as bB, type TxSetShape as bC, type TxSetValue as bD, type TxTable as bE, type TxTables as bF, type TxWhere as bG, type TxWireExpr as bH, type TxWireGuard as bI, type TxWireOp as bJ, type TxWireRef as bK, type TxWireValue as bL, type TypedDB as bM, type TypedTable as bN, type TypedTx as bO, Unauthorized as bP, type User as bQ, type VerifiedDevice as bR, bigint as bS, boolean as bT, dec as bU, defineMiddleware as bV, defineSchema as bW, enumType as bX, inc as bY, integer as bZ, isPalbaseExtension as b_, type PalbaseVerifyRequestSignatureParams as ba, type PalbaseWhereOperator as bb, PolicyBuilder as bc, type PolicyCommand as bd, type PolicyDef as be, type PolicyMode as bf, type RawConstraintDef as bg, type Ref as bh, type RowShape as bi, type SchemaInput as bj, type TableDef as bk, type TableInput as bl, TooManyRequests as bm, type TxColumnExpr as bn, type TxInsertShape as bo, type TxInsertValue as bp, type TxNow as bq, type TxPlan as br, type TxPlanBody as bs, TxPlanError as bt, type TxPlanHandle as bu, type TxPlanOpResult as bv, type TxPlanRejection as bw, type TxPlanResponse as bx, TxRefError as by, type TxRow as bz, type PalbaseRealtimeClient as c, makeTypedDB as c0, now as c1, numeric as c2, policy as c3, raw as c4, text as c5, timestamp as c6, uuid as c7, type PalbaseStorageClient as d, type AuthConfig as e, type ClientInfo as f, ColumnBuilder as g, type ColumnDef as h, type ColumnMap as i, type ColumnType as j, Conflict as k, type DBOps as l, EXTENSION_DEPENDENCIES as m, type EnvServiceDatabase as n, type EnvTables as o, type EnvTypedTable as p, type ErrorDef as q, type ErrorMap as r, type ErrorThrowers as s, Forbidden as t, type HttpMethod as u, type Middleware as v, type MiddlewareContext as w, type MiddlewareHandler as x, PALBASE_EXTENSIONS as y, type PBRequest as z };
+export { type PalbaseCreateLinkParams as $, type AuthSpec as A, BadRequest as B, type CacheClient as C, type DBClient as D, type ErrorDef as E, type FileContext as F, type PalbaseAttestiOSParams as G, HttpError as H, type PalbaseAttestiOSResult as I, type PalbaseAuthClient as J, type PalbaseBatchOverrideOperation as K, type Logger as L, type Materialized as M, NotFound as N, type PalbaseBatchSetOverridesResult as O, type PalbaseDocsClient as P, type PalbaseBindDeviceParams as Q, type RateLimitConfig as R, type SecretsService as S, type TxPlanBody as T, type PalbaseClearAllOverridesResult as U, type PalbaseClearOverrideResult as V, type PalbaseCohortQueryInput as W, type PalbaseCohortResult as X, type PalbaseCollectionRef as Y, type PalbaseCountQueryInput as Z, type PalbaseCountResult as _, type PalbaseFlagsClient as a, type PalbaseVerifyRequestSignatureParams as a$, type PalbaseDeviceInfo as a0, type PalbaseDeviceTokenView as a1, type PalbaseDocumentRef as a2, type PalbaseDocumentSnapshot as a3, type PalbaseEmailClient as a4, type PalbaseEmailSendParams as a5, type PalbaseEmailSendResponse as a6, type PalbaseEventNamesResult as a7, type PalbaseEventsQueryInput as a8, type PalbaseEventsResult as a9, type PalbaseMatchParams as aA, type PalbaseMultiChannelResponse as aB, type PalbaseOverviewResult as aC, type PalbasePreferences as aD, type PalbasePreferencesClient as aE, type PalbasePushClient as aF, type PalbasePushSendParams as aG, type PalbasePushSendResponse as aH, type PalbaseQrCodeOptions as aI, type PalbaseQuerySnapshot as aJ, type PalbaseRegisterDeviceParams as aK, type PalbaseRetentionQueryInput as aL, type PalbaseRetentionResult as aM, type PalbaseSession as aN, type PalbaseSetOverrideResult as aO, type PalbaseSetOverridesResult as aP, type PalbaseSignedUrlResponse as aQ, type PalbaseSmsClient as aR, type PalbaseSmsSendParams as aS, type PalbaseSmsSendResponse as aT, type PalbaseTransformOptions as aU, type PalbaseUpdateLinkParams as aV, type PalbaseUploadOptions as aW, type PalbaseUser as aX, type PalbaseUserDetailResult as aY, type PalbaseUsersQueryInput as aZ, type PalbaseUsersResult as a_, type PalbaseFileObject as aa, type PalbaseFlag as ab, type PalbaseFlagContext as ac, type PalbaseFlagSource as ad, type PalbaseFlagValue as ae, type PalbaseFlagVariant as af, type PalbaseFlagsServiceClient as ag, type PalbaseFunctionsClient as ah, type PalbaseFunnelQueryInput as ai, type PalbaseFunnelResult as aj, type PalbaseIdentifyTraits as ak, type PalbaseInboxClient as al, type PalbaseInboxListOptions as am, type PalbaseInboxListResult as an, type PalbaseInboxMessage as ao, type PalbaseInboxSendParams as ap, type PalbaseInboxSendResponse as aq, type PalbaseInitialLink as ar, type PalbaseInvokeOptions as as, type PalbaseLink as at, type PalbaseLinkAnalytics as au, type PalbaseLinkDetails as av, type PalbaseLinksClient as aw, type PalbaseListLinksOptions as ax, type PalbaseListLinksResult as ay, type PalbaseListOptions as az, type PalbaseNotificationsClient as b, type PalbaseWhereOperator as b0, type Ref as b1, TooManyRequests as b2, type TxColumnExpr as b3, type TxInsertShape as b4, type TxInsertValue as b5, type TxNow as b6, TxPlanError as b7, type TxPlanHandle as b8, type TxPlanOpResult as b9, type TxPlanRejection as ba, TxRefError as bb, type TxRow as bc, type TxRows as bd, type TxSelectOptions as be, type TxSetShape as bf, type TxSetValue as bg, type TxTable as bh, type TxWhere as bi, type TxWireExpr as bj, type TxWireGuard as bk, type TxWireOp as bl, type TxWireRef as bm, type TxWireValue as bn, Unauthorized as bo, type User as bp, type VerifiedDevice as bq, dec as br, defineMiddleware as bs, inc as bt, now as bu, type PalbaseRealtimeClient as c, type PalbaseStorageClient as d, type PalbaseBucketClient as e, type TxPlanResponse as f, type PalbaseResult as g, type AuthConfig as h, type ClientInfo as i, Conflict as j, type DBOps as k, type ErrorMap as l, type ErrorThrowers as m, Forbidden as n, type HttpMethod as o, type Middleware as p, type MiddlewareContext as q, type MiddlewareHandler as r, type PBRequest as s, PalError as t, type PalbaseAnalyticsClient as u, type PalbaseAnalyticsManagementNamespace as v, type PalbaseAnalyticsProperties as w, type PalbaseAnalyticsQueryNamespace as x, type PalbaseAttestAndroidParams as y, type PalbaseAttestAndroidResult as z };