@abloatai/ablo 0.36.0 → 0.37.0

package/dist/transaction/schema/roles.js

@@ -1,230 +0,0 @@
-import { z } from 'zod';
-/**
- * Sync-group roles — the fan-out vocabulary, as typed data.
- *
- * A *sync group* is the unit the broadcast layer routes deltas on. On the wire
- * it's a `kind:id` string, but that serialization is owned entirely by this
- * module — callers never hand-write `'org:abc'`. Instead they declare a typed
- * {@link Role} (`kind` + which field supplies the id) and the engine mints the
- * branded {@link SyncGroup} string via {@link syncGroup}.
- *
- * Two reading directions, one shape:
- *
- *   • {@link IdentityRole} — "which groups may this *participant* subscribe to?"
- *     Reads fields off an identity context (`organizationId`, `teamIds`).
- *
- *   • {@link EntityRole} — "which groups does this *record* live in?" Reads
- *     fields off the record itself (`id`, `reportId`), so the server can fan a
- *     committed delta to the right entity streams regardless of what the
- *     committer was subscribed to.
- *
- * Roles are pure data (no closures) so a `Schema` round-trips through the
- * control plane and the reconstructed copy behaves identically.
- */
-// ── Sync-group wire form (branded) ──────────────────────────────────────────
-/**
- * The branded wire form of a sync group: `${kind}:${id}`. Branded so a raw
- * string can't masquerade as one — the only way to produce a `SyncGroup` is
- * {@link syncGroup}. Because the brand is an intersection it's still assignable
- * *to* `string`, so existing `string[]` plumbing keeps working unchanged.
- */
-export const syncGroupSchema = z
-    .templateLiteral([z.string().regex(/^[a-z][a-z0-9_]*$/), ':', z.string().min(1)])
-    .brand();
-/**
- * Mint a sync-group string. The single place the `kind:id` convention lives —
- * if the wire format ever changes (structured columns, a different separator),
- * it changes here and nowhere else.
- */
-export function syncGroup(kind, id) {
-    return `${kind}:${id}`;
-}
-/**
- * Runtime validation for {@link SyncGroupInput}, used wherever a group crosses a
- * trust boundary such as minting a capability or an ephemeral key. A malformed
- * group is rejected with `invalid_sync_group` rather than stored and left
- * silently subscribed to nothing.
- */
-export const syncGroupInputSchema = z.union([z.literal('default'), syncGroupSchema]);
-/** Runtime guard matching {@link SyncGroupInput}. */
-export function isSyncGroupInput(value) {
-    return syncGroupInputSchema.safeParse(value).success;
-}
-// ── Identity anchors (closed vocabulary) ────────────────────────────────────
-/**
- * The sync-group kinds the authentication provider mints directly onto an
- * identity. This is a fixed vocabulary: add to this list rather than write a
- * new namespace string inline.
- *
- *   - `org:<organizationId>`  — every member of the organization
- *   - `user:<participantId>`  — the participant itself
- *   - `project:<projectId>`   — every credential scoped to the project; the
- *     organization's default project shares the organization's id
- *
- * Schema-declared roles ({@link identityRole} and {@link entityRole}) extend
- * this vocabulary per application; the kinds here are the ones the engine
- * reserves.
- */
-export const IDENTITY_ANCHOR_KINDS = ['org', 'user', 'project'];
-/** Mint an engine-reserved identity anchor (typed wrapper over {@link syncGroup}). */
-export function identityAnchor(kind, id) {
-    return syncGroup(kind, id);
-}
-// ── Role source ─────────────────────────────────────────────────────────────
-/** Validates how a role pulls ids out of a context (identity or record). */
-export const roleSourceSchema = z.object({
-    /** The context field to read, e.g. `'organizationId'`, `'id'`, `'reportId'`. */
-    field: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, 'source must be a valid identifier'),
-    /**
-     * When `true`, `field` holds an array; every non-empty string element yields
-     * one group. When `false` (default), `field` is a scalar; truthy → one group.
-     */
-    multi: z.boolean(),
-});
-// ── Role (kind + source — no template string) ───────────────────────────────
-/**
- * A sync-group role: a typed `kind` plus the field that supplies the id. The
- * wire string is `${kind}:${id}`, built by the engine — there is deliberately
- * no template/placeholder for the author to get wrong.
- */
-export const roleSchema = z.object({
-    kind: z.string().regex(/^[a-z][a-z0-9_]*$/, 'kind must be a lowercase identifier, e.g. "report"'),
-    source: roleSourceSchema,
-});
-/** Validates an {@link IdentityRole}. */
-export const identityRoleSchema = roleSchema;
-/** Validates an {@link EntityRole}. */
-export const entityRoleSchema = roleSchema;
-/**
- * Validates a model's `scope` declaration: `true` (kind = typename) or an
- * explicit lowercase kind string. The same vocabulary the roles use, so the
- * whole sync-group declaration surface is Zod-validated, not hand-checked.
- */
-export const scopeSchema = z.union([
-    z.boolean(),
-    z.string().regex(/^[a-z][a-z0-9_]*$/, 'scope kind must be a lowercase identifier, e.g. "workspace"'),
-]);
-/**
- * Validates a model's `grants` membership edge. Both values are relation names
- * declared on the same model (`subject` → identity, `scope` → scope root); that
- * the relations actually exist + are `belongsTo` is a cross-field check done in
- * `defineSchema` where the relation map is in scope.
- */
-export const grantsRefSchema = z.object({
-    subject: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, 'grants.subject must name a relation'),
-    scope: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, 'grants.scope must name a relation'),
-});
-/**
- * The authoring form of a model's sync-group routing — the `groups: { ... }`
- * option. One object collects the three independent routing controls. This is a
- * separate concern from `policy`, which governs tenant isolation: `policy`
- * decides who may read a row, while `groups` decides which change channels a row
- * fans into.
- *
- * - `root`   — marks this model a scope root, so its records form the group
- *   `<kind>:<id>` (the kind defaults to the typename).
- * - `grants` — a membership edge granting an identity access to a scope root.
- * - `roles`  — record-to-group roles keyed on a plain field rather than a
- *   relation, such as inbox fan-out. Accepts a single role or an array.
- */
-export const groupsInputSchema = z.object({
-    root: scopeSchema.optional(),
-    grants: grantsRefSchema.optional(),
-    roles: z.union([entityRoleSchema, z.array(entityRoleSchema)]).optional(),
-});
-// ── Factories ───────────────────────────────────────────────────────────────
-function makeRole(spec) {
-    return { kind: spec.kind, source: { field: spec.source, multi: spec.multi ?? false } };
-}
-/** Build an identity-anchored role. `multi` defaults to `false`. */
-export function identityRole(spec) {
-    return makeRole(spec);
-}
-/** Build a record-anchored role. `multi` defaults to `false`. */
-export function entityRole(spec) {
-    return makeRole(spec);
-}
-// ── Evaluation ──────────────────────────────────────────────────────────────
-/**
- * Evaluate a {@link RoleSource} against a context. Absent or falsy fields yield
- * `[]`, so a role whose field isn't present (a user with no `teamIds`, a record
- * with no `reportId`) is a silent no-op.
- */
-export function extractRoleIds(context, source) {
-    const raw = context[source.field];
-    if (source.multi) {
-        return Array.isArray(raw)
-            ? raw.filter((t) => typeof t === 'string' && t.length > 0)
-            : [];
-    }
-    return raw ? [String(raw)] : [];
-}
-/** Identity-side name for {@link extractRoleIds}. */
-export const extractIdentityIds = extractRoleIds;
-/** Record-side name for {@link extractRoleIds}. */
-export const extractEntityIds = extractRoleIds;
-/**
- * Compose the sync groups an identity may subscribe to, from the schema's
- * registered {@link IdentityRole}s. Returns `[]` when no role produces an id;
- * the caller treats `[]` as "no scope", not "match everything".
- */
-export function composeIdentitySyncGroups(identity, schema) {
-    const out = new Set();
-    for (const role of schema.identityRoles) {
-        for (const id of extractRoleIds(identity, role.source)) {
-            if (id)
-                out.add(syncGroup(role.kind, id));
-        }
-    }
-    return Array.from(out);
-}
-/**
- * Compose the sync groups a record belongs to, from the model's registered
- * {@link EntityRole}s. Mirror of {@link composeIdentitySyncGroups}, reading the
- * record instead of an identity. Returns `[]` when the model has no entity
- * roles (the delta then fans on its base `org:`/`user:` groups only).
- */
-export function composeEntitySyncGroups(record, def) {
-    if (!def.entityRoles?.length)
-        return [];
-    const out = new Set();
-    for (const role of def.entityRoles) {
-        for (const id of extractRoleIds(record, role.source)) {
-            if (id)
-                out.add(syncGroup(role.kind, id));
-        }
-    }
-    return Array.from(out);
-}
-/**
- * Narrow a client's requested sync-group set to the groups it is actually
- * allowed to subscribe to. This helper is fully generic — it never inspects the
- * group strings — so it lives beside the composition helpers above.
- *
- * Behaviour:
- *   - If the client requested no groups, return the full identity-derived set,
- *     which is this participant's default subscription scope.
- *   - If the client requested some groups, keep only those that appear in the
- *     identity-derived allowed set and drop the rest, reporting the dropped
- *     groups through the optional `logDropped` callback.
- *   - If nothing survives the filter, fall back to the full allowed set rather
- *     than return `[]`, which would otherwise collapse to the server-side
- *     `'default'` fallback and deliver no changes at all.
- */
-export function intersectRequestedWithAllowed(args) {
-    const { requested, allowed, logDropped } = args;
-    if (requested.length === 0)
-        return allowed;
-    const allowedSet = new Set(allowed);
-    const accepted = [];
-    const dropped = [];
-    for (const g of requested) {
-        if (allowedSet.has(g))
-            accepted.push(g);
-        else
-            dropped.push(g);
-    }
-    if (dropped.length > 0 && logDropped)
-        logDropped(dropped);
-    return accepted.length > 0 ? accepted : allowed;
-}

