@abloatai/ablo 0.3.0

package/dist/schema/model.d.ts

@@ -0,0 +1,326 @@
+/**
+ * Schema Model Definition
+ *
+ * A model is a Zod object schema + optional relations.
+ * Types are inferred directly from Zod — no custom type system.
+ *
+ * Usage:
+ *   import { z } from 'zod';
+ *   import { model, relation } from '@ablo/sync-engine/schema';
+ *
+ *   const tasks = model({
+ *     title: z.string(),
+ *     status: z.enum(['todo', 'doing', 'done']).default('todo'),
+ *     projectId: z.string().optional(),
+ *   }, {
+ *     project: relation.belongsTo('projects', 'projectId'),
+ *   });
+ */
+import { z } from 'zod';
+import type { RelationDef } from './relation.js';
+import { type FieldMeta } from './field.js';
+/**
+ * Controls when model data is loaded from the server.
+ *
+ * - `'instant'` — loaded during bootstrap (appears immediately on page load)
+ * - `'lazy'`    — loaded on first access (e.g., when you navigate to a page that needs it)
+ * - `'manual'`  — only loaded when you explicitly call sync.model.load()
+ */
+export type LoadStrategy = 'instant' | 'lazy' | 'manual';
+/** A record of relation definitions */
+export type RelationRecord = Record<string, RelationDef>;
+/**
+ * Persistence hints for IndexedDB write-through and hydration.
+ *
+ * The sync engine's generic loader uses these to route incoming rows to
+ * the right client-side store without the consumer wiring each model by
+ * hand. `store` defaults to the model's {@link ModelDef.typename} (which
+ * itself defaults to the schema key), so consumers only set this when
+ * the IDB store name diverges from the typename.
+ */
+export interface PersistOptions {
+    /**
+     * Name of the IndexedDB object store that backs this model.
+     * Defaults to the model's {@link ModelDef.typename}.
+     */
+    store?: string;
+}
+/**
+ * Describes how to scope a table's rows via a parent table. See
+ * {@link ModelOptions.scopedVia} for semantics and code emitted.
+ */
+export interface ScopedViaRef {
+    /** Column on THIS table that points at `parentKey` (e.g. `'team_id'`). */
+    localKey: string;
+    /** Parent table name (e.g. `'team'`, `'member'`). */
+    parentTable: string;
+    /** Column on the parent that `localKey` references. Default: `'id'`. */
+    parentKey?: string;
+    /** Column on the parent holding the tenant id. Default: `'organization_id'`. */
+    parentOrgColumn?: string;
+}
+/** Options for model() */
+export interface ModelOptions {
+    /** When to load this model's data. Default: 'instant' */
+    load?: LoadStrategy;
+    /** Max records to bootstrap. Default: unlimited. Only applies to 'instant' strategy. */
+    bootstrapLimit?: number;
+    /** Order to sort by during bootstrap (e.g., 'created_at DESC'). */
+    bootstrapOrderBy?: string;
+    /**
+     * The GraphQL/wire `__typename` value for this model.
+     *
+     * Used by the generic loader + hydration pipeline to stamp `__typename`
+     * on raw rows before `pool.createFromData(...)`, and to look up the
+     * matching class in the model registry. Defaults to the schema key
+     * (e.g., `tasks` → `'tasks'`). Provide explicitly when the wire shape
+     * uses a different casing (e.g., schema key `slideLayer` → typename
+     * `'SlideLayer'`).
+     *
+     * This is the single source of truth for "what identifies this model
+     * on the wire." Every other layer (IDB store name, query.returns
+     * references, delta routing) resolves through this value.
+     */
+    typename?: string;
+    /**
+     * IndexedDB persistence hints. See {@link PersistOptions}.
+     */
+    persist?: PersistOptions;
+    /**
+     * The actual database table name. Defaults to snake_case of the model
+     * name if not provided. Used by the bootstrap query builder to know
+     * which table to SELECT from — without this, the server has to guess
+     * via a naming convention that may not match the Prisma @@map directive.
+     */
+    tableName?: string;
+    /**
+     * Whether this model's table has an organization_id column.
+     * Default: true. When false, the bootstrap query omits the
+     * `WHERE organization_id = $1` clause for this model.
+     */
+    orgScoped?: boolean;
+    /**
+     * Scope rows via a parent table when THIS table has no
+     * `organization_id` column of its own, but rows still belong to a
+     * tenant via a foreign key (e.g. `memberRoles.member_id → member.id`,
+     * `teamMember.team_id → team.id`, `users.id ← member.user_id`).
+     *
+     * Emits, in place of the missing `organization_id = $1` clause:
+     *
+     *   WHERE <table>.<localKey> IN
+     *     (SELECT <parentKey> FROM <parentTable> WHERE <parentOrgColumn> = $1)
+     *
+     * Use this INSTEAD of `orgScoped: false` for any `load: 'instant'`
+     * model whose rows would otherwise leak cross-tenant on bootstrap —
+     * dropping the filter entirely exposes the entire DB to every client.
+     *
+     * Identifiers must match the regular `[a-zA-Z_][a-zA-Z0-9_]*` shape;
+     * the SQL compiler validates them to keep this away from injection
+     * paths.
+     */
+    scopedVia?: ScopedViaRef;
+    /**
+     * Template for the sync group this entity lives in. When set, the
+     * participant APIs can derive a transport scope from the entity id.
+     * The single `{id}` placeholder is substituted with the scope id.
+     *
+     * Example: `syncGroupFormat: 'matter:{id}'` + `scope: { matters: 'acme-q3' }`
+     * yields a capability restricted to `sync_group: ['matter:acme-q3']`.
+     *
+     * Leave unset for entities that aren't directly scopable (nested
+     * children whose access derives from their parent — e.g. a `redline`
+     * inside a `document` inside a `matter`).
+     */
+    syncGroupFormat?: string;
+    /**
+     * Whether clients may issue CREATE/UPDATE/DELETE mutations for this
+     * model via the `commit` wire protocol. Default: false.
+     *
+     * Safety-by-default: a newly-declared schema entity is read-only from
+     * the client side until the author explicitly opts into wire mutability.
+     * Prevents the class of bug where adding a new entity to the schema
+     * silently exposes it as a write surface (the 2026-04-20 `AgentJob`
+     * incident) OR where internal tables (`sync_deltas`, `presences`,
+     * digest/ingestion tables) become writable by accident.
+     *
+     * The server's `buildModelMap` (src/server/commit.ts) derives
+     * the mutation allowlist from this flag — no parallel hardcoded list.
+     */
+    mutable?: boolean;
+    /**
+     * Defer MobX observability setup until the model is first accessed
+     * by an observer component. Default: false (observe immediately).
+     *
+     * Use for models that are created in bulk (e.g., during import or
+     * batch bootstrap) where most instances are never rendered. The
+     * model's constructor skips makeObservable(); instead, consuming
+     * code calls model.makeObservable() when the model enters the
+     * render tree. This matches Ablo's SlideLayer.ensureObservable()
+     * pattern and avoids ~10ms of MobX setup overhead per instance
+     * when creating hundreds of models that never get observed.
+     */
+    lazyObservable?: boolean;
+    /**
+     * Computed getters installed on the dynamic model class prototype.
+     *
+     * Each key becomes a getter on the model instance. The function receives
+     * `self` (the model instance) and returns the computed value. These replace
+     * hand-coded getter methods on legacy Model subclasses.
+     *
+     * @example
+     * model({ title: z.string(), metadata: z.string() }, {}, {
+     *   computed: {
+     *     displayTitle: (self) => self.title || `Untitled`,
+     *     metadataObject: (self) => {
+     *       try { return JSON.parse(self.metadata || '{}'); }
+     *       catch { return {}; }
+     *     },
+     *   },
+     * })
+     */
+    computed?: ComputedRecord;
+    /**
+     * Fields to back-fill from the sync client identity when missing
+     * during IndexedDB self-healing.
+     *
+     * Healing runs on every row loaded from IDB at hydration time and on
+     * every delta merge. If the row is missing one of these fields, the
+     * engine writes the corresponding identity value (`organizationId` /
+     * `userId` from `SyncClient.initialize`) into the row before passing
+     * it to the ObjectPool. Without this, rows from a past version that
+     * didn't write the field would surface as `undefined` and break any
+     * code that assumes the field is set.
+     *
+     * @example
+     * autoFill: [
+     *   { field: 'organizationId', from: 'organizationId' },
+     *   { field: 'createdBy', from: 'userId' },
+     * ]
+     */
+    autoFill?: readonly AutoFillRule[];
+    /**
+     * Fields whose absence makes a stored row "orphaned" — corrupt
+     * enough that the engine should drop it instead of loading it.
+     *
+     * Healing returns `null` for the row when any listed field is
+     * missing, which causes the caller to skip pool insertion for that
+     * record. Use for foreign keys whose absence would crash dependent
+     * code (e.g. a `SlideLayer` with no `slideId` can't render anywhere).
+     *
+     * @example requiredFields: ['slideId']
+     */
+    requiredFields?: readonly string[];
+}
+/** Base type for computed getter records. Preserves return types via inference. */
+export type ComputedRecord = Record<string, (self: any) => any>;
+/**
+ * Identity sources the sync engine can pull from when auto-filling a
+ * record's missing field during IndexedDB self-healing.
+ *
+ * - `'organizationId'` — the org id passed to `SyncClient.initialize`
+ * - `'userId'` — the user id passed to `SyncClient.initialize`
+ */
+export type AutoFillSource = 'organizationId' | 'userId';
+/**
+ * Declaration of a field that should be back-filled from the connected
+ * sync identity if missing from a stored row.
+ *
+ * Used by `SyncClient.healModelRecord` to repair pre-existing IDB rows
+ * that were written without `organizationId` / `createdBy` due to past
+ * bugs in delta merging. Declared per-model so the engine itself stays
+ * product-neutral.
+ */
+export interface AutoFillRule {
+    /** Field name on the model (e.g. `'organizationId'`, `'createdBy'`). */
+    field: string;
+    /** Where to read the replacement value from on the sync client. */
+    from: AutoFillSource;
+}
+/** A complete model definition: Zod shape + fields metadata + relations + options */
+export interface ModelDef<Shape extends z.ZodRawShape = z.ZodRawShape, R extends RelationRecord = RelationRecord, C extends ComputedRecord = ComputedRecord> {
+    /** The Zod object schema for this model's fields */
+    readonly schema: z.ZodObject<Shape>;
+    /** The raw shape (for type inference) */
+    readonly shape: Shape;
+    /**
+     * Runtime metadata for each field, keyed by field name.
+     *
+     * Populated automatically from `field.*()` builders. Fields defined
+     * with raw Zod (e.g., `z.string()`) get a fallback metadata entry
+     * with type inferred from Zod's `_def.typeName`.
+     *
+     * Used by the CLI (`npx ablo migrate`), admin panels, and any tooling
+     * that needs to introspect the schema without parsing Zod internals.
+     */
+    readonly fields: Record<string, FieldMeta>;
+    /** Relations to other models */
+    readonly relations: R;
+    /** Load strategy */
+    readonly load: LoadStrategy;
+    /** Max records to bootstrap */
+    readonly bootstrapLimit?: number;
+    /** Sort order for bootstrap */
+    readonly bootstrapOrderBy?: string;
+    /**
+     * The GraphQL/wire `__typename` value for this model. When unset in
+     * {@link ModelOptions}, this falls back to the schema key at schema
+     * assembly time (see `defineSchema`).
+     */
+    readonly typename?: string;
+    /** IndexedDB persistence hints. See {@link PersistOptions}. */
+    readonly persist?: PersistOptions;
+    /** The actual database table name from Prisma @@map. See {@link ModelOptions.tableName}. */
+    readonly tableName?: string;
+    /** Whether the table has organization_id. See {@link ModelOptions.orgScoped}. */
+    readonly orgScoped?: boolean;
+    /** Parent-table scoping for rows with no organization_id. See {@link ModelOptions.scopedVia}. */
+    readonly scopedVia?: ScopedViaRef;
+    /** Template for participant scope derivation. See {@link ModelOptions.syncGroupFormat}. */
+    readonly syncGroupFormat?: string;
+    /** Whether wire-level CREATE/UPDATE/DELETE is allowed. See {@link ModelOptions.mutable}. */
+    readonly mutable?: boolean;
+    /** Defer MobX setup until first observer access. See {@link ModelOptions.lazyObservable}. */
+    readonly lazyObservable?: boolean;
+    /** Computed getters for the dynamic model class. See {@link ModelOptions.computed}. */
+    readonly computed?: C;
+    /** Auto-fill rules for IDB self-healing. See {@link ModelOptions.autoFill}. */
+    readonly autoFill?: readonly AutoFillRule[];
+    /** Fields whose absence orphans a row. See {@link ModelOptions.requiredFields}. */
+    readonly requiredFields?: readonly string[];
+}
+/**
+ * Define a model with a Zod shape and optional relations.
+ *
+ * ```ts
+ * import { z } from 'zod';
+ * import { model, relation } from '@ablo/sync-engine/schema';
+ *
+ * const tasks = model({
+ *   title: z.string(),
+ *   status: z.enum(['todo', 'doing', 'done']).default('todo'),
+ *   priority: z.number().default(0),
+ *   projectId: z.string().optional(),
+ * }, {
+ *   project: relation.belongsTo('projects', 'projectId'),
+ * });
+ * ```
+ */
+/**
+ * Define a model with fields, optional relations, and load strategy.
+ *
+ * ```ts
+ * // Loaded at bootstrap (default)
+ * const tasks = model({ title: z.string() });
+ *
+ * // Loaded on first access (lazy)
+ * const slideLayers = model({ slideId: z.string(), type: z.string() }, {
+ *   slide: relation.belongsTo('slides', 'slideId'),
+ * }, { load: 'lazy' });
+ *
+ * // Only loaded when explicitly requested
+ * const auditLogs = model({ action: z.string() }, {}, { load: 'manual' });
+ * ```
+ */
+export declare function model<Shape extends z.ZodRawShape, R extends RelationRecord = Record<string, never>, C extends ComputedRecord = Record<string, never>>(shape: Shape, relations?: R, options?: ModelOptions & {
+    computed?: C;
+}): ModelDef<Shape, R, C>;

