@ai-matrx/data 0.26.2 → 0.28.1

package/dist/doors-D88CwoLU.d.cts

@@ -0,0 +1,296 @@
+/** Registry type (`platform.entity_types.type`); null = untyped or no registry row. */
+type TableType = "entity" | "detail" | "ledger" | "reference" | "system" | "restricted" | "deprecated";
+type OrgRule = {
+    readonly rule: "binding";
+} | {
+    readonly rule: "parent";
+    readonly parent: string;
+    readonly via: string;
+} | {
+    readonly rule: "column";
+} | {
+    readonly rule: "none";
+};
+/** Phantom carrier for the generated row types — never present at runtime. */
+declare const ROW: unique symbol;
+interface TableDescriptor<Row = Record<string, unknown>, Insert = Record<string, unknown>, Update = Partial<Insert>> {
+    readonly schema: string;
+    readonly name: string;
+    readonly kind: "table" | "view" | "materialized_view";
+    readonly type: TableType | null;
+    readonly pk: readonly string[];
+    readonly org: OrgRule;
+    readonly versioned: boolean;
+    readonly softDelete: boolean;
+    /** The archive column, when the table archives instead of (or as well as) soft-deleting. */
+    readonly archive: "archived_at" | "is_archived" | null;
+    readonly readOnly: boolean;
+    readonly deletesRefused: boolean;
+    readonly readOnlyColumns: readonly string[];
+    readonly listScope: string | null;
+    readonly realtime: boolean;
+    /**
+     * The table has a `created_by` column. A signed-in insert that omits it is stamped with the
+     * session's person (row security on tables like `workbench.notes` refuses an insert whose
+     * `created_by` is not `auth.uid()`). Optional: descriptors generated before 0.25.0 lack it.
+     */
+    readonly createdBy?: boolean;
+    readonly [ROW]?: {
+        row: Row;
+        insert: Insert;
+        update: Update;
+    };
+}
+interface FunctionDescriptor<Args = Record<string, unknown>, Result = unknown> {
+    readonly schema: string;
+    readonly name: string;
+    readonly roles: readonly ("anon" | "authenticated" | "service_role")[];
+    readonly registered: boolean;
+    readonly [ROW]?: {
+        args: Args;
+        result: Result;
+    };
+}
+type RowOf<T> = T extends TableDescriptor<infer R, any, any> ? R : never;
+type InsertOf<T> = T extends TableDescriptor<any, infer I, any> ? I : never;
+type UpdateOf<T> = T extends TableDescriptor<any, any, infer U> ? U : never;
+type ArgsOf<F> = F extends FunctionDescriptor<infer A, any> ? A : never;
+type ResultOf<F> = F extends FunctionDescriptor<any, infer R> ? R : never;
+interface PostgrestError {
+    message: string;
+    code?: string;
+    details?: string | null;
+    hint?: string | null;
+}
+interface Resp<T> {
+    data: T | null;
+    error: PostgrestError | null;
+    count?: number | null;
+}
+/** The slice of a supabase-js query builder the doors use (structural — any supabase-js 2.x client). */
+interface QueryLike extends PromiseLike<Resp<any>> {
+    select(columns?: string, opts?: {
+        count?: "exact" | "planned" | "estimated";
+        head?: boolean;
+    }): QueryLike;
+    eq(column: string, value: unknown): QueryLike;
+    is(column: string, value: null | boolean): QueryLike;
+    order(column: string, opts?: {
+        ascending?: boolean;
+    }): QueryLike;
+    range(from: number, to: number): QueryLike;
+    maybeSingle(): PromiseLike<Resp<any>>;
+    single(): PromiseLike<Resp<any>>;
+}
+/** The slice of a supabase-js client the doors use (a real `SupabaseClient` is assignable — doors.types.test.ts). */
+interface SupabaseLike {
+    schema(name: string): {
+        /**
+         * A table builder (read as `TableLike` inside the doors). Typed `unknown` on purpose: matching
+         * supabase-js's deep builder generics structurally costs TS2589 in every consumer.
+         */
+        from(table: string): unknown;
+        rpc(fn: string, args?: Record<string, unknown>, opts?: {
+            count?: "exact" | "planned" | "estimated";
+        }): PromiseLike<Resp<any>>;
+    };
+    auth?: {
+        getSession(): Promise<{
+            data: {
+                session: {
+                    access_token: string;
+                    user?: {
+                        id: string;
+                    } | null;
+                } | null;
+            };
+        }>;
+        onAuthStateChange(cb: (event: string, session: unknown) => void): {
+            data: {
+                subscription: {
+                    unsubscribe(): void;
+                };
+            };
+        };
+    };
+}
+/** The credential shape `@ai-matrx/api`'s `CredentialsPort` accepts (structural; data owns the session). */
+interface UserCredentialsPort {
+    get(): Promise<{
+        kind: "user";
+        accessToken: string;
+    } | null>;
+    onChange?(cb: () => void): () => void;
+}
+interface Db {
+    readonly client: SupabaseLike;
+    readonly role: "user" | "service";
+    /** The active organization — where NEW entity rows are saved. Never a read filter. */
+    activeOrganization(): string | null;
+    /** The session as `@ai-matrx/api`'s `user` credential (one sign-in feeds both lanes). */
+    readonly credentials: UserCredentialsPort;
+}
+interface CreateDbOptions {
+    /** The app's existing Supabase client (browser, RSC, route or the host's chat client). */
+    client: SupabaseLike;
+    /** Where new entity rows are saved. Read lazily on every insert; never consulted by a read. */
+    organization?: () => string | null | undefined;
+}
+/** The one database connection for a signed-in (or anonymous) person. */
+declare function createDb(options: CreateDbOptions): Db;
+/**
+ * Service-role doors — servers only. No session, no binding: every entity insert
+ * names its organization. Throws in a browser bundle.
+ */
+declare function createServiceDb(options: {
+    client: SupabaseLike;
+}): Db;
+declare class DoorRefusedError extends Error {
+    readonly door: string;
+    readonly reason: string;
+    constructor(door: string, reason: string);
+}
+declare class DatabaseError extends Error {
+    readonly door: string;
+    readonly cause: PostgrestError;
+    constructor(door: string, cause: PostgrestError);
+}
+type Op = "read" | "insert" | "update" | "remove" | "archive";
+/** Refuse before the wire when the descriptor's rules do not open this door. */
+declare function assertDoor(db: Db, table: TableDescriptor<any, any, any>, op: Op): void;
+type Col<R> = Extract<keyof R, string>;
+/** The typed filter a `Where` callback receives — column names and values checked against the row. */
+interface Filter<R> {
+    eq<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    neq<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    gt<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    gte<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    lt<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    lte<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    like(column: Col<R>, pattern: string): Filter<R>;
+    ilike(column: Col<R>, pattern: string): Filter<R>;
+    in<K extends Col<R>>(column: K, values: readonly NonNullable<R[K]>[]): Filter<R>;
+    is(column: Col<R>, value: null | boolean): Filter<R>;
+    contains(column: Col<R>, value: unknown): Filter<R>;
+    overlaps(column: Col<R>, value: unknown): Filter<R>;
+    textSearch(column: Col<R>, query: string, opts?: {
+        type?: "plain" | "phrase" | "websearch";
+        config?: string;
+    }): Filter<R>;
+    /** PostgREST's raw `or` grammar (`"pinned.eq.true,starred.eq.true"`). */
+    or(filters: string, opts?: {
+        referencedTable?: string;
+    }): Filter<R>;
+    not(column: Col<R>, operator: string, value: unknown): Filter<R>;
+}
+/** A filter callback — the same builder `readAllRows` callers write today, typed to the row. */
+type Where<R = any> = (q: Filter<R>) => Filter<R>;
+interface ReadOptions<C> {
+    /** Only these columns (the result is typed to them). Default every column. */
+    columns?: readonly C[];
+    /** Include soft-deleted rows (default: excluded on tables with `deleted_at`). */
+    includeDeleted?: boolean;
+}
+/** One row by primary key (a composite key takes `{ col: value }`), or null. */
+declare function read<R, I, U, C extends Col<R> = Col<R>>(db: Db, table: TableDescriptor<R, I, U>, id: unknown, opts?: ReadOptions<C>): Promise<Pick<R, C> | null>;
+/** EVERY matching row, paged past the 1,000-row cap (ordered by the full key); throws on a short read. */
+declare function listAll<R, I, U, C extends Col<R> = Col<R>>(db: Db, table: TableDescriptor<R, I, U>, where?: Where<R>, opts?: ReadOptions<C> & {
+    orderBy?: Col<R>;
+    pageSize?: number;
+    maxRows?: number;
+}): Promise<Pick<R, C>[]>;
+/** One explicit window (`from`..`to`, inclusive) plus the exact total. */
+declare function page<R, I, U, C extends Col<R> = Col<R>>(db: Db, table: TableDescriptor<R, I, U>, window: ReadOptions<C> & {
+    from: number;
+    to: number;
+    where?: Where<R>;
+    orderBy?: Col<R>;
+    ascending?: boolean;
+}): Promise<{
+    rows: Pick<R, C>[];
+    total: number | null;
+}>;
+/** The exact count of matching rows (no rows transferred). */
+declare function count<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, where?: Where<R>, opts?: {
+    includeDeleted?: boolean;
+}): Promise<number>;
+/** Insert one row (or many) and return what the database stored. */
+declare function insert<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, values: I): Promise<R>;
+declare function insert<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, values: readonly I[]): Promise<R[]>;
+/** Every write on a versioned table is explicit: `{ expectedVersion }` (guarded) or `{ overwrite: true }`. */
+type UpdateGuard = {
+    expectedVersion: number;
+} | {
+    overwrite: true;
+};
+type WriteResult<R> = {
+    status: "saved";
+    row: R;
+    rebasedFrom?: {
+        expectedVersion: number;
+        currentVersion: number;
+    };
+} | {
+    status: "conflict";
+    currentRow: R;
+    currentVersion: number;
+} | {
+    status: "not_found";
+};
+/**
+ * Update one row by primary key. On a versioned table the guard is required:
+ * `{ expectedVersion }` (a conflict comes back, never a silent overwrite) or
+ * `{ overwrite: true }`; on an unversioned table `expectedVersion` is refused.
+ */
+declare function update<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, id: unknown, patch: U, guard?: UpdateGuard): Promise<WriteResult<R>>;
+/**
+ * Remove one row the way the table removes: soft delete (`deleted_at`) where it
+ * has one; an archive-only table refuses (use `archive`); a hard delete only where
+ * the table has neither. Guarded like `update` on a versioned table.
+ */
+declare function remove<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, id: unknown, guard?: UpdateGuard): Promise<{
+    status: "soft_deleted" | "deleted" | "not_found";
+} | {
+    status: "conflict";
+    currentVersion: number;
+}>;
+/** Archive (or, with `restore`, bring back) one row by the table's archive column. Guarded like `update`. */
+declare function archive<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, id: unknown, opts?: {
+    restore?: boolean;
+    guard?: UpdateGuard;
+}): Promise<WriteResult<R>>;
+/** Bring back an archived or soft-deleted row. */
+declare const restore: <R, I, U>(db: Db, table: TableDescriptor<R, I, U>, id: unknown, guard?: UpdateGuard) => Promise<WriteResult<R>>;
+/** Call a database function through its generated door (PostgREST chooses an overload by argument names). */
+declare function call<F extends FunctionDescriptor<any, any>>(db: Db, fn: F, args: ArgsOf<F>): Promise<ResultOf<F>>;
+/** One ordering column of a set-returning function's rows (PostgREST `order`). */
+type CallOrder = string | {
+    column: string;
+    ascending?: boolean;
+    nullsFirst?: boolean;
+};
+/**
+ * EVERY row a set-returning function answers, paged past the 1,000-row cap by
+ * `range` over a stable `order` (name enough columns to make it total — end on a key);
+ * throws a `DatabaseError` with the database's own error, or `IncompleteReadError` on a short read.
+ */
+declare function callAll<F extends FunctionDescriptor<any, any>>(db: Db, fn: F, args: ArgsOf<F>, opts: {
+    order: readonly CallOrder[];
+    pageSize?: number;
+    maxRows?: number;
+}): Promise<ResultOf<F> extends readonly (infer Row)[] ? Row[] : ResultOf<F>[]>;
+/** One schema's flags (`<schema>.flags.ts` from `matrx-data generate --flags-index`): "schema.table" → descriptor. */
+type FlagsIndex = Readonly<Record<string, TableDescriptor>>;
+/** Per-schema loaders (`flags-index.ts`): only the schema a runtime name names is loaded (pay-only). */
+type FlagLoaders = Readonly<Record<string, () => Promise<FlagsIndex>>>;
+/** The door for a table whose name arrives at runtime — loosely typed, the same rules. */
+declare function tableByName(index: FlagsIndex, name: string): TableDescriptor;
+/** `tableByName` over per-schema loaders: loads only the named schema's flags. */
+declare function loadTableByName(loaders: FlagLoaders, name: string): Promise<TableDescriptor>;
+/** The `postgres_changes` filter for a table — only published tables have one (an unpublished table delivers nothing). */
+declare function changesOf(table: TableDescriptor<any, any, any>): {
+    schema: string;
+    table: string;
+};
+
+export { type ArgsOf as A, restore as B, type CallOrder as C, type Db as D, tableByName as E, type Filter as F, update as G, type InsertOf as I, type OrgRule as O, type QueryLike as Q, type ReadOptions as R, type SupabaseLike as S, type TableDescriptor as T, type UserCredentialsPort as U, type Where as W, type CreateDbOptions as a, DatabaseError as b, DoorRefusedError as c, type FlagLoaders as d, type FlagsIndex as e, type FunctionDescriptor as f, type ResultOf as g, type RowOf as h, type TableType as i, type UpdateGuard as j, type UpdateOf as k, type WriteResult as l, archive as m, assertDoor as n, call as o, callAll as p, changesOf as q, count as r, createDb as s, createServiceDb as t, insert as u, listAll as v, loadTableByName as w, page as x, read as y, remove as z };