package/dist/transaction/schema/schema.d.ts

@@ -1,351 +0,0 @@
-/**
- * Schema Definition + Type Inference
- *
- * defineSchema() wraps your models. Types are inferred via Zod — no custom type system.
- *
- * Usage:
- *   import { z } from 'zod';
- *   import { defineSchema, model, relation } from '@abloatai/ablo/schema';
- *
- *   const schema = defineSchema({
- *     tasks: model({
- *       title: z.string(),
- *       status: z.enum(['todo', 'doing', 'done']).default('todo'),
- *       projectId: z.string().optional(),
- *     }, {
- *       project: relation.belongsTo('projects', 'projectId'),
- *     }),
- *   });
- *
- *   type Task = InferModel<typeof schema, 'tasks'>;
- */
-import { z } from 'zod';
-import type { ModelDef, RelationRecord } from './model.js';
-import type { RelationDef } from './relation.js';
-import type { IdentityRole } from './roles.js';
-import { type FieldRef } from './fieldRef.js';
-export { type IdentityRole, type IdentityRoleSource, type IdentityContext, type EntityRole, type EntityRoleSource, type EntityContext, type RoleSource, type RoleContext, type SyncGroup, type SyncGroupInput, identityRole, entityRole, extractIdentityIds, extractEntityIds, composeIdentitySyncGroups, composeEntitySyncGroups, intersectRequestedWithAllowed, syncGroup, syncGroupSchema, syncGroupInputSchema, isSyncGroupInput, identityRoleSchema, entityRoleSchema, roleSchema, roleSourceSchema, scopeSchema, grantsRefSchema, groupsInputSchema, type GroupsInput, } from './roles.js';
-/** The set of built-in casing conventions supported by `defineSchema`. */
-export type CasingConvention = 'snake_case' | 'camelCase';
-/** Plug point for custom conventions (e.g. mixed legacy databases). */
-export type CasingFn = (jsField: string) => string;
-/** `defineSchema`'s casing option. Identity when unset. */
-export type Casing = CasingConvention | CasingFn;
-/**
- * A server-authored identity value that can fill one of a customer's Postgres
- * session settings. Deliberately a closed set — every member is resolved by Ablo
- * from the authenticated `ek_` and the plane, never from client-supplied data —
- * so a mapping can forward the tenant identity Ablo already trusts but can never
- * widen a writer's scope. Mirrors the fields the engine sets on the direct-write
- * connection (`app.current_org_id`, `app.current_project_id`, …).
- */
-export type SessionSettingSource = 'orgId' | 'projectId' | 'environment' | 'sandboxId' | 'participantId' | 'participantKind';
-/**
- * A map from a Postgres session-setting name the customer's RLS policies read to
- * the Ablo identity that fills it — e.g. `{ 'app.current_org': 'orgId' }`. The
- * setting name is the key (it takes exactly one source), so a duplicate is
- * unrepresentable rather than validated away. See
- * {@link DefineSchemaOptions.sessionSettings} and ADR 0011.
- */
-export type SessionSettings = Readonly<Record<string, SessionSettingSource>>;
-/**
- * Session settings Ablo already sets on its direct-write connection. A
- * `sessionSettings` entry FORWARDS Ablo's trusted context into a setting the
- * customer's own policies read — it may never reassign one of these, which would
- * let a schema push relax the engine's own scoping, timeouts, or `row_security`.
- * Shared with the engine's direct-write seam so authoring-time validation and
- * the runtime guard read one list. See ADR 0011.
- */
-export declare const RESERVED_SESSION_SETTINGS: readonly string[];
-export interface DefineSchemaOptions {
-    /**
-     * How to translate camelCase JS field names into database column
-     * identifiers. Applied once, at schema build, to every relation's
-     * `foreignKey` to produce `foreignKeyColumn`. Consumers whose DB
-     * columns already match their JS field names can omit this — the
-     * default is identity (no transform).
-     *
-     * Accepts a named convention or a custom function:
-     *
-     * ```ts
-     * defineSchema({ ... }, { casing: 'snake_case' })
-     * defineSchema({ ... }, { casing: (key) => key.toUpperCase() })
-     * ```
-     */
-    readonly casing?: Casing;
-    /**
-     * Identity-anchored sync-group roles. The server's
-     * `composeIdentitySyncGroups` reads these to build the set of groups a
-     * participant may subscribe to. See {@link IdentityRole} for the shape: you
-     * define the `kind` and which identity field supplies the id, with no fixed
-     * vocabulary of kinds.
-     *
-     * Leave this unset for schemas that need no identity-derived scoping, such as
-     * fully public read models. When it is unset, `composeIdentitySyncGroups`
-     * returns `[]` and callers fall back to whatever explicit sync groups the
-     * authentication provider attached to the identity.
-     */
-    readonly identityRoles?: readonly IdentityRole[];
-    /**
-     * Extra Postgres session settings Ablo's direct-write connection applies from
-     * your authenticated identity, so your row-level-security policies read them
-     * (ADR 0011). Before every direct write, Ablo already `SET LOCAL`s a fixed
-     * bundle (`app.current_org_id`, `app.current_project_id`, …). If your policies
-     * read a differently-named setting your own app sets per-connection — e.g. a
-     * restrictive policy on `current_setting('app.current_org')` — map that
-     * setting to the identity that fills it, and Ablo sets it too:
-     *
-     * ```ts
-     * defineSchema({ ... }, {
-     *   sessionSettings: { 'app.current_org': 'orgId' },
-     * })
-     * ```
-     *
-     * The key is the setting name your policies read; the value is a closed set of
-     * identities Ablo authenticates, so a mapping can narrow what the writer sees
-     * but never widen it. Do NOT carve a policy exception for the writer role —
-     * that exempts exactly the writes you want governed. Leave unset when your
-     * policies read the settings Ablo already applies (or when a table has no RLS).
-     */
-    readonly sessionSettings?: SessionSettings;
-}
-/** A record of model names → model definitions */
-export type SchemaRecord = Record<string, ModelDef>;
-/**
- * Base fields every synced model gets automatically.
- *
- * Exported (internal) so `parseSchema` can rebuild a model's validator the
- * same way `defineSchema` does — `baseFieldsSchema.merge(modelSchema)` — when
- * reconstructing a `Schema` from its JSON form.
- */
-export declare const baseFieldsSchema: z.ZodObject<{
-    id: z.ZodString;
-    createdAt: z.ZodDate;
-    updatedAt: z.ZodDate;
-    organizationId: z.ZodOptional<z.ZodString>;
-    createdBy: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-/**
- * The base-column names every model carries automatically — the keys of
- * {@link baseFieldsSchema}, kept here as the single source of truth. Code
- * generation reads it to avoid emitting a base column twice, and
- * {@link defineSchema} uses it to reject a model that redeclares one, since
- * merging the user's field over the base field would produce a `string & Date`
- * type and break the build.
- */
-export declare const BASE_FIELDS: readonly ["id", "createdAt", "updatedAt", "organizationId", "createdBy"];
-/** The base fields type — pure data columns. */
-export type BaseModelFields = z.infer<typeof baseFieldsSchema>;
-/**
- * Methods every model instance carries. These are intersected into
- * {@link InferModel}, the read-side type, but not into the create or update
- * input types, since methods are not valid input.
- */
-export interface BaseModelMethods {
-    /** Wire-format model name (e.g. `'Section'`, `'Comment'`). */
-    getModelName(): string;
-    /** Plain-object serialization suitable for sending over the wire. */
-    toJSON(): Record<string, unknown>;
-}
-/** The schema object returned by defineSchema() */
-export interface Schema<S extends SchemaRecord = SchemaRecord> {
-    /** The raw model definitions */
-    readonly models: S;
-    /**
-     * Every declared field as a {@link FieldRef} — the field as a value rather
-     * than a quoted name: `schema.fields.tasks.status`.
-     *
-     * A surface that names a field takes one of these instead of a string, so a
-     * name that does not exist stops compiling and a rename is a compile error at
-     * every use. Claims are the first caller; anything else that has to say
-     * "which field" should take a reference for the same reason.
-     *
-     * Base fields (`id`, `createdAt`, …) are not here: the schema does not
-     * declare them, and a caller naming one means the row, not a part of it.
-     */
-    readonly fields: {
-        readonly [K in keyof S]: S[K] extends ModelDef<infer Shape> ? {
-            readonly [F in Extract<keyof Shape, string>]: FieldRef;
-        } : never;
-    };
-    /** Zod schemas with base fields merged in */
-    readonly validators: {
-        readonly [K in keyof S]: S[K] extends ModelDef<infer Shape> ? z.ZodObject<Shape & typeof baseFieldsSchema.shape> : never;
-    };
-    /**
-     * Identity-anchored sync-group roles registered via
-     * `defineSchema({...}, { identityRoles })`. Empty array when unset.
-     * Server's `composeIdentitySyncGroups(identity, schema)` reads this
-     * to derive a participant's allowed sync-group set.
-     */
-    readonly identityRoles: readonly IdentityRole[];
-    /**
-     * Session settings registered via `defineSchema({...}, { sessionSettings })`
-     * (ADR 0011). The engine's direct-write path reads this to `SET LOCAL` each
-     * named setting from server-authored context before applying DML, so the
-     * customer's RLS governs Ablo's writes. Empty object when unset.
-     */
-    readonly sessionSettings: SessionSettings;
-    /**
-     * Set only on a projection produced by `selectModels`/`omitModels`: the
-     * content hash of the FULL source schema the subset was cut from. A subset
-     * hashes differently from the full schema it belongs to, so a projection-bound
-     * client would otherwise always report drift against a server running the full
-     * schema. The drift check treats the client as in-sync when the server's active
-     * hash matches EITHER this client's own (subset) hash or this source hash — so
-     * a current projection stays quiet while a genuinely behind server still warns.
-     * Absent on a schema authored directly, where the client's own hash is the
-     * deployed hash and plain equality is correct. Excluded from `toSchemaJSON`, so
-     * stamping it never perturbs `schemaHash`.
-     */
-    readonly sourceSchemaHash?: string;
-}
-/**
- * Infer the full model type from a schema.
- * Includes base fields (id, createdAt, updatedAt, etc.)
- *
- * ```ts
- * type Task = InferModel<typeof schema, 'tasks'>;
- * ```
- */
-/** The schema bound via `declare module … interface Register { Schema: … }`
- *  (the `ablo/register.ts` the scaffold writes). `never` when not registered. */
-type RegisteredSchema = import('../types/global.js').Register extends {
-    Schema: infer S extends Schema;
-} ? S : never;
-/**
- * The primary model-type helper. Once your project's `ablo/register.ts`
- * registers the schema, a single argument is all it takes:
- *
- * ```ts
- * type Task = Model<'tasks'>;
- * ```
- *
- * Without that registration, or for a second schema, pass the schema
- * explicitly: `Model<typeof schema, 'tasks'>`.
- */
-export type Model<A, B = never> = [B] extends [never] ? A extends keyof RegisteredSchema['models'] ? InferModel<RegisteredSchema, A> : never : A extends Schema ? InferModel<A, B extends keyof A['models'] ? B : never> : never;
-/**
- * The row type {@link Model} resolves to. Internal: `Model<typeof schema,
- * 'tasks'>` is the published spelling, because it reads as the domain rather
- * than the machinery. This one is no longer exported from any subpath — it
- * stays because `Model` is defined in terms of it, not as a second name for
- * the same idea.
- */
-export type InferModel<S extends Schema, ModelName extends keyof S['models']> = S['models'][ModelName] extends ModelDef<infer Shape, infer R, infer C> ? // `Omit<…, keyof BaseModelFields>` so a model that (wrongly) redeclares a
-Omit<z.infer<z.ZodObject<Shape>>, keyof BaseModelFields> & BaseModelFields & BaseModelMethods & InferComputed<C> & InferRelations<S, R> : never;
-/**
- * Infer the relation accessor types from a model's relations record.
- *
- * At runtime the engine installs a getter for each declared relation, so this
- * type mirrors them and you can read `section.blocks` and `section.report` without a
- * cast.
- *
- * - `hasMany` → `InferModel<S, Target>[]`
- * - `belongsTo` / `hasOne` → `InferModel<S, Target> | undefined` (undefined
- *   when the foreign key is unset or the parent has not loaded yet)
- *
- * Kept `readonly` because the accessors are getters with no setter — assigning
- * to `section.blocks` would have no effect at runtime.
- */
-export type InferRelations<S extends Schema, R extends RelationRecord> = string extends keyof R ? unknown : {
-    readonly [K in keyof R]: R[K] extends RelationDef<infer Type, infer Target> ? Target extends keyof S['models'] ? Type extends 'hasMany' ? InferModel<S, Target>[] : Type extends 'hasOne' | 'belongsTo' ? InferModel<S, Target> | undefined : never : never : never;
-};
-/**
- * The row shape a reactive read returns: the model's data fields, base fields,
- * and schema computed getters — WITHOUT relation accessors and WITHOUT model
- * methods. Derived from the model definition, exactly like {@link InferModel},
- * mirroring what `toReactiveSnapshot()` produces at runtime.
- *
- * Relations (`hasMany` / `belongsTo`) are store-backed getters that exist only
- * on the pool's model instances, so a reactive row honestly omits them —
- * reading `row.blocks` is a compile error instead of a silent `undefined`.
- * Compose relations through a selector or hook instead.
- *
- * The same pairing other data layers converged on: Zero's data-only `Row<...>`
- * with relations added per-query, Prisma's scalar-only model types with
- * `GetPayload<{ include }>`, mobx-state-tree's `Instance<T>` / `SnapshotOut<T>`.
- */
-export type InferRow<S extends Schema, ModelName extends keyof S['models']> = S['models'][ModelName] extends ModelDef<infer Shape, RelationRecord, infer C> ? // Same reserved-field guard as InferModel — see the comment there.
-Omit<z.infer<z.ZodObject<Shape>>, keyof BaseModelFields> & BaseModelFields & InferComputed<C> : never;
-/**
- * The reactive-row companion to {@link Model}. Once your project's
- * `ablo/register.ts` registers the schema, a single argument is all it takes:
- *
- * ```ts
- * type SectionRow = Row<'sections'>;    // data fields + computeds, no relations
- * type Section    = Model<'sections'>;  // the pool's model instance
- * ```
- *
- * Without that registration, or for a second schema, pass the schema
- * explicitly: `Row<typeof schema, 'sections'>`.
- */
-export type Row<A, B = never> = [B] extends [never] ? A extends keyof RegisteredSchema['models'] ? InferRow<RegisteredSchema, A> : never : A extends Schema ? InferRow<A, B extends keyof A['models'] ? B : never> : never;
-/**
- * Infer the return types of computed getters.
- * Maps each computed function's return type into a readonly property.
- *
- * ```ts
- * // Given: computed: { displayTitle: (self) => self.title || 'Untitled' }
- * // Infers: { readonly displayTitle: string }
- * ```
- */
-export type InferComputed<C> = string extends keyof C ? unknown : {
-    readonly [K in keyof C]: C[K] extends (...args: any[]) => infer R ? R : never;
-};
-/**
- * Infer the create input type. Only schema-defined fields are accepted —
- * base fields (id, createdAt, updatedAt) are auto-generated by the SDK
- * and cannot be passed by the consumer.
- *
- * The only exception is `id`: consumers can optionally provide one for
- * client-generated IDs (useful for optimistic UI that needs to reference
- * the entity before the server confirms).
- *
- * ```ts
- * type CreateTask = InferCreate<typeof schema, 'tasks'>;
- * // { title: string; status?: 'todo' | 'doing' | 'done'; id?: string }
- * // createdAt, updatedAt are NOT accepted — they're auto-generated
- * ```
- */
-export type InferCreate<S extends Schema, ModelName extends keyof S['models']> = S['models'][ModelName] extends ModelDef<infer Shape> ? // Same reserved-field guard as InferModel: drop any (wrongly) redeclared
-Omit<z.input<z.ZodObject<Shape>>, keyof BaseModelFields> & Partial<BaseModelFields> : never;
-/**
- * Extract all model names from a schema.
- */
-export type InferModelNames<S extends Schema> = keyof S['models'] & string;
-/**
- * The value type for inserting a new row. Same shape as {@link InferCreate}:
- * the fields you can write, plus an optional `id` for client-generated ids.
- */
-export type InsertValue<S extends Schema, ModelName extends keyof S['models']> = InferCreate<S, ModelName>;
-/**
- * The value type for upserting (insert or overwrite). Same shape as
- * {@link InsertValue} — a full row. If a row with the same `id` exists,
- * it gets overwritten.
- */
-export type UpsertValue<S extends Schema, ModelName extends keyof S['models']> = InsertValue<S, ModelName>;
-/**
- * The value type for updating an existing row. `id` is required (identifies
- * the row to update); all other fields are optional (only provided fields
- * are changed).
- */
-export type UpdateValue<S extends Schema, ModelName extends keyof S['models']> = S['models'][ModelName] extends ModelDef<infer Shape> ? {
-    id: string;
-} & Partial<z.input<z.ZodObject<Shape>>> : never;
-/**
- * The value type for deleting a row. Just the primary key.
- */
-export interface DeleteId<S extends Schema, ModelName extends keyof S['models']> {
-    id: string;
-}
-/**
- * One {@link FieldRef} per declared field, keyed by model then field.
- *
- * Every construction of a {@link Schema} goes through here — `defineSchema`,
- * the `selectModels`/`omitModels` projections, and the deserializer — so a
- * projection carries references for exactly the models it kept and a schema
- * rebuilt from JSON carries them at all.
- */
-export declare function buildFieldRefs(models: Record<string, ModelDef>): Record<string, Record<string, FieldRef>>;
-export declare function defineSchema<const S extends SchemaRecord>(models: S, options?: DefineSchemaOptions): Schema<S>;