package/dist/schema/model.js

@@ -0,0 +1,89 @@
+/**
+ * Schema Model Definition
+ *
+ * A model is a Zod object schema + optional relations.
+ * Types are inferred directly from Zod — no custom type system.
+ *
+ * Usage:
+ *   import { z } from 'zod';
+ *   import { model, relation } from '@ablo/sync-engine/schema';
+ *
+ *   const tasks = model({
+ *     title: z.string(),
+ *     status: z.enum(['todo', 'doing', 'done']).default('todo'),
+ *     projectId: z.string().optional(),
+ *   }, {
+ *     project: relation.belongsTo('projects', 'projectId'),
+ *   });
+ */
+import { z } from 'zod';
+import { getFieldMeta, inferFieldMetaFromZod } from './field.js';
+// ── Model factory ─────────────────────────────────────────────────────────
+/**
+ * Define a model with a Zod shape and optional relations.
+ *
+ * ```ts
+ * import { z } from 'zod';
+ * import { model, relation } from '@ablo/sync-engine/schema';
+ *
+ * const tasks = model({
+ *   title: z.string(),
+ *   status: z.enum(['todo', 'doing', 'done']).default('todo'),
+ *   priority: z.number().default(0),
+ *   projectId: z.string().optional(),
+ * }, {
+ *   project: relation.belongsTo('projects', 'projectId'),
+ * });
+ * ```
+ */
+/**
+ * Define a model with fields, optional relations, and load strategy.
+ *
+ * ```ts
+ * // Loaded at bootstrap (default)
+ * const tasks = model({ title: z.string() });
+ *
+ * // Loaded on first access (lazy)
+ * const slideLayers = model({ slideId: z.string(), type: z.string() }, {
+ *   slide: relation.belongsTo('slides', 'slideId'),
+ * }, { load: 'lazy' });
+ *
+ * // Only loaded when explicitly requested
+ * const auditLogs = model({ action: z.string() }, {}, { load: 'manual' });
+ * ```
+ */
+export function model(shape, relations, options) {
+    // Build the fields metadata record by walking the Zod shape.
+    // Fields built with `field.*()` have structured metadata; fields built
+    // with raw Zod get a fallback derived from the Zod typeName.
+    const fields = {};
+    for (const [name, zodType] of Object.entries(shape)) {
+        const meta = getFieldMeta(zodType);
+        if (meta) {
+            fields[name] = meta;
+        }
+        else {
+            fields[name] = inferFieldMetaFromZod(zodType);
+        }
+    }
+    return {
+        schema: z.object(shape),
+        shape,
+        fields,
+        relations: (relations ?? {}),
+        load: options?.load ?? 'instant',
+        bootstrapLimit: options?.bootstrapLimit,
+        bootstrapOrderBy: options?.bootstrapOrderBy,
+        typename: options?.typename,
+        persist: options?.persist,
+        tableName: options?.tableName,
+        orgScoped: options?.orgScoped,
+        scopedVia: options?.scopedVia,
+        syncGroupFormat: options?.syncGroupFormat,
+        mutable: options?.mutable,
+        lazyObservable: options?.lazyObservable,
+        computed: options?.computed,
+        autoFill: options?.autoFill,
+        requiredFields: options?.requiredFields,
+    };
+}