package/dist/doors-D88CwoLU.d.ts

@@ -0,0 +1,296 @@
+/** Registry type (`platform.entity_types.type`); null = untyped or no registry row. */
+type TableType = "entity" | "detail" | "ledger" | "reference" | "system" | "restricted" | "deprecated";
+type OrgRule = {
+    readonly rule: "binding";
+} | {
+    readonly rule: "parent";
+    readonly parent: string;
+    readonly via: string;
+} | {
+    readonly rule: "column";
+} | {
+    readonly rule: "none";
+};
+/** Phantom carrier for the generated row types — never present at runtime. */
+declare const ROW: unique symbol;
+interface TableDescriptor<Row = Record<string, unknown>, Insert = Record<string, unknown>, Update = Partial<Insert>> {
+    readonly schema: string;
+    readonly name: string;
+    readonly kind: "table" | "view" | "materialized_view";
+    readonly type: TableType | null;
+    readonly pk: readonly string[];
+    readonly org: OrgRule;
+    readonly versioned: boolean;
+    readonly softDelete: boolean;
+    /** The archive column, when the table archives instead of (or as well as) soft-deleting. */
+    readonly archive: "archived_at" | "is_archived" | null;
+    readonly readOnly: boolean;
+    readonly deletesRefused: boolean;
+    readonly readOnlyColumns: readonly string[];
+    readonly listScope: string | null;
+    readonly realtime: boolean;
+    /**
+     * The table has a `created_by` column. A signed-in insert that omits it is stamped with the
+     * session's person (row security on tables like `workbench.notes` refuses an insert whose
+     * `created_by` is not `auth.uid()`). Optional: descriptors generated before 0.25.0 lack it.
+     */
+    readonly createdBy?: boolean;
+    readonly [ROW]?: {
+        row: Row;
+        insert: Insert;
+        update: Update;
+    };
+}
+interface FunctionDescriptor<Args = Record<string, unknown>, Result = unknown> {
+    readonly schema: string;
+    readonly name: string;
+    readonly roles: readonly ("anon" | "authenticated" | "service_role")[];
+    readonly registered: boolean;
+    readonly [ROW]?: {
+        args: Args;
+        result: Result;
+    };
+}
+type RowOf<T> = T extends TableDescriptor<infer R, any, any> ? R : never;
+type InsertOf<T> = T extends TableDescriptor<any, infer I, any> ? I : never;
+type UpdateOf<T> = T extends TableDescriptor<any, any, infer U> ? U : never;
+type ArgsOf<F> = F extends FunctionDescriptor<infer A, any> ? A : never;
+type ResultOf<F> = F extends FunctionDescriptor<any, infer R> ? R : never;
+interface PostgrestError {
+    message: string;
+    code?: string;
+    details?: string | null;
+    hint?: string | null;
+}
+interface Resp<T> {
+    data: T | null;
+    error: PostgrestError | null;
+    count?: number | null;
+}
+/** The slice of a supabase-js query builder the doors use (structural — any supabase-js 2.x client). */
+interface QueryLike extends PromiseLike<Resp<any>> {
+    select(columns?: string, opts?: {
+        count?: "exact" | "planned" | "estimated";
+        head?: boolean;
+    }): QueryLike;
+    eq(column: string, value: unknown): QueryLike;
+    is(column: string, value: null | boolean): QueryLike;
+    order(column: string, opts?: {
+        ascending?: boolean;
+    }): QueryLike;
+    range(from: number, to: number): QueryLike;
+    maybeSingle(): PromiseLike<Resp<any>>;
+    single(): PromiseLike<Resp<any>>;
+}
+/** The slice of a supabase-js client the doors use (a real `SupabaseClient` is assignable — doors.types.test.ts). */
+interface SupabaseLike {
+    schema(name: string): {
+        /**
+         * A table builder (read as `TableLike` inside the doors). Typed `unknown` on purpose: matching
+         * supabase-js's deep builder generics structurally costs TS2589 in every consumer.
+         */
+        from(table: string): unknown;
+        rpc(fn: string, args?: Record<string, unknown>, opts?: {
+            count?: "exact" | "planned" | "estimated";
+        }): PromiseLike<Resp<any>>;
+    };
+    auth?: {
+        getSession(): Promise<{
+            data: {
+                session: {
+                    access_token: string;
+                    user?: {
+                        id: string;
+                    } | null;
+                } | null;
+            };
+        }>;
+        onAuthStateChange(cb: (event: string, session: unknown) => void): {
+            data: {
+                subscription: {
+                    unsubscribe(): void;
+                };
+            };
+        };
+    };
+}
+/** The credential shape `@ai-matrx/api`'s `CredentialsPort` accepts (structural; data owns the session). */
+interface UserCredentialsPort {
+    get(): Promise<{
+        kind: "user";
+        accessToken: string;
+    } | null>;
+    onChange?(cb: () => void): () => void;
+}
+interface Db {
+    readonly client: SupabaseLike;
+    readonly role: "user" | "service";
+    /** The active organization — where NEW entity rows are saved. Never a read filter. */
+    activeOrganization(): string | null;
+    /** The session as `@ai-matrx/api`'s `user` credential (one sign-in feeds both lanes). */
+    readonly credentials: UserCredentialsPort;
+}
+interface CreateDbOptions {
+    /** The app's existing Supabase client (browser, RSC, route or the host's chat client). */
+    client: SupabaseLike;
+    /** Where new entity rows are saved. Read lazily on every insert; never consulted by a read. */
+    organization?: () => string | null | undefined;
+}
+/** The one database connection for a signed-in (or anonymous) person. */
+declare function createDb(options: CreateDbOptions): Db;
+/**
+ * Service-role doors — servers only. No session, no binding: every entity insert
+ * names its organization. Throws in a browser bundle.
+ */
+declare function createServiceDb(options: {
+    client: SupabaseLike;
+}): Db;
+declare class DoorRefusedError extends Error {
+    readonly door: string;
+    readonly reason: string;
+    constructor(door: string, reason: string);
+}
+declare class DatabaseError extends Error {
+    readonly door: string;
+    readonly cause: PostgrestError;
+    constructor(door: string, cause: PostgrestError);
+}
+type Op = "read" | "insert" | "update" | "remove" | "archive";
+/** Refuse before the wire when the descriptor's rules do not open this door. */
+declare function assertDoor(db: Db, table: TableDescriptor<any, any, any>, op: Op): void;
+type Col<R> = Extract<keyof R, string>;
+/** The typed filter a `Where` callback receives — column names and values checked against the row. */
+interface Filter<R> {
+    eq<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    neq<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    gt<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    gte<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    lt<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    lte<K extends Col<R>>(column: K, value: NonNullable<R[K]>): Filter<R>;
+    like(column: Col<R>, pattern: string): Filter<R>;
+    ilike(column: Col<R>, pattern: string): Filter<R>;
+    in<K extends Col<R>>(column: K, values: readonly NonNullable<R[K]>[]): Filter<R>;
+    is(column: Col<R>, value: null | boolean): Filter<R>;
+    contains(column: Col<R>, value: unknown): Filter<R>;
+    overlaps(column: Col<R>, value: unknown): Filter<R>;
+    textSearch(column: Col<R>, query: string, opts?: {
+        type?: "plain" | "phrase" | "websearch";
+        config?: string;
+    }): Filter<R>;
+    /** PostgREST's raw `or` grammar (`"pinned.eq.true,starred.eq.true"`). */
+    or(filters: string, opts?: {
+        referencedTable?: string;
+    }): Filter<R>;
+    not(column: Col<R>, operator: string, value: unknown): Filter<R>;
+}
+/** A filter callback — the same builder `readAllRows` callers write today, typed to the row. */
+type Where<R = any> = (q: Filter<R>) => Filter<R>;
+interface ReadOptions<C> {
+    /** Only these columns (the result is typed to them). Default every column. */
+    columns?: readonly C[];
+    /** Include soft-deleted rows (default: excluded on tables with `deleted_at`). */
+    includeDeleted?: boolean;
+}
+/** One row by primary key (a composite key takes `{ col: value }`), or null. */
+declare function read<R, I, U, C extends Col<R> = Col<R>>(db: Db, table: TableDescriptor<R, I, U>, id: unknown, opts?: ReadOptions<C>): Promise<Pick<R, C> | null>;
+/** EVERY matching row, paged past the 1,000-row cap (ordered by the full key); throws on a short read. */
+declare function listAll<R, I, U, C extends Col<R> = Col<R>>(db: Db, table: TableDescriptor<R, I, U>, where?: Where<R>, opts?: ReadOptions<C> & {
+    orderBy?: Col<R>;
+    pageSize?: number;
+    maxRows?: number;
+}): Promise<Pick<R, C>[]>;
+/** One explicit window (`from`..`to`, inclusive) plus the exact total. */
+declare function page<R, I, U, C extends Col<R> = Col<R>>(db: Db, table: TableDescriptor<R, I, U>, window: ReadOptions<C> & {
+    from: number;
+    to: number;
+    where?: Where<R>;
+    orderBy?: Col<R>;
+    ascending?: boolean;
+}): Promise<{
+    rows: Pick<R, C>[];
+    total: number | null;
+}>;
+/** The exact count of matching rows (no rows transferred). */
+declare function count<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, where?: Where<R>, opts?: {
+    includeDeleted?: boolean;
+}): Promise<number>;
+/** Insert one row (or many) and return what the database stored. */
+declare function insert<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, values: I): Promise<R>;
+declare function insert<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, values: readonly I[]): Promise<R[]>;
+/** Every write on a versioned table is explicit: `{ expectedVersion }` (guarded) or `{ overwrite: true }`. */
+type UpdateGuard = {
+    expectedVersion: number;
+} | {
+    overwrite: true;
+};
+type WriteResult<R> = {
+    status: "saved";
+    row: R;
+    rebasedFrom?: {
+        expectedVersion: number;
+        currentVersion: number;
+    };
+} | {
+    status: "conflict";
+    currentRow: R;
+    currentVersion: number;
+} | {
+    status: "not_found";
+};
+/**
+ * Update one row by primary key. On a versioned table the guard is required:
+ * `{ expectedVersion }` (a conflict comes back, never a silent overwrite) or
+ * `{ overwrite: true }`; on an unversioned table `expectedVersion` is refused.
+ */
+declare function update<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, id: unknown, patch: U, guard?: UpdateGuard): Promise<WriteResult<R>>;
+/**
+ * Remove one row the way the table removes: soft delete (`deleted_at`) where it
+ * has one; an archive-only table refuses (use `archive`); a hard delete only where
+ * the table has neither. Guarded like `update` on a versioned table.
+ */
+declare function remove<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, id: unknown, guard?: UpdateGuard): Promise<{
+    status: "soft_deleted" | "deleted" | "not_found";
+} | {
+    status: "conflict";
+    currentVersion: number;
+}>;
+/** Archive (or, with `restore`, bring back) one row by the table's archive column. Guarded like `update`. */
+declare function archive<R, I, U>(db: Db, table: TableDescriptor<R, I, U>, id: unknown, opts?: {
+    restore?: boolean;
+    guard?: UpdateGuard;
+}): Promise<WriteResult<R>>;
+/** Bring back an archived or soft-deleted row. */
+declare const restore: <R, I, U>(db: Db, table: TableDescriptor<R, I, U>, id: unknown, guard?: UpdateGuard) => Promise<WriteResult<R>>;
+/** Call a database function through its generated door (PostgREST chooses an overload by argument names). */
+declare function call<F extends FunctionDescriptor<any, any>>(db: Db, fn: F, args: ArgsOf<F>): Promise<ResultOf<F>>;
+/** One ordering column of a set-returning function's rows (PostgREST `order`). */
+type CallOrder = string | {
+    column: string;
+    ascending?: boolean;
+    nullsFirst?: boolean;
+};
+/**
+ * EVERY row a set-returning function answers, paged past the 1,000-row cap by
+ * `range` over a stable `order` (name enough columns to make it total — end on a key);
+ * throws a `DatabaseError` with the database's own error, or `IncompleteReadError` on a short read.
+ */
+declare function callAll<F extends FunctionDescriptor<any, any>>(db: Db, fn: F, args: ArgsOf<F>, opts: {
+    order: readonly CallOrder[];
+    pageSize?: number;
+    maxRows?: number;
+}): Promise<ResultOf<F> extends readonly (infer Row)[] ? Row[] : ResultOf<F>[]>;
+/** One schema's flags (`<schema>.flags.ts` from `matrx-data generate --flags-index`): "schema.table" → descriptor. */
+type FlagsIndex = Readonly<Record<string, TableDescriptor>>;
+/** Per-schema loaders (`flags-index.ts`): only the schema a runtime name names is loaded (pay-only). */
+type FlagLoaders = Readonly<Record<string, () => Promise<FlagsIndex>>>;
+/** The door for a table whose name arrives at runtime — loosely typed, the same rules. */
+declare function tableByName(index: FlagsIndex, name: string): TableDescriptor;
+/** `tableByName` over per-schema loaders: loads only the named schema's flags. */
+declare function loadTableByName(loaders: FlagLoaders, name: string): Promise<TableDescriptor>;
+/** The `postgres_changes` filter for a table — only published tables have one (an unpublished table delivers nothing). */
+declare function changesOf(table: TableDescriptor<any, any, any>): {
+    schema: string;
+    table: string;
+};
+
+export { type ArgsOf as A, restore as B, type CallOrder as C, type Db as D, tableByName as E, type Filter as F, update as G, type InsertOf as I, type OrgRule as O, type QueryLike as Q, type ReadOptions as R, type SupabaseLike as S, type TableDescriptor as T, type UserCredentialsPort as U, type Where as W, type CreateDbOptions as a, DatabaseError as b, DoorRefusedError as c, type FlagLoaders as d, type FlagsIndex as e, type FunctionDescriptor as f, type ResultOf as g, type RowOf as h, type TableType as i, type UpdateGuard as j, type UpdateOf as k, type WriteResult as l, archive as m, assertDoor as n, call as o, callAll as p, changesOf as q, count as r, createDb as s, createServiceDb as t, insert as u, listAll as v, loadTableByName as w, page as x, read as y, remove as z };