package/dist/schema/queries.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Schema Query Definitions
+ *
+ * A query is a zod input schema + a string reference to a schema model
+ * that the query returns. Types flow via `z.infer` for inputs and
+ * `InferModel` for results — the same inference path `model` and
+ * `relation` already use. No second type system.
+ *
+ * Usage:
+ *   import { z } from 'zod';
+ *   import {
+ *     defineSchema, defineQueries, model, query, relation,
+ *   } from '@ablo/sync-engine/schema';
+ *
+ *   const schema = defineSchema({
+ *     slideLayer: model(
+ *       { slideId: z.string(), type: z.string() },
+ *       { slide: relation.belongsTo('slides', 'slideId') },
+ *       { load: 'lazy', typename: 'SlideLayer', persist: {} },
+ *     ),
+ *   });
+ *
+ *   const queries = defineQueries(schema, {
+ *     slideLayersByDeck: query({
+ *       input:   z.object({ deckId: z.string() }),
+ *       returns: 'slideLayer',   // ← type-checked against schema.models
+ *     }),
+ *   });
+ *
+ *   type Input  = InferQueryInput<typeof queries.queries.slideLayersByDeck>;
+ *   //    ^? { deckId: string }
+ *   type Result = InferQueryResult<
+ *     typeof schema,
+ *     typeof queries.queries.slideLayersByDeck
+ *   >;
+ *   //    ^? Array<SlideLayer>
+ *
+ * Design notes:
+ *
+ *  - `query()` accepts any string for `returns`. The constraint that it
+ *    must reference a real schema model is applied when the query is
+ *    passed to `defineQueries(schema, ...)`. This mirrors how
+ *    `relation.belongsTo('projects', 'projectId')` accepts a plain
+ *    string at the factory and defers the cross-reference check to
+ *    schema assembly time.
+ *
+ *  - Queries do NOT carry a `name` until they pass through
+ *    `defineQueries()`. The name is assigned from the record key —
+ *    same pattern as `defineSchema({ tasks: model(...) })` where the
+ *    model name is the record key, not a field on the model factory.
+ *
+ *  - All queries return an array of a single model type. Multi-model
+ *    fetches (e.g., files + folders) are expressed as multiple queries
+ *    in a single batch at dispatch time, not as "bundle" shapes in the
+ *    schema. This keeps each `QueryDef` pointed at exactly one model
+ *    and lets the generic loader hydrate via a single
+ *    `schema.models[queryDef.returns]` lookup.
+ */
+import { z } from 'zod';
+import type { Schema, InferModel, InferModelNames } from './schema.js';
+/**
+ * A single query definition: a zod input shape, the schema key of the
+ * model it returns, and (after assembly) the name it was registered
+ * under.
+ *
+ * `name` is filled in by `defineQueries()` from the record key. It is
+ * optional on the type so `query()` can return a value without one —
+ * downstream code should only read `name` after the query has been
+ * passed through `defineQueries()`.
+ */
+export interface QueryDef<TInput extends z.ZodType = z.ZodType, TReturns extends string = string> {
+    /** Zod schema for the query's input arguments. */
+    readonly input: TInput;
+    /**
+     * The schema key of the model this query returns. Narrowed by
+     * `defineQueries()` to `InferModelNames<S>` via the `Q` generic, so
+     * a query whose `returns` does not match a known model fails at
+     * compile time.
+     */
+    readonly returns: TReturns;
+    /**
+     * Name under which the query is registered. Populated by
+     * `defineQueries()` from the record key — do not set directly.
+     * Present so wire-dispatch code (`client.runNamed(queryDef.name,
+     * ...)`) and the Go registry lookup can read it straight off the
+     * def without needing the surrounding `Queries` object.
+     */
+    readonly name?: string;
+}
+/**
+ * The raw spec accepted by `query()`. Internal type — consumers never
+ * reference this directly, they call `query({ input, returns })`.
+ */
+interface QuerySpec<TInput extends z.ZodType, TReturns extends string> {
+    readonly input: TInput;
+    readonly returns: TReturns;
+}
+/**
+ * Define a query.
+ *
+ * `TReturns` is a `const` generic so TypeScript preserves the literal
+ * type of the `returns` value at call time (e.g., `'slideLayer'`
+ * instead of widening to `string`). This is what lets `defineQueries`
+ * type-check `returns` against the schema's model keys without
+ * requiring the consumer to write `as const` manually.
+ *
+ * ```ts
+ * const slideLayersByDeck = query({
+ *   input:   z.object({ deckId: z.string() }),
+ *   returns: 'slideLayer',
+ * });
+ * ```
+ */
+export declare function query<TInput extends z.ZodType, const TReturns extends string>(spec: QuerySpec<TInput, TReturns>): QueryDef<TInput, TReturns>;
+/**
+ * A record of query names → query definitions, parameterized by a
+ * schema so each query's `returns` must reference a known model.
+ *
+ * This is the constraint type used by `defineQueries()` — it's what
+ * turns "any string" into "a model in this schema" without touching
+ * the `query()` factory itself.
+ */
+export type QueryRecord<S extends Schema> = Record<string, QueryDef<z.ZodType, InferModelNames<S>>>;
+/**
+ * The object returned by `defineQueries()`. Holds a reference back to
+ * the schema (so the generic loader can resolve `queryDef.returns` to
+ * a `ModelDef` at runtime via `schema.models[def.returns]`) and the
+ * resolved record of queries, each with its `name` field filled in.
+ */
+export interface Queries<S extends Schema, Q extends QueryRecord<S>> {
+    readonly schema: S;
+    readonly queries: Q;
+}
+/**
+ * Infer the input type of a query from its zod schema.
+ *
+ * ```ts
+ * type Input = InferQueryInput<typeof queries.queries.slideLayersByDeck>;
+ * // { deckId: string }
+ * ```
+ */
+export type InferQueryInput<Q extends QueryDef> = z.infer<Q['input']>;
+/**
+ * Infer the result type of a query by looking up its `returns` model
+ * in the schema.
+ *
+ * Returns `Array<InferModel<S, returns>>` — all queries return a
+ * collection at this layer. Single-entity fetches use
+ * `ids: [singleId]` and the caller picks `result[0]`; this avoids a
+ * second `scope: 'single'` shape in the DSL for a case that can be
+ * expressed with the collection form.
+ *
+ * ```ts
+ * type Result = InferQueryResult<
+ *   typeof schema,
+ *   typeof queries.queries.slideLayersByDeck
+ * >;
+ * // Array<SlideLayer>
+ * ```
+ */
+export type InferQueryResult<S extends Schema, Q extends QueryDef> = Q extends QueryDef<z.ZodType, infer R> ? R extends InferModelNames<S> ? Array<InferModel<S, R>> : never : never;
+/**
+ * Define a typed query set against a schema.
+ *
+ * Each entry's `returns` field is constrained to the schema's model
+ * names at compile time via the `Q` generic bound to `QueryRecord<S>`.
+ * A query whose `returns` does not match a known model will fail at
+ * the `defineQueries` call site with a TypeScript error, not at
+ * runtime.
+ *
+ * The factory also performs a runtime validation of the same
+ * invariant. This catches the edge case where the schema and the
+ * queries live in separate modules that drift out of sync — for
+ * example, when a developer removes a model from the schema without
+ * updating the queries that referenced it. The runtime error points
+ * at the specific offending query and lists the available models,
+ * which is a nicer failure mode than a generic "property does not
+ * exist" error deep inside the loader.
+ *
+ * Each resolved query gets its `name` populated from the record key:
+ * `queries.slideLayersByDeck.name === 'slideLayersByDeck'`. Wire
+ * dispatch, the Go registry, and the loader orchestrator all read
+ * `queryDef.name` directly rather than re-deriving it.
+ *
+ * ```ts
+ * const schema = defineSchema({
+ *   slideLayer: model(
+ *     { slideId: z.string() },
+ *     {},
+ *     { load: 'lazy', typename: 'SlideLayer', persist: {} },
+ *   ),
+ * });
+ *
+ * const queries = defineQueries(schema, {
+ *   slideLayersByDeck: query({
+ *     input:   z.object({ deckId: z.string() }),
+ *     returns: 'slideLayer',   // ← type-checked
+ *   }),
+ * });
+ * ```
+ */
+export declare function defineQueries<S extends Schema, const Q extends QueryRecord<S>>(schema: S, queries: Q): Queries<S, Q>;
+export {};