@relyio/sdk 0.12.0 → 0.13.0

package/dist/{include-paths-CL4gHv6I.d.cts → include-paths-Bs5FhNw2.d.cts}

@@ -1,4 +1,4 @@
-import { w as RichTextValue, t as RichTextTable, c as RichTextCodeGroup, s as RichTextStructure, n as RichTextMarkType } from './rich-text.d-rKmpgdGd.cjs';
+import { b as RichTextValue, c as RichTextShapeValue, d as RichTextEntryLinkMark, y as RichTextTable, h as RichTextCodeGroup, x as RichTextStructure, s as RichTextMarkType } from './rich-text.d-BWc-5gX1.cjs';
 
 /**
  * Generated by scripts/emit-openapi-types.mjs from @relyio/api's committed
@@ -986,6 +986,21 @@ interface components {
                 retriable?: boolean;
             };
         };
+        /** @description An asset entry’s `urls`, sent beside its `file` once `file.status` is `ready`: an image’s `original` and `variants`, a file’s `original`, a video’s `playback`, `poster` and `download`. Every URL is on the delivery gateway; a protected or private asset’s carries a short-lived token minted for this request. */
+        AssetUrls: {
+            /** @description An image or a file: its original bytes. */
+            original?: string;
+            /** @description An image: each delivery variant’s id, mapped to its URL. */
+            variants?: {
+                [key: string]: string;
+            };
+            /** @description A video: its HLS/DASH manifest. */
+            playback?: string;
+            /** @description A video: its poster image. */
+            poster?: string;
+            /** @description A video: its downloadable MP4, when enabled. */
+            download?: string;
+        };
         /** @description One distinct value of the field, and the entry it was first found in. */
         AutocompleteSuggestion: {
             /** @description The suggested value. */
@@ -997,6 +1012,19 @@ interface components {
             /** @description The value with its matched part wrapped in `<em>`, when Atlas highlighted it. */
             highlight?: string;
         };
+        /** @description An entry link left pointing nowhere: who holds it, where, and the heading anchor it names. */
+        BrokenEntryLink: {
+            /** @description The linking entry’s id. */
+            entryUid: string;
+            /** @description The linking entry’s content type. */
+            contentType: string;
+            /** @description The rich-text field holding the link, spelt as the include path that names it: `body`, `sections.body`. */
+            field: string;
+            /** @description The heading anchor the link names, which this entry no longer has. */
+            anchor: string;
+            /** @description The locale the link is published in. */
+            locale: string;
+        };
         /** @description One change to one entry, ids only. Refetch the entry through the ordinary read path to see it. */
         Change: {
             entryId: string;
@@ -1012,7 +1040,7 @@ interface components {
             nextCursor: string | null;
             hasMore: boolean;
         };
-        /** @description One entry: its fields at the top level, as the content type declares them, and `_metadata`. An asset entry also carries `file`, an `AssetFile`, and `urls` once the file is ready. */
+        /** @description One entry: its fields at the top level, as the content type declares them, and `_metadata`. An asset entry also carries `file`, an `AssetFile`, and `urls`, an `AssetUrls`, once the file is ready. */
         Entry: {
             _metadata: components['schemas']['EntryMetadata'];
         } & {
@@ -1115,7 +1143,7 @@ interface components {
         ErrorResponse: {
             error: {
                 /** @enum {string} */
-                code: 'ACCESS_DENIED' | 'CONTENT_INVALID' | 'INTERNAL_ERROR' | 'INVALID_API_KEY' | 'METHOD_NOT_ALLOWED' | 'MISSING_API_KEY' | 'ORGANIZATION_BEING_DELETED' | 'ORGANIZATION_DELETE_BLOCKED' | 'ORGANIZATION_IN_ANOTHER_CELL' | 'PAYLOAD_TOO_LARGE' | 'PLAN_DOWNGRADE_BLOCKED' | 'PLAN_FEATURE_UNAVAILABLE' | 'PROJECT_IN_ANOTHER_CELL' | 'RATE_LIMIT_EXCEEDED' | 'READ_ONLY_KEY' | 'REQUEST_INVALID' | 'REQUEST_TIMEOUT' | 'RESOURCE_CONFLICT' | 'RESOURCE_EXPIRED' | 'RESOURCE_NOT_FOUND' | 'REVERIFICATION_REQUIRED' | 'SERVICE_INDETERMINATE' | 'TRANSACTION_ROLLED_BACK' | 'USAGE_QUOTA_EXCEEDED' | 'USER_NOT_PROVISIONED';
+                code: 'ACCESS_DENIED' | 'AI_UNAVAILABLE_IN_REGION' | 'CONTENT_INVALID' | 'INTERNAL_ERROR' | 'INVALID_API_KEY' | 'METHOD_NOT_ALLOWED' | 'MISSING_API_KEY' | 'ORGANIZATION_BEING_DELETED' | 'ORGANIZATION_DELETE_BLOCKED' | 'ORGANIZATION_IN_ANOTHER_CELL' | 'PAYLOAD_TOO_LARGE' | 'PLAN_DOWNGRADE_BLOCKED' | 'PLAN_FEATURE_UNAVAILABLE' | 'PROJECT_IN_ANOTHER_CELL' | 'RATE_LIMIT_EXCEEDED' | 'READ_ONLY_KEY' | 'REQUEST_INVALID' | 'REQUEST_TIMEOUT' | 'RESOURCE_CONFLICT' | 'RESOURCE_EXPIRED' | 'RESOURCE_NOT_FOUND' | 'REVERIFICATION_REQUIRED' | 'SERVICE_INDETERMINATE' | 'TRANSACTION_ROLLED_BACK' | 'USAGE_QUOTA_EXCEEDED' | 'USER_NOT_PROVISIONED';
                 messages: string[];
                 details?: {
                     [key: string]: unknown;
@@ -1315,7 +1343,7 @@ interface components {
                 };
             };
         };
-        /** @description The entry after a restore: its fields at the top level and `_metadata`, which also lists what the restore left out. */
+        /** @description The entry after a restore: its fields at the top level and `_metadata`, which also lists what the restore left out and the links other entries publish that it left pointing nowhere. */
         RestoredEntry: {
             _metadata: components['schemas']['RestoredEntryMetadata'];
         } & {
@@ -1394,8 +1422,190 @@ interface components {
             firstPublishedAt?: string;
             /** @description The entry’s outgoing references, across every locale, each once. */
             refs: components['schemas']['EntryRef'][];
-            /** @description Each value of the restored version the active schema no longer declares, by path (`legacy`, `seo.note`, `faq[_key=="k1"].note` — an item named by its key). A restore writes what the schema still declares and is never refused for the rest; empty when the version held nothing removed. A replay of the restore under the same `Idempotency-Key` answers the entry as it stands and leaves this out. */
+            /** @description Each value of the restored version the active schema no longer declares, by path (`legacy`, `seo.note`, `faq[_key=="k1"].note` — an item named by its key). A restore writes what the schema still declares and is never refused for the rest; empty when the version held nothing removed. A replay of the restore under the same `Idempotency-Key` answers the list the restore did. */
             leftOut?: string[];
+            /** @description Each entry link another entry publishes whose `anchor` names a heading this restore took away from the content its reader lands on, as a revision lists them. A restore of a published locale lands on its draft, so it takes none away and this is empty. A replay of the restore under the same `Idempotency-Key` answers the list the restore did. */
+            brokenLinks?: components['schemas']['BrokenEntryLink'][];
+        };
+        /** @description The entry after a revision: its fields at the top level and `_metadata`, which also lists the links other entries publish that the revision left pointing nowhere. */
+        RevisedEntry: {
+            _metadata: components['schemas']['RevisedEntryMetadata'];
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description What this service reports about an entry beside its fields, and the links a revision left pointing nowhere. */
+        RevisedEntryMetadata: {
+            id: string;
+            /** @description The content type. */
+            type: string;
+            /** @enum {string} */
+            entryType: 'asset' | 'content' | 'settings' | 'singleton';
+            /** @description The slug field’s value at `locale`, or null when the type declares none. */
+            slug: string | null;
+            /**
+             * @description Container lifecycle only. Publication is per locale: `localeStatus`.
+             * @enum {string}
+             */
+            status: 'active' | 'archived' | 'proposed';
+            /** @description The reported locale’s own version counter — not the entry’s shared-field counter. `0` when that locale has no content of its own. With `id` and `locale`, it is what `X-Entity-Tag` is minted from. */
+            version: number;
+            /** @description The locale the fields beside this object were composed for. */
+            locale: string;
+            /** @description How many versions `locale` has. Sent on a single-entry read; a list leaves it out. */
+            versionCount?: number;
+            /** @description `locale`’s version numbers, newest first, at most 25. Sent on a single-entry read; a list leaves it out. */
+            versions?: number[];
+            /**
+             * @description Publication state of `locale`. Absent when that locale has no content of its own: what is visible in it is inherited through the fallback chain.
+             * @enum {string}
+             */
+            localeStatus?: 'archived' | 'draft' | 'published';
+            /** @description Whether `locale` has unpublished changes of its own. */
+            localeHasDraft: boolean;
+            /** @description Every locale holding unpublished content of its own, sorted. A shared-field draft is not listed: it is `hasDraft`. */
+            draftLocales: string[];
+            /** @description Whether the shared (non-localized) fields have unpublished changes. Publishing any locale makes them live, so they are unpublished work in every locale. */
+            hasDraft: boolean;
+            /** @description The locale the request named, when it named one other than the default. On `?locales=a,b,c` it is always sent: the primary, or `*` when the list names as many locales as the entry has — as on `?locale=*`. */
+            requestedLocale?: string;
+            /** @description The schema’s default locale. */
+            defaultLocale: string;
+            /** @description Each field whose value came from another locale, mapped to that locale. Absent when none did. */
+            localeFallbacksApplied?: {
+                [key: string]: string;
+            };
+            /** @description Each required field the entry holds no value for, which this read filled with its kind’s empty value — `""` for text, the tree holding nothing (`{ _type: "richText", version: 1, children: [] }`) for rich text, `[]` for a list, `false` for a boolean — so a required field is always present. A draft may leave these empty; publishing refuses it. Each is a value path, a list item named by its key: `title`, `seo.title`, `faq[_key=="k1"].question` — the spelling a validation error’s path uses, so a path still finds its item after a reorder. Absent when none was filled. */
+            emptyRequiredFields?: string[];
+            /** @description Every locale the entry has content in, the default first. */
+            availableLocales: components['schemas']['EntryLocale'][];
+            /** @description The fields of every other locale asked for, keyed by locale — on `?locales=a,b` and `?locale=*`. A locale with no visible fields is left out. */
+            localizations?: {
+                [key: string]: {
+                    [key: string]: unknown;
+                };
+            };
+            /**
+             * Format: date-time
+             * @description When the entry was created.
+             */
+            createdAt: string;
+            /**
+             * Format: date-time
+             * @description When the entry was last written.
+             */
+            updatedAt: string;
+            /**
+             * Format: date-time
+             * @description When the entry was last published. Absent until it is.
+             */
+            publishedAt?: string;
+            /**
+             * Format: date-time
+             * @description When the entry was first published. Absent until it is.
+             */
+            firstPublishedAt?: string;
+            /** @description The entry’s outgoing references, across every locale, each once. */
+            refs: components['schemas']['EntryRef'][];
+            /** @description Each entry link another entry publishes whose `anchor` names a heading this revision took away from the content its reader lands on — in the link’s locale, or the first locale of its fallback chain this entry publishes. The revision is never refused for them; the linking entry’s own next publish is (`ENTRY_LINK_ANCHOR_NOT_FOUND`). Only what this revision took away is listed, and empty when it took none. A replay of the revision under the same `Idempotency-Key` answers the list the revision did. */
+            brokenLinks?: components['schemas']['BrokenEntryLink'][];
+        };
+        /** @description The settings group after a write or a reset: its fields at the top level and `_metadata`, which also lists the links other entries publish that the write left pointing nowhere. */
+        RevisedSettingsGroup: {
+            _metadata: components['schemas']['RevisedSettingsGroupMetadata'];
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description What this service reports about a settings group beside its fields, and the links a write left pointing nowhere. */
+        RevisedSettingsGroupMetadata: {
+            id: string;
+            /** @description The settings group. */
+            groupId: string;
+            /** @description The reported locale’s own version counter — not the entry’s shared-field counter. `0` when that locale has no content of its own. With `id` and `locale`, it is what `X-Entity-Tag` is minted from. */
+            version: number;
+            /** @description The locale the fields beside this object were composed for. */
+            locale: string;
+            /** @description How many versions `locale` has. */
+            versionCount: number;
+            /** @description `locale`’s version numbers, newest first, at most 25. */
+            versions: number[];
+            /**
+             * @description Publication state of `locale`. Absent when that locale has no content of its own: what is visible in it is inherited through the fallback chain.
+             * @enum {string}
+             */
+            localeStatus?: 'archived' | 'draft' | 'published';
+            /** @description Whether `locale` has unpublished changes of its own. */
+            localeHasDraft: boolean;
+            /** @description Every locale holding unpublished content of its own, sorted. A shared-field draft is not listed: it is `hasDraft`. */
+            draftLocales: string[];
+            /** @description Whether the shared (non-localized) fields have unpublished changes. Publishing any locale makes them live, so they are unpublished work in every locale. */
+            hasDraft: boolean;
+            /**
+             * Format: date-time
+             * @description When the group was last written.
+             */
+            updatedAt: string;
+            /** @description Each entry link another entry publishes whose `anchor` names a heading this write took away from the settings group’s content, as an entry revision lists them. The write is never refused for them; the linking entry’s own next publish is (`ENTRY_LINK_ANCHOR_NOT_FOUND`). Empty when it took none away. A replay of the write under the same `Idempotency-Key` answers the list the write did. */
+            brokenLinks?: components['schemas']['BrokenEntryLink'][];
+        };
+        /** @description The singleton after a write: its fields at the top level and `_metadata`, which also lists the links other entries publish that the write left pointing nowhere. */
+        RevisedSingleton: {
+            _metadata: components['schemas']['RevisedSingletonMetadata'];
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description What this service reports about a singleton beside its fields, and the links a write left pointing nowhere. */
+        RevisedSingletonMetadata: {
+            id: string;
+            /** @description The singleton type. */
+            type: string;
+            /**
+             * @description Container lifecycle only. Publication is per locale: `localeStatus`.
+             * @enum {string}
+             */
+            status: 'active' | 'archived' | 'proposed';
+            /** @description The reported locale’s own version counter — not the entry’s shared-field counter. `0` when that locale has no content of its own. With `id` and `locale`, it is what `X-Entity-Tag` is minted from. */
+            version: number;
+            /** @description The locale the fields beside this object were composed for. */
+            locale: string;
+            /** @description How many versions `locale` has. */
+            versionCount: number;
+            /** @description `locale`’s version numbers, newest first, at most 25. */
+            versions: number[];
+            /**
+             * @description Publication state of `locale`. Absent when that locale has no content of its own: what is visible in it is inherited through the fallback chain.
+             * @enum {string}
+             */
+            localeStatus?: 'archived' | 'draft' | 'published';
+            /** @description Whether `locale` has unpublished changes of its own. */
+            localeHasDraft: boolean;
+            /** @description Every locale holding unpublished content of its own, sorted. A shared-field draft is not listed: it is `hasDraft`. */
+            draftLocales: string[];
+            /** @description Whether the shared (non-localized) fields have unpublished changes. Publishing any locale makes them live, so they are unpublished work in every locale. */
+            hasDraft: boolean;
+            /**
+             * Format: date-time
+             * @description When the singleton was created.
+             */
+            createdAt: string;
+            /**
+             * Format: date-time
+             * @description When the singleton was last written.
+             */
+            updatedAt: string;
+            /**
+             * Format: date-time
+             * @description When the singleton was last published. Absent until it is.
+             */
+            publishedAt?: string;
+            /**
+             * Format: date-time
+             * @description When the singleton was first published. Absent until it is.
+             */
+            firstPublishedAt?: string;
+            /** @description Each required field the singleton holds no value for, which this read filled with its kind’s empty value, as a value path naming a list item by its key — as on an entry. Absent when none was. */
+            emptyRequiredFields?: string[];
+            /** @description Each entry link another entry publishes whose `anchor` names a heading this write took away from the singleton’s content, as an entry revision lists them. The write is never refused for them; the linking entry’s own next publish is (`ENTRY_LINK_ANCHOR_NOT_FOUND`). Empty when it took none away. A replay of the write under the same `Idempotency-Key` answers the list the write did. */
+            brokenLinks?: components['schemas']['BrokenEntryLink'][];
         };
         /** @description How a hit’s relevance was reached. Sent on a search that asked for `explain`. */
         ScoreBreakdown: {
@@ -1417,7 +1627,7 @@ interface components {
         } & {
             [key: string]: unknown;
         };
-        /** @description One hit: the entry’s fields at the top level — at `_metadata.locale`, or only the aliases a `fields` projection names — its `_metadata`, and the score annotations the request asked for. Not an entry read: see `SearchHitMetadata`. */
+        /** @description One hit: the entry’s fields at the top level — at `_metadata.locale`, or only the aliases a `fields` projection names — its `_metadata`, and the score annotations the request asked for. A hit of an asset type also carries `file`, an `AssetFile`, and `urls`, an `AssetUrls`, once the file is ready. Not an entry read: see `SearchHitMetadata`. */
         SearchHit: {
             _metadata: components['schemas']['SearchHitMetadata'];
             /** @description Relevance. Sent on a search that asked for `includeScore`, and on every similar hit. */
@@ -1615,7 +1825,7 @@ interface components {
             id?: string;
             error: {
                 /** @enum {string} */
-                code: 'ACCESS_DENIED' | 'CONTENT_INVALID' | 'INTERNAL_ERROR' | 'INVALID_API_KEY' | 'METHOD_NOT_ALLOWED' | 'MISSING_API_KEY' | 'ORGANIZATION_BEING_DELETED' | 'ORGANIZATION_DELETE_BLOCKED' | 'ORGANIZATION_IN_ANOTHER_CELL' | 'PAYLOAD_TOO_LARGE' | 'PLAN_DOWNGRADE_BLOCKED' | 'PLAN_FEATURE_UNAVAILABLE' | 'PROJECT_IN_ANOTHER_CELL' | 'RATE_LIMIT_EXCEEDED' | 'READ_ONLY_KEY' | 'REQUEST_INVALID' | 'REQUEST_TIMEOUT' | 'RESOURCE_CONFLICT' | 'RESOURCE_EXPIRED' | 'RESOURCE_NOT_FOUND' | 'REVERIFICATION_REQUIRED' | 'SERVICE_INDETERMINATE' | 'TRANSACTION_ROLLED_BACK' | 'USAGE_QUOTA_EXCEEDED' | 'USER_NOT_PROVISIONED';
+                code: 'ACCESS_DENIED' | 'AI_UNAVAILABLE_IN_REGION' | 'CONTENT_INVALID' | 'INTERNAL_ERROR' | 'INVALID_API_KEY' | 'METHOD_NOT_ALLOWED' | 'MISSING_API_KEY' | 'ORGANIZATION_BEING_DELETED' | 'ORGANIZATION_DELETE_BLOCKED' | 'ORGANIZATION_IN_ANOTHER_CELL' | 'PAYLOAD_TOO_LARGE' | 'PLAN_DOWNGRADE_BLOCKED' | 'PLAN_FEATURE_UNAVAILABLE' | 'PROJECT_IN_ANOTHER_CELL' | 'RATE_LIMIT_EXCEEDED' | 'READ_ONLY_KEY' | 'REQUEST_INVALID' | 'REQUEST_TIMEOUT' | 'RESOURCE_CONFLICT' | 'RESOURCE_EXPIRED' | 'RESOURCE_NOT_FOUND' | 'REVERIFICATION_REQUIRED' | 'SERVICE_INDETERMINATE' | 'TRANSACTION_ROLLED_BACK' | 'USAGE_QUOTA_EXCEEDED' | 'USER_NOT_PROVISIONED';
                 messages: string[];
                 details?: {
                     [key: string]: unknown;
@@ -2199,6 +2409,15 @@ interface operations {
                     'application/json': components['schemas']['RefusalInternalError'];
                 };
             };
+            /** @description SERVICE_INDETERMINATE */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalServiceIndeterminate'];
+                };
+            };
         };
     };
     ingestUsage: {
@@ -2781,8 +3000,7 @@ interface operations {
                 };
                 content: {
                     'application/json': {
-                        /** @description The payload itself. */
-                        data: unknown;
+                        data: components['schemas']['RevisedEntry'];
                     };
                 };
             };
@@ -4727,6 +4945,21 @@ interface operations {
                     };
                 };
             };
+            /** @description RESOURCE_NOT_FOUND */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalResourceNotFound'];
+                    'text/event-stream': {
+                        /** @enum {string} */
+                        type: 'change' | 'complete' | 'error' | 'heartbeat';
+                    } & {
+                        [key: string]: unknown;
+                    };
+                };
+            };
             /** @description RESOURCE_EXPIRED */
             410: {
                 headers: {
@@ -4854,6 +5087,15 @@ interface operations {
                     'application/json': components['schemas']['RefusalAccessDeniedOrPlanFeatureUnavailableOrUsageQuotaExceeded'];
                 };
             };
+            /** @description RESOURCE_NOT_FOUND */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalResourceNotFound'];
+                };
+            };
             /** @description PROJECT_IN_ANOTHER_CELL */
             421: {
                 headers: {
@@ -5039,6 +5281,15 @@ interface operations {
                     'application/json': components['schemas']['RefusalAccessDeniedOrPlanFeatureUnavailableOrUsageQuotaExceeded'];
                 };
             };
+            /** @description RESOURCE_NOT_FOUND */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalResourceNotFound'];
+                };
+            };
             /** @description PROJECT_IN_ANOTHER_CELL */
             421: {
                 headers: {
@@ -5735,6 +5986,15 @@ interface operations {
                     'application/json': components['schemas']['RefusalAccessDeniedOrPlanFeatureUnavailableOrUsageQuotaExceeded'];
                 };
             };
+            /** @description RESOURCE_NOT_FOUND */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalResourceNotFound'];
+                };
+            };
             /** @description PROJECT_IN_ANOTHER_CELL */
             421: {
                 headers: {
@@ -5930,6 +6190,15 @@ interface operations {
                     'application/json': components['schemas']['RefusalAccessDeniedOrPlanFeatureUnavailableOrUsageQuotaExceeded'];
                 };
             };
+            /** @description RESOURCE_NOT_FOUND */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalResourceNotFound'];
+                };
+            };
             /** @description PROJECT_IN_ANOTHER_CELL */
             421: {
                 headers: {
@@ -6093,8 +6362,7 @@ interface operations {
                 };
                 content: {
                     'application/json': {
-                        /** @description The payload itself. */
-                        data: unknown;
+                        data: components['schemas']['RevisedSettingsGroup'];
                     };
                 };
             };
@@ -6308,8 +6576,7 @@ interface operations {
                 };
                 content: {
                     'application/json': {
-                        /** @description The payload itself. */
-                        data: unknown;
+                        data: components['schemas']['RevisedSettingsGroup'];
                     };
                 };
             };
@@ -6725,8 +6992,7 @@ interface operations {
                 };
                 content: {
                     'application/json': {
-                        /** @description The payload itself. */
-                        data: unknown;
+                        data: components['schemas']['RevisedSingleton'];
                     };
                 };
             };
@@ -7117,31 +7383,483 @@ interface operations {
 }
 
 /**
- * Workflow definition for content approval pipelines
+ * Where the SDK's transport gets its truth.
  *
- * Workflows define approval stages that content must pass through before
- * publication. They can be configured globally and per content type.
+ * Every route this client calls is named by its **path template as the
+ * committed document spells it**, and the body type it expects is read out of
+ * that document rather than written down here. `api-schema.ts` beside this file
+ * is generated by `pnpm api:types` from `apps/services/api/openapi-spec.json`,
+ * which is itself generated from that service's `RouteContract`s
+ * (`INV-API-DOCUMENT-IS-DERIVED`). So the chain is: one declaration in
+ * `routes.ts` → the serializer that produces the body → the document → these
+ * types → the method that reads it.
  *
- * @example
- * // Simple workflow with one approval stage
- * const workflow = defineWorkflow({
- *   enabled: true,
- *   stages: [
- *     defineWorkflowStage('review', {
- *       displayName: 'Editorial Review',
- *       allowedRoles: ['editor', 'admin']
- *     })
- *   ]
- * })
+ * That chain is the answer to the question this phase exists to close. Before
+ * it, six SDK methods read a key the server does not send; each had no caller
+ * and no test, so nothing could see them. Now:
  *
- * @example
- * // Multi-stage workflow
- * const workflow = defineWorkflow({
- *   enabled: true,
- *   stages: [
- *     defineWorkflowStage('editorial-review', {
- *       displayName: 'Editorial Review',
- *       allowedRoles: ['editor']
+ * - A route that changes **kind** — `collection` to `object`, say — changes
+ *   whether the document's 200 body carries `page` and whether `data` is an
+ *   array. `Wire<…>` follows, `readPayload` follows, and the method's declared
+ *   return type stops matching. `tsc` names the method.
+ * - A route that changes **path** or is deleted stops being a `keyof paths`, so
+ *   the call site fails on the literal.
+ * - A route that changes **dialect** changes `page` from `CursorPage` to
+ *   `OffsetPage`, and anything reading `nextCursor` fails.
+ *
+ * `/v1` lives in these templates because it lives in the document
+ * (`INV-API-VERSION-IS-DECIDED-ONCE`). Before this phase the SDK's base URL was
+ * `https://api.relyio.com` and its paths were `/{contentType}`, so every
+ * versioned request went to a path the router does not serve.
+ *
+ * Spec: `devtools/docs/guide/engineering/api-contract-spec.md`,
+ * `INV-API-CLIENT-IS-DERIVED`.
+ */
+
+/** Every path the committed document declares. */
+type ApiPath = keyof paths;
+type Verb = 'get' | 'post' | 'put' | 'patch' | 'delete';
+/** The verbs the document declares on this path — not the seven HTTP has. */
+type ApiMethod<P extends ApiPath> = {
+    [M in Verb]: M extends keyof paths[P] ? paths[P][M] extends {
+        responses: unknown;
+    } ? M : never : never;
+}[Verb];
+type Operation<P extends ApiPath, M extends ApiMethod<P>> = M extends keyof paths[P] ? paths[P][M] : never;
+type JsonBody<R> = R extends {
+    content: {
+        'application/json': infer B;
+    };
+} ? B : never;
+/**
+ * The success body the document declares, preferring 200 where a route serves
+ * both. A route with neither — `kind: 'empty'`, which serves 204 — resolves to
+ * `never`, and `readPayload` cannot be called on it.
+ */
+type ApiSuccessBody<P extends ApiPath, M extends ApiMethod<P>> = Operation<P, M> extends {
+    responses: infer R;
+} ? 200 extends keyof R ? JsonBody<R[200]> : 201 extends keyof R ? JsonBody<R[201]> : never : never;
+/**
+ * The document's success body with the payload typed as the caller's `T`.
+ *
+ * The array arm is tested **first** on purpose: `{ data: unknown[] }` also
+ * satisfies `{ data: unknown }`, so the object arm would swallow every
+ * collection and hand a list route's caller a single entity — which is the
+ * exact defect class (`ContentClient.children` reading `.data.items` from an
+ * object route) that this phase makes unrepresentable.
+ */
+type Wire<P extends ApiPath, M extends ApiMethod<P>, T> = ApiSuccessBody<P, M> extends {
+    data: unknown[];
+} ? Omit<ApiSuccessBody<P, M>, 'data'> & {
+    data: T[];
+} : ApiSuccessBody<P, M> extends {
+    data: unknown;
+} ? Omit<ApiSuccessBody<P, M>, 'data'> & {
+    data: T;
+} : ApiSuccessBody<P, M>;
+/**
+ * The path parameters the document declares for this operation, or `never`
+ * where it declares none.
+ *
+ * `never` rather than `{}`: a route with no segments must **forbid** a `path`
+ * argument, not merely tolerate an empty one, and `keyof Record<string, never>`
+ * is `string`, so an empty-object encoding cannot be told apart from a real
+ * one at the type level.
+ */
+type PathParamsOf<P extends ApiPath, M extends ApiMethod<P>> = Operation<P, M> extends {
+    parameters: {
+        path?: infer X;
+    };
+} ? [X] extends [undefined] ? never : NonNullable<X> : never;
+/** What {@link matchRoute} recovers from a URL the client emitted. */
+interface RouteMatch {
+    /** The document's path template — the value a tag translator switches on. */
+    path: ApiPath;
+    /** The template's `{name}` segments, decoded: the inverse of {@link fillPath}. */
+    params: Record<string, string>;
+    /** The query string; a key that appears more than once comes back as an array. */
+    query: Record<string, string | string[]>;
+}
+interface MatchRouteOptions {
+    /**
+     * The client's `baseUrl`, when it carries a path prefix of its own
+     * (`https://example.com/relyio`). Its path is removed before the template is
+     * matched. Unneeded for the default `https://api.relyio.com`.
+     */
+    baseUrl?: string;
+}
+/**
+ * Recover the route a URL names: the inverse of {@link fillPath}, over the same
+ * committed document (`INV-API-CLIENT-IS-DERIVED`).
+ *
+ * `matchRoute(url).path` is an `ApiPath`, so anything that keys behaviour on a
+ * request — a cache-tag translator, say — switches on the document's templates
+ * and never on a route table of its own.
+ *
+ * Returns `null` for a URL no declared template matches — a presigned storage
+ * URL, or a path outside `baseUrl` — rather than a guess.
+ */
+declare function matchRoute(url: string | URL, options?: MatchRouteOptions): RouteMatch | null;
+
+/**
+ * Configuration types for the RelyIO SDK
+ */
+
+interface RelyIOConfig {
+    /**
+     * API key for authentication, sent as `X-API-Key`.
+     *
+     * Required by every request, not by construction: a client built without one — a module-scope
+     * client whose `process.env` variable is unset during a build — constructs, and each request it
+     * makes rejects with `MissingApiKeyError` before anything is sent. Under `relyio dev` the
+     * sandbox's key is used instead, so none need be configured.
+     */
+    apiKey: string;
+    /** Base URL for the RelyIO API */
+    baseUrl?: string;
+    /** Dataset to use */
+    dataset?: string;
+    /**
+     * Default locale for all content queries
+     * Can be overridden per-query using .locale() or .withLocale()
+     *
+     * @example
+     * const client = createClient({
+     *   apiKey: '...',
+     *   locale: 'en-US', // All queries default to English
+     * })
+     */
+    locale?: string;
+    /**
+     * How long one request may take, in milliseconds, before it ends as a `TimeoutError` (defaults
+     * to 30000). A number from 1 to 2147483647, the longest a timer waits; `0`, `NaN`, `Infinity` or
+     * anything larger is refused, and no value turns the timeout off.
+     */
+    timeout?: number;
+    /**
+     * The most attempts one request makes, the first included (defaults to 3). `1` turns retrying
+     * off; a value that is not a whole number of at least 1 is refused. Only a failure a later attempt
+     * can change is retried, and only where sending the request twice cannot apply it twice.
+     */
+    retryAttempts?: number;
+    /** Whether to use HTTPS (defaults to true) */
+    useSsl?: boolean;
+    /** Environment mode */
+    environment?: 'development' | 'staging' | 'production';
+    /**
+     * Cache configuration.
+     *
+     * Declarative only: the client keeps no response cache, and nothing in it reads
+     * these values, so every call goes to `fetch`. There is no SDK-side cache to
+     * turn off under a framework that caches `fetch` itself (Next.js).
+     */
+    cache?: CacheConfig;
+    /** Real-time configuration */
+    realtime?: RealtimeConfig;
+    /** Debug configuration */
+    debug?: DebugConfig;
+    /** Custom headers to include with requests */
+    headers?: Record<string, string>;
+    /**
+     * The function every request to the RelyIO API is sent through. Omit it and the
+     * client calls the runtime's `globalThis.fetch`, looked up per request. File
+     * bytes an asset upload PUTs straight to a presigned storage URL do not pass
+     * through it.
+     *
+     * The client still builds every request — URL, method, headers, body, signal —
+     * and hands this function that `RequestInit` unchanged, retries included, so an
+     * `Idempotency-Key` minted for a write is the same on every attempt. Supply one
+     * to add what your framework reads off the `RequestInit`, for example Next.js
+     * cache tags:
+     *
+     * @example
+     * const client = createClient({
+     *   apiKey: '...',
+     *   fetch: (input, init) => fetch(input, { ...init, next: { tags: ['posts'] } }),
+     * })
+     */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * RelyIO's live edge, which `liveChanges()` — and `<RelyIOProvider live>` from `@relyio/react`
+     * with a publishable key — follows a dataset's published changes at. An `https:` or `wss:` URL
+     * (`http:` or `ws:` for a local one); the socket and the poll each use the scheme they need.
+     *
+     * Omitted, it is derived from `baseUrl` for RelyIO's own API only: `https://api.relyio.com`
+     * (the default) follows `https://live.relyio.com`. For any other `baseUrl` there is no address to
+     * derive, so set this, or `liveChanges()` ends at once with a `LiveEdgeError` naming it and sends
+     * nothing.
+     *
+     * @example
+     * const relyio = createClient({
+     *   apiKey: 'rly_pub_…',
+     *   baseUrl: 'http://localhost:3000',
+     *   liveUrl: 'http://localhost:8787',
+     * })
+     */
+    liveUrl?: string;
+    /**
+     * The `WebSocket` class `liveChanges()` opens its socket with. Omit it and the client uses the
+     * runtime's global `WebSocket` — every browser, and Node 22 or later — looked up per connection.
+     * Where there is none, as in Node 18 and 20, it polls the edge instead, about every fifteen
+     * seconds.
+     *
+     * Supply one to use a library's socket where the runtime has none, or to add what your runtime
+     * lets a socket carry.
+     */
+    webSocket?: LiveWebSocketConstructor;
+    /** Browser-specific configuration */
+    browser?: BrowserConfig;
+    /**
+     * `relyio dev` sandbox detection.
+     *
+     * When developing under `relyio dev`, the CLI injects an ephemeral sandbox's dataset + scoped
+     * preview API key (via env vars or a local `.relyio/dev.json`). The SDK then transparently
+     * targets that sandbox instead of production — no code changes required.
+     *
+     * - Omit (default): detection runs automatically unless `NODE_ENV === 'production'`, so
+     *   `relyio dev -- pnpm dev` "just works" while production builds stay untouched.
+     * - `false`: disable detection entirely (force production targeting even in a dev shell).
+     * - `true`: force detection even when `NODE_ENV === 'production'`.
+     */
+    dev?: boolean;
+}
+/**
+ * The part of a `WebSocket` the live edge transport uses. A browser's `WebSocket` and Node's (22 and
+ * later) are assignable as they are; `src/__tests__/changes.types.ts` holds the platform's to it.
+ * Each event reaches its listener as `unknown` and is read field by field.
+ */
+interface LiveWebSocket {
+    /** `0` connecting, `1` open, `2` closing, `3` closed. */
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: 'open' | 'message' | 'close' | 'error', listener: (event: unknown) => void): void;
+}
+type LiveWebSocketConstructor = new (url: string) => LiveWebSocket;
+/**
+ * What `updateConfig()` takes: any option of {@link RelyIOConfig}, each laid over the value the
+ * client holds rather than over its default.
+ *
+ * An option left out or given as `undefined` keeps the value the client holds, and a bag of options
+ * you name keeps every field you do not name. `null` removes — "`undefined` keeps, `null` removes" —
+ * and the types accept it only where a value can go: an option with no default (`locale`,
+ * `dataset`, `fetch`, `browser.onCorsError`, `debug.logger`, …), which is then absent, and a header,
+ * which is then no longer sent. An option with a default takes no `null`: removed, it would leave
+ * nothing but that default. `createClient()` has nothing to remove, so its options take no `null`.
+ *
+ * Which options have no default is read off {@link UndefaultedOption} and {@link UndefaultedField} —
+ * the names {@link ConfigDefaults} leaves optional — so an option that gains or loses a default
+ * changes what `null` can clear with no edit here.
+ */
+type RelyIOConfigUpdate = Update<Omit<RelyIOConfig, OptionBag | 'headers'>, UndefaultedOption> & {
+    browser?: Update<BrowserConfig, UndefaultedField['browser']>;
+    cache?: Update<CacheConfig, UndefaultedField['cache']>;
+    realtime?: Update<RealtimeConfig, UndefaultedField['realtime']>;
+    debug?: Update<DebugConfig, UndefaultedField['debug']>;
+    /** Headers to add or replace, each kept until named again; `null` stops sending that header. */
+    headers?: Record<string, string | null>;
+};
+/** `T`'s options, each one optional, with `null` accepted for the ones named in `Clearable`. */
+type Update<T, Clearable extends keyof T> = {
+    [K in keyof T]?: K extends Clearable ? T[K] | null : T[K];
+};
+interface CacheConfig {
+    /** Whether caching is enabled (defaults to true) */
+    enabled?: boolean;
+    /** Cache TTL in milliseconds (defaults to 5 minutes) */
+    ttl?: number;
+    /** Maximum number of cache entries (defaults to 1000) */
+    maxEntries?: number;
+    /** Maximum cache size in bytes (defaults to 50MB) */
+    maxSize?: number;
+    /** Cache strategies to use */
+    strategies?: CacheStrategy[];
+}
+interface RealtimeConfig {
+    /** Whether real-time features are enabled (defaults to true) */
+    enabled?: boolean;
+    /** WebSocket URL for real-time connections */
+    wsUrl?: string;
+    /** Maximum number of reconnection attempts (defaults to 10) */
+    maxReconnectAttempts?: number;
+    /** Reconnection delay in milliseconds (defaults to 1000) */
+    reconnectDelay?: number;
+    /** Heartbeat interval in milliseconds (defaults to 30000) */
+    heartbeatInterval?: number;
+}
+interface DebugConfig {
+    /** Whether debug mode is enabled (defaults to false) */
+    enabled?: boolean;
+    /** Whether to log network requests (defaults to false) */
+    logRequests?: boolean;
+    /** Whether to log cache operations (defaults to false) */
+    logCache?: boolean;
+    /** Whether to log WebSocket events (defaults to false) */
+    logWebSocket?: boolean;
+    /** Custom logger function */
+    logger?: (_level: LogLevel, _message: string, _data?: unknown) => void;
+}
+/**
+ * The numbers the retry backoff is computed from.
+ *
+ * There is no `retryCondition` here any more. It was a predicate over
+ * `(error, attempt)`, which is structurally unable to see the request — so the
+ * only rule it could express is "is this error retryable", and the rule that
+ * matters is "may this request be sent twice". That question, and the answer,
+ * live in `RetryPolicy` (`http/retry-policy.ts`).
+ */
+interface RetryConfig {
+    /** Maximum number of attempts, including the first. */
+    maxAttempts: number;
+    /** Base delay between retries in milliseconds */
+    baseDelay: number;
+    /** Maximum delay between retries in milliseconds */
+    maxDelay: number;
+    /** Backoff factor for exponential backoff */
+    backoffFactor: number;
+    /** Whether to add jitter to retry delays */
+    jitter: boolean;
+}
+interface RequestConfig {
+    /** HTTP method */
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    /** Request URL */
+    url: string;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Request body */
+    body?: unknown;
+    /** Query parameters */
+    params?: Record<string, unknown>;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Whether to retry this request on failure */
+    retryable?: boolean;
+    /** Abort signal for canceling requests */
+    signal?: AbortSignal;
+    /** Additional metadata for the request */
+    metadata?: Record<string, unknown>;
+}
+interface ApiResponse<T = unknown> {
+    /**
+     * The response body exactly as the route's contract declares it —
+     * `{ data }`, `{ data, page }`, `{ data, page, meta }` or `{ empty }`.
+     *
+     * Named `body`, not `data`, because the envelope's own key is `data`: the
+     * incumbent `response.data.data` read like a typo and was one 33 times, in
+     * six methods that read a key the server never sent. One `data` in the
+     * spelling means `readPayload(response.body)` is the only way to reach a
+     * payload (`INV-API-CLIENT-IS-DERIVED`).
+     */
+    body: T;
+    /** HTTP status code */
+    status: number;
+    /** HTTP status text */
+    statusText: string;
+    /** Response headers */
+    headers: Record<string, string>;
+    /** Request configuration that generated this response */
+    config: RequestConfig;
+    /** Whether this response came from cache */
+    fromCache?: boolean;
+    /** Cache metadata */
+    cacheMetadata?: {
+        key: string;
+        timestamp: number;
+        ttl: number;
+    };
+}
+interface BrowserConfig {
+    /**
+     * Whether requests the client sends from a web page carry the browser's cookies to another
+     * origin (defaults to `false`).
+     *
+     * `false` — and leaving it out, or writing `undefined` — sends every request with
+     * `credentials: 'same-origin'`: nothing to another origin, and a same-origin request — the API
+     * behind a proxy on your own host — sent as the platform's own `fetch` would send it. `true`
+     * sends it with `credentials: 'include'`, which a browser completes only when the answer names
+     * your page's origin in `Access-Control-Allow-Origin` (not `*`) and carries
+     * `Access-Control-Allow-Credentials: true`. The RelyIO API authenticates with your API key and
+     * reads no cookie, so set `true` only for a server of your own in front of it that does.
+     *
+     * Applied only in a web page. On a server, in an edge runtime or in a Web Worker the client sets
+     * no `credentials` mode at all, whatever this says.
+     */
+    includeCredentials?: boolean;
+    /** Whether to use relative URLs for same-origin requests (defaults to false) */
+    useRelativeUrls?: boolean;
+    /** Custom CORS error handling */
+    onCorsError?: (_error: Error, _context: unknown) => void;
+}
+type CacheStrategy = 'memory' | 'persistent' | 'network-first' | 'cache-first' | 'stale-while-revalidate';
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+type Environment = 'development' | 'staging' | 'production';
+/**
+ * `T` once its defaults are applied: every field present, except the ones named in `NoDefault`,
+ * which stay as optional as `T` declares them because nothing stands in for them.
+ */
+type WithDefaults<T, NoDefault extends keyof T = never> = Required<Omit<T, NoDefault>> & Pick<T, NoDefault>;
+/**
+ * The options with no default, absent from a merged configuration until the caller gives one.
+ * `fetch` and `webSocket` among them: absent means the runtime's own, and that is read per request
+ * or per connection rather than captured here. `liveUrl` too: absent is derived from `baseUrl` when
+ * the live transport opens, where RelyIO's own API names its edge, and is otherwise no address.
+ */
+type UndefaultedOption = 'apiKey' | 'dataset' | 'locale' | 'dev' | 'fetch' | 'liveUrl' | 'webSocket';
+/** The options that are themselves bags of options, each merged field by field. */
+type OptionBag = 'browser' | 'cache' | 'realtime' | 'debug';
+/**
+ * The fields of each bag with no default, absent from a merged configuration until the caller gives
+ * one — and the fields of a bag `updateConfig()` can clear with `null`.
+ */
+interface UndefaultedField {
+    browser: 'onCorsError';
+    cache: never;
+    realtime: 'wsUrl';
+    debug: 'logger';
+}
+/**
+ * The value each option takes when the caller gives none, down to each field of each bag — so a
+ * field of a merged configuration that has a default is never `undefined`, and a reader does not
+ * restate the default. A field with no default (`onCorsError`, `wsUrl`, `logger`) is named in
+ * {@link UndefaultedField}; a field added to a bag without one fails to compile at
+ * {@link DEFAULT_CONFIG} until it gets a default or a name there.
+ */
+type ConfigDefaults = WithDefaults<Omit<RelyIOConfig, UndefaultedOption | OptionBag>> & {
+    browser: WithDefaults<BrowserConfig, UndefaultedField['browser']>;
+    cache: WithDefaults<CacheConfig, UndefaultedField['cache']>;
+    realtime: WithDefaults<RealtimeConfig, UndefaultedField['realtime']>;
+    debug: WithDefaults<DebugConfig, UndefaultedField['debug']>;
+};
+/** The configuration a client runs on: each option the caller gave, and its default where not. */
+type MergedRelyIOConfig = ConfigDefaults & Pick<RelyIOConfig, UndefaultedOption>;
+
+/**
+ * Workflow definition for content approval pipelines
+ *
+ * Workflows define approval stages that content must pass through before
+ * publication. They can be configured globally and per content type.
+ *
+ * @example
+ * // Simple workflow with one approval stage
+ * const workflow = defineWorkflow({
+ *   enabled: true,
+ *   stages: [
+ *     defineWorkflowStage('review', {
+ *       displayName: 'Editorial Review',
+ *       allowedRoles: ['editor', 'admin']
+ *     })
+ *   ]
+ * })
+ *
+ * @example
+ * // Multi-stage workflow
+ * const workflow = defineWorkflow({
+ *   enabled: true,
+ *   stages: [
+ *     defineWorkflowStage('editorial-review', {
+ *       displayName: 'Editorial Review',
+ *       allowedRoles: ['editor']
  *     }),
  *     defineWorkflowStage('legal-approval', {
  *       displayName: 'Legal Approval',
@@ -7393,7 +8111,7 @@ declare function isFinalWorkflowStage(workflow: WorkflowDefinition, stageId: str
  * Every field kind, in the order the schema language has always listed them. The one definition of
  * the union in `@relyio/schema`: `FIELD_TYPES` in `types/base/constants.ts` is this tuple.
  */
-declare const FIELD_KINDS: readonly ['shortText', 'longText', 'richText', 'table', 'code', 'email', 'url', 'slug', 'integer', 'decimal', 'boolean', 'enum', 'date', 'dateTime', 'reference', 'tags', 'list', 'object'];
+declare const FIELD_KINDS: readonly ['shortText', 'longText', 'richText', 'table', 'code', 'email', 'url', 'slug', 'integer', 'decimal', 'boolean', 'enum', 'date', 'dateTime', 'reference', 'tags', 'list', 'object', 'json'];
 /** A field kind: what a field's `type` names. The declaration is keyed by it and by nothing else. */
 type FieldKind = (typeof FIELD_KINDS)[number];
 /**
@@ -7405,6 +8123,167 @@ type OverEveryFieldKind<T extends {
     readonly [K in FieldKind]: unknown;
 }> = T;
 
+/**
+ * A `json` field's value and its JSON Schema (REL-1811, design decision 18): data nobody models in
+ * RelyIO still has a place.
+ *
+ * - **The value** is any JSON value — an object, an array, a string, a finite number, a boolean or
+ *   `null` — stored and served parsed. {@link jsonValueProblems} names what keeps a value from being
+ *   one, and the validation document's `x-json` keyword refuses it (`JSON_INVALID`) under every
+ *   write profile, a draft's included: a value that is not JSON, or that its field's JSON Schema
+ *   refuses, is never stored.
+ * - **The source** a person edits is collaborative text in the live document (ADR 0014), parsed on
+ *   save by {@link parseJsonSource}. While it does not parse, or the field's schema refuses what it
+ *   parses to, the live save leaves the field out — its stored value stands — and names it, so every
+ *   open editor shows it not saving until it does (`@relyio/entry-projection`'s `extractYDocData`,
+ *   `leftOut`).
+ * - **The JSON Schema** is the field's optional `config.schema`, written in the vocabulary
+ *   {@link JSON_SCHEMA_KEYWORDS} names: a subset of draft-07 that the validation document enforces,
+ *   the SDK infers a read's type from and both code generators emit a type from. Deploy refuses any
+ *   other keyword by name (`types/fields/data/json.ts`), so the three never disagree about a schema.
+ *
+ * Dependency-free like the rest of `./field-kinds` (`__tests__/dependency-free.test.ts`).
+ */
+/** A JSON value: what a `json` field holds. */
+type JsonValue = string | number | boolean | null | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+/** The types a JSON Schema's `type` may name (draft-07's simple types). */
+declare const JSON_SCHEMA_TYPES: readonly ['string', 'number', 'integer', 'boolean', 'object', 'array', 'null'];
+type JsonSchemaType = (typeof JSON_SCHEMA_TYPES)[number];
+/**
+ * The `format`s a json field's schema may name: those the validation document's AJV instance knows
+ * (`ajv-formats`). A format it did not know would be ignored, and a constraint nothing enforces is
+ * not one to accept.
+ */
+declare const JSON_SCHEMA_FORMATS: readonly ['date', 'time', 'date-time', 'email', 'hostname', 'ipv4', 'ipv6', 'uri', 'uuid'];
+type JsonSchemaFormat = (typeof JSON_SCHEMA_FORMATS)[number];
+/** A json field's JSON Schema: one node of the vocabulary {@link JSON_SCHEMA_KEYWORDS} names. */
+interface JsonFieldSchema {
+    readonly type?: JsonSchemaType | readonly JsonSchemaType[];
+    readonly properties?: {
+        readonly [key: string]: JsonFieldSchema;
+    };
+    readonly required?: readonly string[];
+    readonly additionalProperties?: boolean | JsonFieldSchema;
+    readonly items?: JsonFieldSchema;
+    readonly enum?: readonly JsonValue[];
+    readonly const?: JsonValue;
+    readonly anyOf?: readonly JsonFieldSchema[];
+    readonly oneOf?: readonly JsonFieldSchema[];
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string;
+    readonly format?: JsonSchemaFormat;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly exclusiveMinimum?: number;
+    readonly exclusiveMaximum?: number;
+    readonly multipleOf?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly uniqueItems?: boolean;
+    readonly minProperties?: number;
+    readonly maxProperties?: number;
+    readonly title?: string;
+    readonly description?: string;
+    readonly default?: JsonValue;
+    readonly examples?: readonly JsonValue[];
+}
+
+/**
+ * What a read returns for a `json` field (REL-1811): the value its JSON Schema describes, inferred
+ * from the schema literal at the type level, and any JSON value when it gives none — `JsonValue`,
+ * never `any`.
+ *
+ * **The subset that types a value** is the schema's structure, as `@relyio/schema`'s
+ * `JSON_SCHEMA_KEYWORDS` names it — the vocabulary deploy accepts, so a schema that deploys is one
+ * this reads:
+ *
+ * - `const` — that value; `enum` — the union of its members.
+ * - `anyOf` / `oneOf` — the union of each branch.
+ * - `type` — `string`, `number` and `integer` (a `number`), `boolean`, `null`, an `array` of its
+ *   `items` (any JSON value without them), an `object`; a list of types, their union.
+ * - An object's `properties`, each a property of its own type — present when `required` names it,
+ *   optional otherwise — and its other keys by `additionalProperties`: none when it is `false`,
+ *   each of its schema's type when it is a schema and the object declares no `properties` (a map),
+ *   and `unknown` otherwise.
+ *
+ * The constraint keywords (`minLength`, `pattern`, `minimum`, `maxItems` …) narrow the values of a
+ * type without changing it, and the annotations say nothing about it. **Anything the subset cannot
+ * say is `JsonValue`**: a schema with none of these keywords, and one whose literal was widened —
+ * `type: string` rather than `'object'` — since a literal the compiler did not keep names nothing.
+ * Write the schema `as const` to keep every literal: without it `required` widens to `string[]` and
+ * every property reads as optional, and an `enum` or a `const` as the type of its members — wider
+ * than the value, never narrower. `relyio generate-types` writes it `as const`.
+ */
+
+/** A json field's JSON Schema: the vocabulary deploy accepts (`@relyio/schema`'s `JsonFieldSchema`). */
+type JsonSchema = JsonFieldSchema;
+/** `true` for `any`, which every conditional would otherwise answer both ways. */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/** One object type from an intersection, so a read's type prints as one object. */
+type Flatten$1<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * The value a JSON Schema literal `S` describes — see the module note for the subset. Distributes
+ * over a union of schemas, which is what an `anyOf`'s branches are.
+ */
+type InferJsonSchema<S> = IsAny<S> extends true ? JsonValue : S extends {
+    readonly const: infer C;
+} ? C : S extends {
+    readonly enum: ReadonlyArray<infer E>;
+} ? E : S extends {
+    readonly anyOf: ReadonlyArray<infer A>;
+} ? InferJsonSchema<A> : S extends {
+    readonly oneOf: ReadonlyArray<infer O>;
+} ? InferJsonSchema<O> : S extends {
+    readonly type: infer T;
+} ? T extends ReadonlyArray<infer Each> ? OfType<S, Each> : OfType<S, T> : JsonValue;
+/** The value of type `T` (one of a schema's `type`s) that `S` describes. Distributes over `T`. */
+type OfType<S, T> = T extends 'string' ? string : T extends 'number' | 'integer' ? number : T extends 'boolean' ? boolean : T extends 'null' ? null : T extends 'array' ? ArrayOf<S> : T extends 'object' ? ObjectOf<S> : JsonValue;
+type ArrayOf<S> = S extends {
+    readonly items: infer I;
+} ? Array<InferJsonSchema<I>> : JsonValue[];
+type PropertiesOf<S> = S extends {
+    readonly properties: infer P;
+} ? P : {};
+/** The property names `required` lists; none when its literal was widened to `string`. */
+type RequiredOf<S> = S extends {
+    readonly required: ReadonlyArray<infer R>;
+} ? string extends R ? never : R : never;
+type ObjectOf<S> = Flatten$1<{
+    [K in keyof PropertiesOf<S> & RequiredOf<S>]: InferJsonSchema<PropertiesOf<S>[K]>;
+} & {
+    [K in Exclude<keyof PropertiesOf<S>, RequiredOf<S>>]?: InferJsonSchema<PropertiesOf<S>[K]>;
+} & AdditionalOf<S>>;
+/**
+ * The keys an object holds beyond its `properties`: none when `additionalProperties` is `false`;
+ * each of its schema's type when the object declares no `properties` (a map); `unknown` otherwise,
+ * since a declared property and an index signature of another type cannot both be read precisely.
+ */
+type AdditionalOf<S> = S extends {
+    readonly additionalProperties: false;
+} ? {} : keyof PropertiesOf<S> extends never ? S extends {
+    readonly additionalProperties: infer A;
+} ? A extends true ? {
+    [key: string]: JsonValue;
+} : {
+    [key: string]: InferJsonSchema<A>;
+} : {
+    [key: string]: JsonValue;
+} : {
+    [key: string]: unknown;
+};
+/**
+ * A json field's read: `JsonValue` without a schema, the schema's value with one. `C` is the field's
+ * config, as a builder keeps it.
+ */
+type JsonFieldValue<C> = C extends {
+    readonly schema?: infer S;
+} ? [Exclude<S, undefined>] extends [never] ? JsonValue : InferJsonSchema<Exclude<S, undefined>> : JsonValue;
+
 /**
  * Singleton content type definition matching @relyio/schema
  *
@@ -7696,13 +8575,44 @@ type AnyAssetTypeDefinition = AssetTypeDefinition<any>;
  *
  * Mirrors {@link InferContentType}: produces the metadata field shape (a required field present)
  * plus `_metadata`, so it is assignable to `BaseContent` and can parametrize
- * `AssetClient<T>`. The runtime `file`/`urls` blocks are layered on by the
- * client's `AssetEntryResponse<T>` return type, not here, to keep the schema
- * layer free of any dependency on the client layer.
+ * `AssetClient<T>` — whose writes and `where` name exactly these fields. What a **read** returns
+ * adds the {@link AssetServedBlocks}: {@link InferAssetEntry}.
  */
 type InferAssetType<T extends AnyAssetTypeDefinition, S extends FieldSchemaContext | undefined = undefined, I extends string = never> = FieldValues<DeclaredFields<T>, S, 'required', I> & {
     _metadata: EntryMetadata;
 };
+/**
+ * Customer-facing file binding block on an asset entry: the document's `AssetFile` — status,
+ * backend, file name, MIME type, size, advisory hash, visibility, extracted metadata, focal point,
+ * enrichment and scan status, processing stage/progress/error, and video playback readiness.
+ */
+type AssetFileBlock = components['schemas']['AssetFile'];
+/**
+ * Computed gateway delivery URLs (the reserved `urls` key): the document's `AssetUrls` — an image's
+ * `original` and `variants`, a file's `original`, a video's `playback`, `poster` and `download`.
+ * Present only when `file.status` is `ready` — otherwise the response omits `urls` and callers read
+ * `file.status`. Read from the committed document (REL-2194), which declared none until then, so this
+ * was written here by hand.
+ */
+type AssetUrls = components['schemas']['AssetUrls'];
+/**
+ * What every read of an asset carries beside its fields and `_metadata`, wherever the asset is read:
+ * `file`, its binding, once one is bound, and `urls`, signed once the file is ready. The Content API
+ * composes an asset's `file` into every entry it serves, an included reference at any depth among
+ * them, and keeps it when an include path picks fields; its entry routes stamp `urls` onto every asset
+ * the payload holds (REL-1812). A read's blocks, not fields: nothing writes or filters by them.
+ */
+interface AssetServedBlocks {
+    file?: AssetFileBlock;
+    urls?: AssetUrls;
+}
+/**
+ * An asset as a read returns it (REL-1812): its fields and `_metadata` ({@link InferAssetType}) and
+ * the {@link AssetServedBlocks}. What `asset(name)` reads, and what a reference to the asset type
+ * reads as once an include path expands it — through a list, an object, rich text or a singleton
+ * alike. `relyio generate-types` writes each asset type's alias with it.
+ */
+type InferAssetEntry<T extends AnyAssetTypeDefinition, S extends FieldSchemaContext | undefined = undefined, I extends string = never> = InferAssetType<T, S, I> & AssetServedBlocks;
 
 /**
  * What a read returns for each field, derived from the field's declaration (`INV-SS-TYPES-INFERRED`).
@@ -7737,6 +8647,8 @@ type InferAssetType<T extends AnyAssetTypeDefinition, S extends FieldSchemaConte
  *   their union told apart by `_type` (REL-1799). A **required** object is given a shape and that
  *   shape's required values when the entry is created (REL-2034), so even a draft read holds its
  *   `_type` and `_key`.
+ * - A `json` field is the value its JSON Schema describes, inferred from the schema literal, and
+ *   `JsonValue` — any JSON value — without one (REL-1811, `./json-schema.ts`).
  */
 
 /**
@@ -7767,8 +8679,14 @@ interface UnresolvedEntry {
 type FieldValueByType<C, S extends Context, K extends string, I extends string, A extends boolean> = OverEveryFieldKind<{
     shortText: string;
     longText: string;
-    /** The version-1 tree (REL-1803): `{ _type: 'richText', version: 1, children }`. */
-    richText: RichTextValue;
+    /**
+     * The version-1 tree (REL-1803): `{ _type: 'richText', version: 1, children }`, holding the
+     * field's declared Blocks and Inline elements, each its fieldset's value (REL-1807), and — where it
+     * declares `links` — its entry links (REL-1808). The field is one include path: included, every
+     * entry link's `to` is the entry it links to and every reference inside a declared node its entry;
+     * not included, each is its id.
+     */
+    richText: RichTextValue<DeclaredIn<BlocksIn<C>, S, InsideRichText<I, K, BlocksIn<C>>, ExpandsHere<I, K, A>>, DeclaredIn<InlineIn<C>, S, InsideRichText<I, K, InlineIn<C>>, ExpandsHere<I, K, A>>, EntryLinkIn<C, S, K, I, A>>;
     /** Exactly a rich-text table block's value (REL-1806). */
     table: RichTextTable;
     /** Exactly a rich-text code group's value: code with tabs (REL-1806). */
@@ -7788,6 +8706,11 @@ type FieldValueByType<C, S extends Context, K extends string, I extends string,
     tags: string[];
     list: ListValue<C, S, IncludesUnder<I, K>, CoversBelow<I, K, A>>;
     object: ObjectValue<C, S, IncludesUnder<I, K>, CoversBelow<I, K, A>>;
+    /**
+     * The value its JSON Schema describes, and any JSON value without one — `JsonValue`, never `any`
+     * (REL-1811, `./json-schema.ts`).
+     */
+    json: JsonFieldValue<C>;
 }>;
 /**
  * The value a read returns for field `F`, under the include paths `I` of the record it sits in —
@@ -7864,15 +8787,31 @@ type ReferenceTarget<C> = C extends {
 /** `R[K]` where `R` declares `K`. A `Record<string, never>` default declares nothing. */
 type Declared<R, K> = K extends keyof R ? R[K] : never;
 type ContentEntryOf<D, S extends Context, I extends string> = D extends ContentTypeDefinition ? InferContentType<D, S, I> : never;
-type SingletonEntryOf<D, S extends Context, I extends string> = D extends SingletonContentTypeDefinition ? InferSingletonContentType<D, S, I> : never;
-type AssetEntryOf<D, S extends Context, I extends string> = D extends AssetTypeDefinition ? InferAssetType<D, S, I> : never;
-type OrUnresolved<T> = [T] extends [never] ? UnresolvedEntry : T;
+/**
+ * An expanded singleton: its fields, as a singleton read types them, beside the `_metadata` every
+ * expanded entry carries — {@link EntryMetadata}, not the singleton read's `SingletonMetadata`. The
+ * Content API builds every record an include expands with the entry transform, a singleton's too
+ * (REL-2195), so it reports `entryType`, `slug`, `refs` and the rest, and no version history.
+ */
+type SingletonEntryOf<D, S extends Context, I extends string> = D extends SingletonContentTypeDefinition ? Omit<InferSingletonContentType<D, S, I>, '_metadata'> & {
+    _metadata: EntryMetadata;
+} : never;
+/**
+ * An expanded asset: the fields a path picked of it beside `_metadata`, and the
+ * {@link AssetServedBlocks} — `file` and `urls` — picked or not, as the Content API serves every asset
+ * an include expands, at any depth (REL-1812). With every field, exactly what `asset(name)` reads
+ * (`InferAssetEntry`).
+ */
+type AssetEntryOf<D, S extends Context, I extends string, Fields> = D extends AssetTypeDefinition ? Selected<InferAssetType<D, S, I>, Fields> & AssetServedBlocks : never;
+type OrUnresolved<T, Fields> = [T] extends [never] ? Selected<UnresolvedEntry, Fields> : T;
 /**
  * What `include` expands a reference to `Target` into: that type's entry, typed by the schema, under
  * `I`, the include paths that continue past the reference (`customers.logo` → `logo` inside the
- * customer).
+ * customer), cut down to `Fields`, the fields a path picked (`./include-paths.ts`'s `Selected`). The
+ * one place every expansion is typed — a reference at any depth, an entry link, a singleton's or a
+ * settings group's include — so an asset reads as the API serves it wherever it is reached.
  */
-type ExpandedEntry<Target, S extends Context, I extends string = never> = S extends FieldSchemaContext ? OrUnresolved<ContentEntryOf<Declared<S['contentTypes'], Target>, S, I> | SingletonEntryOf<Declared<S['singletonContentTypes'], Target>, S, I> | AssetEntryOf<Declared<NonNullable<S['assetTypes']>, Target>, S, I>> : UnresolvedEntry;
+type ExpandedEntry<Target, S extends Context, I extends string = never, Fields = EveryField> = S extends FieldSchemaContext ? OrUnresolved<Selected<ContentEntryOf<Declared<S['contentTypes'], Target>, S, I>, Fields> | Selected<SingletonEntryOf<Declared<S['singletonContentTypes'], Target>, S, I>, Fields> | AssetEntryOf<Declared<NonNullable<S['assetTypes']>, Target>, S, I, Fields>, Fields> : Selected<UnresolvedEntry, Fields>;
 /**
  * What a single reference reads as once its target is gone: `null` for an optional one, whose
  * referrers a delete may nullify, and nothing for a required one, whose target cannot be deleted
@@ -7884,7 +8823,7 @@ type Nullified<C> = RequiredIn<C> extends true ? never : null;
  * where a path expands it — the target's entry, narrowed to the fields a path picked. Under an include
  * set the type cannot see (`string`), either.
  */
-type ReferenceValue<C, S extends Context, K extends string, I extends string, A extends boolean> = string extends I ? ReferenceAs<C, string | ExpandedEntry<ReferenceTarget<C>, S, string>> : ReferenceAs<C, ExpandsHere<I, K, A> extends true ? Selected<ExpandedEntry<ReferenceTarget<C>, S, IncludesUnder<I, K>>, SelectionAt<I, K>> : string>;
+type ReferenceValue<C, S extends Context, K extends string, I extends string, A extends boolean> = string extends I ? ReferenceAs<C, string | ExpandedEntry<ReferenceTarget<C>, S, string>> : ReferenceAs<C, ExpandsHere<I, K, A> extends true ? ExpandedEntry<ReferenceTarget<C>, S, IncludesUnder<I, K>, SelectionAt<I, K>> : string>;
 /** One reference value `V`, as the field holds it: alone, nullable unless required, or a list. */
 type ReferenceAs<C, V> = [Multiplicity<C>] extends [true] ? V[] : [Multiplicity<C>] extends [false | undefined] ? V | Nullified<C> : V | Nullified<C> | V[];
 /**
@@ -7896,6 +8835,54 @@ type ReferenceAs<C, V> = [Multiplicity<C>] extends [true] ? V[] : [Multiplicity<
 type ListValue<C, S extends Context, I extends string, A extends boolean> = C extends {
     readonly of?: infer Shape;
 } ? [ShapesIn<Exclude<Shape, undefined>>] extends [never] ? string[] : Array<ShapeItem<ShapesIn<Exclude<Shape, undefined>>, S, I, A>> : string[];
+/**
+ * A declared shape's value inside rich text: its item, as a page builder's is — every reference in it
+ * expanded when `A`, the field being included, says so (a rich-text field is one include path).
+ */
+type DeclaredIn<Shape, S extends Context, I extends string, A extends boolean> = Extract<ShapeItem<Shape, S, I, A>, RichTextShapeValue>;
+/**
+ * The include paths a rich-text field `K`'s declared nodes `Shape` are read under. Rich text has no
+ * path inside it: the field is one include path, so what a path does at `K` it does to every
+ * reference the nodes hold, at any depth — the server picks each one's fields by `K(…)`'s
+ * parentheses and continues each by `K.…`'s rest (REL-1808). So each path stopping at or past `K` is
+ * re-spelt at every path the shape can include (`body(slug)` → `see(slug)`, `items.ref(slug)`),
+ * and every reference reads the selection and the hops the field was given. An include set the type
+ * cannot see (`string`) may expand anything.
+ */
+type InsideRichText<I extends string, K extends string, Shape> = string extends I ? string : `${IncludablePaths<FieldsOfShapes$1<Shape>>}${SuffixAt<I, K>}`;
+/** What each path does at `K`, as a suffix: `''` stops there, `(slug)` picks, `.author` continues. */
+type SuffixAt<I extends string, K extends string> = I extends K ? '' : I extends `${K}(${infer Picked})` ? `(${Picked})` : I extends `${K}.${infer Rest}` ? `.${Rest}` : never;
+/** The fields of the fieldsets `Shape` names, sections read flat. */
+type FieldsOfShapes$1<Shape> = Shape extends {
+    readonly fields: readonly unknown[];
+} ? DeclaredFields<Shape> : never;
+/**
+ * The content types a rich-text config's `links` names (REL-1808), as a union; `never` for a field
+ * that declares none — and for a config the type cannot read `links` from.
+ */
+type LinkTargetsIn<C> = C extends {
+    readonly links?: {
+        readonly to: infer To;
+    } | undefined;
+} ? unknown extends To ? never : ReferenceTarget<{
+    readonly to: To;
+}> : never;
+/**
+ * A rich-text field's entry link (REL-1808): `never` for a field declaring no `links`; otherwise the
+ * mark, its `to` the target's id — or, where the field is included, the target's entry, narrowed to
+ * the fields a path picked and holding the paths that continue past the field.
+ */
+type EntryLinkIn<C, S extends Context, K extends string, I extends string, A extends boolean> = [
+    LinkTargetsIn<C>
+] extends [never] ? never : RichTextEntryLinkMark<string extends I ? string | ExpandedEntry<LinkTargetsIn<C>, S, string> : ExpandsHere<I, K, A> extends true ? ExpandedEntry<LinkTargetsIn<C>, S, IncludesUnder<I, K>, SelectionAt<I, K>> : string>;
+/** The fieldsets a rich-text config declares as Blocks (REL-1807), as a union; `never` for none. */
+type BlocksIn<C> = C extends {
+    readonly blocks?: ReadonlyArray<infer Shape>;
+} ? Shape : never;
+/** The fieldsets a rich-text config declares as Inline elements (REL-1807), as a union. */
+type InlineIn<C> = C extends {
+    readonly inline?: ReadonlyArray<infer Shape>;
+} ? Shape : never;
 /** The shapes an `of` names: the one fieldset, or each of a list of them. Distributes. */
 type ShapesIn<Of> = Of extends readonly (infer Shape)[] ? Shape : Of;
 /**
@@ -8243,7 +9230,7 @@ interface RequirementRule {
     action: 'require' | 'optional';
     conditions: RuleConditions;
 }
-interface ValidationRule {
+interface ValidationRule$1 {
     type: 'validation';
     action: 'validate' | 'skip';
     message?: string;
@@ -8254,13 +9241,13 @@ interface ReadOnlyRule {
     action: 'enable' | 'disable';
     conditions: RuleConditions;
 }
-type FieldRule = VisibilityRule | RequirementRule | ValidationRule | ReadOnlyRule;
+type FieldRule = VisibilityRule | RequirementRule | ValidationRule$1 | ReadOnlyRule;
 type LocalizationConfig = boolean | string[] | {
     enabled: boolean;
     requiredLocales?: string[];
     fallback?: boolean;
 };
-interface FieldDefinition<TId extends string = string, TType extends string = string, TConfig = unknown> {
+interface FieldDefinition$1<TId extends string = string, TType extends string = string, TConfig = unknown> {
     /** Unique field identifier - preserves literal type for type inference */
     readonly id: TId;
     /** Field type */
@@ -8283,7 +9270,7 @@ interface FieldDefinition<TId extends string = string, TType extends string = st
 /**
  * Any field definition - used in arrays where we need to preserve specific field types
  */
-type AnyFieldDefinition = FieldDefinition<string, string, unknown>;
+type AnyFieldDefinition = FieldDefinition$1<string, string, unknown>;
 interface ShortTextConfig extends BaseFieldConfig {
     /** Maximum character length */
     maxLength?: number;
@@ -8299,10 +9286,17 @@ interface LongTextConfig extends BaseFieldConfig {
 /**
  * A rich-text field's config. With none of `structure`, `marks` and `multiline` the field has the
  * whole docs set of built-ins; each narrows it, and the Studio's editor and every write hold the
- * field to the narrowing (REL-1805). `blocks`, `inline` and `links` are reserved for declared blocks
- * and entry links, and a deploy that sets one now is refused.
+ * field to the narrowing (REL-1805). `blocks` and `inline` declare the fieldsets an editor inserts
+ * between paragraphs and inside a sentence (REL-1807) — `TBlock` and `TInline`, which
+ * `fields.richText()` infers so a read types each one by its fieldset — and `links` the content types
+ * its text may link to (REL-1808), `TLinks`, so a read types each entry link's target.
  */
-interface RichTextConfig extends BaseFieldConfig {
+/** A rich-text field's `links` (REL-1808): the content types its entry links may point at. */
+interface RichTextLinks<TTo extends string = string> {
+    /** As a reference field's `to` is written: one content type's id, or several */
+    to: TTo | TTo[];
+}
+interface RichTextConfig<TBlock extends AnyFieldset = AnyFieldset, TInline extends AnyFieldset = AnyFieldset, TLinks extends string = string> extends BaseFieldConfig {
     /** Maximum count of the value's text characters, its markup not counted (default 50,000) */
     maxLength?: number;
     /**
@@ -8314,12 +9308,25 @@ interface RichTextConfig extends BaseFieldConfig {
     marks?: readonly RichTextMarkType[];
     /** `false` makes a one-line field: one paragraph, no line break, no other block. Default `true`. */
     multiline?: boolean;
-    /** Reserved for declared blocks (REL-1807): a deploy that sets it is refused. */
-    blocks?: never;
-    /** Reserved for inline elements (REL-1807): a deploy that sets it is refused. */
-    inline?: never;
-    /** Reserved for entry links (REL-1808): a deploy that sets it is refused. */
-    links?: never;
+    /**
+     * The fieldsets an editor may insert between paragraphs (REL-1807): each is a node of the tree
+     * wherever blocks go, `{ _type, _key, …its fields }` — exactly a page builder's item of the same
+     * fieldset. `<RichText>` needs a component for each. Not in a one-line field.
+     */
+    blocks?: readonly TBlock[];
+    /**
+     * The fieldsets an editor may insert inside a sentence (REL-1807): each stands beside a
+     * paragraph's text as `{ _type, _key, …its fields }`. `<RichText>` needs a component for each.
+     */
+    inline?: readonly TInline[];
+    /**
+     * The content types the text may link to (REL-1808): `{ to }`, one type or several, as a
+     * reference names them. Each entry link is a reference — checked on publish, blocking or unwrapped
+     * on its target's delete, expanded when the field is included — with an optional heading anchor.
+     * `<RichText>` needs an `entryLink` component wherever it is set: only your site knows its URLs.
+     * Absent allows no entry link.
+     */
+    links?: RichTextLinks<TLinks>;
     /** A version-1 rich-text tree, every node but a text run keyed (REL-1803) */
     defaultValue?: RichTextValue;
 }
@@ -8346,6 +9353,11 @@ interface CodeConfig extends BaseFieldConfig {
     /** A code group, every node keyed, held to `languages` and `maxTabs` */
     defaultValue?: RichTextCodeGroup;
 }
+/**
+ * A slug field's value is lowercase letters, numbers and hyphens, and may have segments separated by
+ * a slash (`guide/schema/text-fields`), each segment a slug on its own. A leading, a trailing and a
+ * doubled slash are refused `SLUG_INVALID_FORMAT`, the message naming which. Unique as a whole.
+ */
 interface SlugConfig extends BaseFieldConfig {
     /** Source field to generate slug from */
     sourceField?: string;
@@ -8488,6 +9500,27 @@ interface ObjectConfig<TShape extends AnyFieldset = AnyFieldset> extends BaseFie
      */
     of: TShape | readonly TShape[];
 }
+/**
+ * A `json` field's config (REL-1811): any JSON value, held to `schema` when it is given — on every
+ * write, a draft included, since a value its schema refuses is never stored. `TSchema` is the schema
+ * literal, which `fields.json()` keeps so a read is typed by it (`InferJsonSchema`); write it
+ * `as const` to keep `required`, `enum` and `const` exact. A json field takes no `defaultValue`.
+ */
+interface JsonConfig<TSchema extends JsonSchema = JsonSchema> {
+    /** Whether the field is required: required from creation, since no value is every schema's */
+    required?: boolean;
+    /** Whether the field value must be unique */
+    unique?: boolean;
+    /**
+     * The JSON Schema every value is held to: `type`, `properties`, `required`,
+     * `additionalProperties`, `items`, `enum`, `const`, `anyOf` and `oneOf` say what a value is;
+     * `minLength`, `maxLength`, `pattern`, `format`, `minimum`, `maximum`, `exclusiveMinimum`,
+     * `exclusiveMaximum`, `multipleOf`, `minItems`, `maxItems`, `uniqueItems`, `minProperties` and
+     * `maxProperties` narrow it; `title`, `description`, `default` and `examples` annotate it. Any
+     * other keyword — `$ref`, `$id`, `allOf`, `not` — is refused at deploy by name.
+     */
+    schema?: TSchema;
+}
 /**
  * Every field kind: the one union, `FieldKind` in `@relyio/schema`'s field-kind declaration
  * (REL-1783). A kind the declaration gains is a kind here, and every table this package keys by it
@@ -8497,57 +9530,268 @@ interface ObjectConfig<TShape extends AnyFieldset = AnyFieldset> extends BaseFie
 type FieldType = FieldKind;
 
 /**
- * Settings group definition matching @relyio/schema SettingsGroupSchema
- *
- * Settings groups are for project-level configuration that doesn't fit
- * into content types (e.g., API keys, feature flags, integrations).
+ * Field builders for defining schema fields
+ * Matches the @relyio/schema FieldSchema structure
  *
- * Uses advanced TypeScript generics to preserve literal field IDs through
- * the type system, enabling full autocomplete in SDK methods.
+ * All builders are generic over the ID to preserve literal types for type inference. `enum`,
+ * `reference` and `list` are generic over the parts of their config a read's type depends on too —
+ * the option values, the targets, `multi` and the list's shape — each through a type parameter with a
+ * primitive or field constraint, which is what keeps a literal from widening without a `const`
+ * type parameter (the package supports TypeScript 4.9, which has none).
  */
 
+interface FieldOptions$1<TConfig, TLocalization extends LocalizationConfig = LocalizationConfig> {
+    /** Type-specific configuration */
+    config?: TConfig;
+    /** UI display configuration */
+    ui?: FieldUIConfig;
+    /** AI configuration: generation/review guidance (`instructions`) for this field. */
+    ai?: FieldAIConfig;
+    /** Dynamic field rules */
+    rules?: FieldRule[];
+    /** Localization settings */
+    localization?: TLocalization;
+    /** Fallback value */
+    fallback?: unknown;
+    /** Whether this field is deprecated */
+    deprecated?: boolean;
+}
 /**
- * Settings group configuration - generic to preserve field types
+ * `required`, kept as the literal it was written as, so a read's type knows which fields are always
+ * present (`schema/infer-fields.ts`, REL-1795) — through a type parameter with a primitive
+ * constraint, as `multi` is, so `true` does not widen to `boolean`.
  */
-interface SettingsGroupConfig<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
-    /** Display name shown in the UI */
-    displayName: string;
-    /** Description of the settings group */
-    description?: string;
-    /** AI configuration for content generation and review */
-    ai?: AIConfig;
-    /** Access tags for role-based access control */
-    accessTags?: string[];
-    /** Settings fields - preserves literal types */
-    fields: TFields;
-}
+type RequiredAs<TRequired extends boolean> = {
+    required?: TRequired;
+};
+/** The key a field definition's type keeps its `localization` literal under. Types only. */
+declare const localizedAs: unique symbol;
 /**
- * Settings group definition - preserves field types for inference
+ * `localization`, kept as the literal it was written as — `true`, `{ enabled: true }` — by the
+ * builders of the kinds whose translation decides what a filter may name (REL-2136): a reference and
+ * rich text, and the list or object they sit in. A reference or rich text a shared list translates
+ * item by item has no stored path a filter names, so a typed `where` refuses it
+ * (`schema/include-paths.ts`'s `FilterPaths`). `never` where none is written.
+ *
+ * Kept under a key of its own, which holds nothing at runtime: kept under `localization`, a field
+ * inside a `fieldset()` or a type's `fields` widened `true` to `boolean`, inferred from the
+ * `localization` every field definition declares (measured, REL-2136), as `required` is not, which
+ * sits in a `config` the surrounding list does not type.
  */
-interface SettingsGroupDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
-    readonly _tag: 'settingsGroup';
-    readonly name: string;
-    readonly displayName: string;
-    readonly description?: string;
-    /** AI configuration for content generation and review */
-    readonly ai?: AIConfig;
-    readonly accessTags?: string[];
-    readonly fields: TFields;
+interface LocalizedAs<TLocalization extends LocalizationConfig> {
+    readonly [localizedAs]?: TLocalization;
 }
+/** The `localization` a field definition's type kept ({@link LocalizedAs}); `never` where none. */
+type LocalizationOf<F> = F extends LocalizedAs<infer L> ? L : never;
 /**
- * Define a settings group
- *
- * The generic type parameter preserves the literal field IDs through the type
- * system, enabling autocomplete in SDK methods.
- *
- * @example
- * const integrations = defineSettingsGroup('integrations', {
- *   displayName: 'Integrations',
- *   description: 'Third-party service integrations',
- *   fields: [
- *     fields.shortText('stripeApiKey', {
- *       config: { required: true },
- *       ui: { displayName: 'Stripe API Key' }
+ * Short text field (single line)
+ * @example fields.shortText('title', { config: { required: true, maxLength: 200 } })
+ */
+declare function shortText<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<ShortTextConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'shortText', ShortTextConfig & RequiredAs<TRequired>>;
+/**
+ * Long text field (multi-line textarea)
+ * @example fields.longText('description', { config: { maxLength: 5000 } })
+ */
+declare function longText<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<LongTextConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'longText', LongTextConfig & RequiredAs<TRequired>>;
+/**
+ * Rich text: the docs set of built-ins, narrowed by `structure`, `marks` and `multiline`, the
+ * fieldsets an editor inserts between paragraphs (`blocks`) and inside a sentence (`inline`), and the
+ * content types its entry links point at (`links`)
+ * @example fields.richText('content', { config: { structure: ['heading', 'bulletList'], marks: ['bold', 'italic', 'link'] } })
+ * @example fields.richText('body', { config: { blocks: [{ id: 'callout', displayName: 'Callout', fields: [fields.shortText('title')] }] } })
+ * @example fields.richText('body', { config: { links: { to: 'docPage' } } })
+ */
+declare function richText<TId extends string, TBlock extends AnyFieldset = never, TInline extends AnyFieldset = never, TLinks extends string = never, TRequired extends boolean = false, TLocalization extends LocalizationConfig = never>(id: TId, options?: FieldOptions$1<RichTextConfig<TBlock, TInline, TLinks> & RequiredAs<TRequired>, TLocalization>): FieldDefinition$1<TId, 'richText', RichTextConfig<TBlock, TInline, TLinks> & RequiredAs<TRequired>> & LocalizedAs<TLocalization>;
+/**
+ * A table: exactly a rich-text table block's value — rows of formatted cells, an optional header row
+ * and per-cell alignment — so a comparison table on a page and a table in a doc are one thing
+ * (REL-1806). Read as `RichTextTable`; `<RichText>` and `richTextToHtml` render it.
+ * @example fields.table('comparison', { config: { required: true } })
+ */
+declare function table<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<TableConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'table', TableConfig & RequiredAs<TRequired>>;
+/**
+ * Code with tabs: exactly a rich-text code group's value — one tab or more, each with its label,
+ * language, filename and line range (REL-1806). Read as `RichTextCodeGroup`; `<RichText>` and
+ * `richTextToHtml` render it.
+ * @example fields.code('snippet', { config: { languages: ['typescript', 'bash'], maxTabs: 4 } })
+ */
+declare function code<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<CodeConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'code', CodeConfig & RequiredAs<TRequired>>;
+/**
+ * Slug field (URL-friendly identifier)
+ * @example fields.slug('slug', { config: { sourceField: 'title' } })
+ */
+declare function slug<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<SlugConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'slug', SlugConfig & RequiredAs<TRequired>>;
+/**
+ * URL field with validation
+ * @example fields.url('website', { config: { allowedProtocols: ['https'] } })
+ */
+declare function url<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<UrlConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'url', UrlConfig & RequiredAs<TRequired>>;
+/**
+ * Email field with validation
+ * @example fields.email('contactEmail', { config: { required: true } })
+ */
+declare function email<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<EmailConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'email', EmailConfig & RequiredAs<TRequired>>;
+/**
+ * Integer field
+ * @example fields.integer('quantity', { config: { min: 0, max: 100 } })
+ */
+declare function integer<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<IntegerConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'integer', IntegerConfig & RequiredAs<TRequired>>;
+/**
+ * Decimal field with precision
+ * @example fields.decimal('weight', { config: { decimalPlaces: 2, min: 0 } })
+ */
+declare function decimal<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<DecimalConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'decimal', DecimalConfig & RequiredAs<TRequired>>;
+/**
+ * Boolean field (true/false toggle)
+ * @example fields.boolean('isActive', { config: { defaultValue: false } })
+ */
+declare function boolean<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<BooleanConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'boolean', BooleanConfig & RequiredAs<TRequired>>;
+/**
+ * Enum field with predefined options
+ * @example fields.enum('status', {
+ *   config: {
+ *     options: [
+ *       { value: 'draft', label: 'Draft' },
+ *       { value: 'published', label: 'Published' },
+ *     ]
+ *   }
+ * })
+ */
+declare function enumField<TId extends string, TValue extends string = string, TMulti extends boolean = false, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<EnumConfig<TValue, TMulti> & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'enum', EnumConfig<TValue, TMulti> & RequiredAs<TRequired>>;
+/**
+ * Date field (no time)
+ * @example fields.date('publishDate', { config: { minDate: '2024-01-01' } })
+ */
+declare function date<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<DateConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'date', DateConfig & RequiredAs<TRequired>>;
+/**
+ * DateTime field: an instant, stored and read back in UTC whatever offset it is written in.
+ * `timeZoneHandling` says whether the editor shows it in UTC or in the author's local time.
+ * @example fields.dateTime('createdAt', { config: { timeZoneHandling: 'UTC' } })
+ */
+declare function dateTime<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<DateTimeConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'dateTime', DateTimeConfig & RequiredAs<TRequired>>;
+/**
+ * Reference to other entries (content types or asset types)
+ * @example fields.reference('category', { config: { to: 'category' } })
+ * @example fields.reference('relatedItems', { config: { to: ['product', 'service'], multi: true } })
+ * @example fields.reference('heroImage', { config: { to: 'productPhoto' } })
+ */
+declare function reference<TId extends string, TTo extends string = string, TMulti extends boolean = false, TRequired extends boolean = false, TLocalization extends LocalizationConfig = never>(id: TId, options?: FieldOptions$1<ReferenceConfig<TTo, TMulti> & RequiredAs<TRequired>, TLocalization>): FieldDefinition$1<TId, 'reference', ReferenceConfig<TTo, TMulti> & RequiredAs<TRequired>> & LocalizedAs<TLocalization>;
+/**
+ * Tags field (array of strings with autocomplete)
+ * @example fields.tags('keywords', { config: { predefinedTags: ['featured', 'sale'], maxTags: 10 } })
+ */
+declare function tags<TId extends string, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<TagsConfig & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'tags', TagsConfig & RequiredAs<TRequired>>;
+/**
+ * List field: a repeatable group of one shape. Each item holds the fields of the fieldset `of`
+ * names — usually a `fieldset()` value, declared once and passed wherever it is wanted — plus
+ * `_type` (that fieldset's id) and `_key` (its item key). Without `of`, a list of strings.
+ * @example fields.list('specifications', {
+ *   config: {
+ *     minItems: 1,
+ *     maxItems: 20,
+ *     of: {
+ *       id: 'spec',
+ *       displayName: 'Specification',
+ *       fields: [
+ *         fields.shortText('name', { config: { required: true } }),
+ *         fields.shortText('value', { config: { required: true } }),
+ *       ],
+ *     },
+ *   },
+ * })
+ */
+declare function list<TId extends string, TShape extends AnyFieldset = never, TRequired extends boolean = false, TLocalization extends LocalizationConfig = never>(id: TId, options?: FieldOptions$1<ListConfig<TShape> & RequiredAs<TRequired>, TLocalization>): FieldDefinition$1<TId, 'list', ListConfig<TShape> & RequiredAs<TRequired>> & LocalizedAs<TLocalization>;
+/**
+ * Object field: one value of a shape. It holds the fields of the fieldset `of` names — usually a
+ * `fieldset()` value, declared once and passed wherever it is wanted — plus `_type` (that
+ * fieldset's id) and `_key`. Or of one of several shapes, `_type` saying which (REL-1799).
+ * @example fields.object('seo', {
+ *   config: {
+ *     of: { id: 'seo', displayName: 'SEO', fields: [fields.shortText('metaTitle')] },
+ *   },
+ * })
+ * @example fields.object('media', {
+ *   config: {
+ *     required: true,
+ *     of: [
+ *       { id: 'screenshot', displayName: 'Screenshot', fields: [fields.reference('image', { config: { to: 'image' } })] },
+ *       { id: 'video', displayName: 'Video', fields: [fields.url('src', { config: { required: true } })] },
+ *     ],
+ *   },
+ * })
+ */
+declare function object<TId extends string, TShape extends AnyFieldset, TRequired extends boolean = false, TLocalization extends LocalizationConfig = never>(id: TId, options: Omit<FieldOptions$1<ObjectConfig<TShape> & RequiredAs<TRequired>, TLocalization>, 'config'> & {
+    config: ObjectConfig<TShape> & RequiredAs<TRequired>;
+}): FieldDefinition$1<TId, 'object', ObjectConfig<TShape> & RequiredAs<TRequired>> & LocalizedAs<TLocalization>;
+/**
+ * JSON field: data nobody models, any JSON value — held to `schema`, a JSON Schema, when it is given
+ * (REL-1811). A read is typed by the schema (`InferJsonSchema`), and is `JsonValue` without one.
+ * Write the schema `as const` so `required`, `enum` and `const` keep their literals. Its source is
+ * edited in the Studio as text, and saved when it parses to a value the schema admits.
+ * @example fields.json('chart', {
+ *   config: {
+ *     schema: {
+ *       type: 'object',
+ *       properties: { points: { type: 'array', items: { type: 'number' } } },
+ *       required: ['points'],
+ *     } as const,
+ *   },
+ * })
+ */
+declare function json<TId extends string, TSchema extends JsonSchema = never, TRequired extends boolean = false>(id: TId, options?: FieldOptions$1<JsonConfig<TSchema> & RequiredAs<TRequired>>): FieldDefinition$1<TId, 'json', JsonConfig<TSchema> & RequiredAs<TRequired>>;
+
+/**
+ * Settings group definition matching @relyio/schema SettingsGroupSchema
+ *
+ * Settings groups are for project-level configuration that doesn't fit
+ * into content types (e.g., API keys, feature flags, integrations).
+ *
+ * Uses advanced TypeScript generics to preserve literal field IDs through
+ * the type system, enabling full autocomplete in SDK methods.
+ */
+
+/**
+ * Settings group configuration - generic to preserve field types
+ */
+interface SettingsGroupConfig<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
+    /** Display name shown in the UI */
+    displayName: string;
+    /** Description of the settings group */
+    description?: string;
+    /** AI configuration for content generation and review */
+    ai?: AIConfig;
+    /** Access tags for role-based access control */
+    accessTags?: string[];
+    /** Settings fields - preserves literal types */
+    fields: TFields;
+}
+/**
+ * Settings group definition - preserves field types for inference
+ */
+interface SettingsGroupDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
+    readonly _tag: 'settingsGroup';
+    readonly name: string;
+    readonly displayName: string;
+    readonly description?: string;
+    /** AI configuration for content generation and review */
+    readonly ai?: AIConfig;
+    readonly accessTags?: string[];
+    readonly fields: TFields;
+}
+/**
+ * Define a settings group
+ *
+ * The generic type parameter preserves the literal field IDs through the type
+ * system, enabling autocomplete in SDK methods.
+ *
+ * @example
+ * const integrations = defineSettingsGroup('integrations', {
+ *   displayName: 'Integrations',
+ *   description: 'Third-party service integrations',
+ *   fields: [
+ *     fields.shortText('stripeApiKey', {
+ *       config: { required: true },
+ *       ui: { displayName: 'Stripe API Key' }
  *     }),
  *     fields.shortText('sendgridApiKey', {
  *       ui: { displayName: 'SendGrid API Key' }
@@ -8584,6 +9828,659 @@ type InferSettingsGroup<T extends AnySettingsGroupDefinition, S extends FieldSch
     _metadata: SettingsGroupMetadata;
 };
 
+/**
+ * Base error class for all RelyIO SDK errors
+ * Provides consistent error handling, context tracking, and retry logic
+ */
+declare abstract class SDKError extends Error {
+    /** Unique error code for programmatic error handling */
+    abstract readonly code: string;
+    /** Whether this error is retryable */
+    abstract readonly retryable: boolean;
+    /** HTTP status code if applicable */
+    readonly statusCode?: number;
+    /** Original error that caused this error */
+    readonly cause?: Error;
+    /** Additional context about the error */
+    readonly context?: Record<string, unknown>;
+    /** Timestamp when the error occurred */
+    readonly timestamp: number;
+    constructor(message: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    /**
+     * Convert error to JSON for logging and debugging
+     */
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string;
+        statusCode: number | undefined;
+        retryable: boolean;
+        context: Record<string, unknown> | undefined;
+        timestamp: number;
+        stack: string | undefined;
+    };
+    /**
+     * Get a user-friendly error message
+     */
+    getUserMessage(): string;
+    /**
+     * Get detailed error information for debugging
+     */
+    getDebugInfo(): string;
+    /**
+     * Check if this error is of a specific type
+     */
+    isType(errorType: string): boolean;
+    /**
+     * Create a new error with additional context
+     */
+    withContext(context: Record<string, unknown>): this;
+}
+
+/**
+ * Validation errors and related interfaces.
+ *
+ * `SchemaValidationError`, `RequiredFieldError` and `InvalidFieldTypeError` were deleted by
+ * REL-1471: nothing constructed them. The API refuses content the schema does not accept with one
+ * code, `CONTENT_INVALID`, whose `details.issues` name each field and its problem — the mapper
+ * throws `ValidationError` for it, and a missing required field or a value of the wrong type is a
+ * `violations` entry whose `code` says which.
+ */
+interface ValidationViolation {
+    field: string;
+    message: string;
+    code: string;
+    value?: unknown;
+    path?: string[];
+}
+declare abstract class BaseValidationError extends SDKError {
+    readonly retryable = false;
+    readonly violations: ValidationViolation[];
+    /**
+     * @param context - Carried beside `violations`. The mapper passes the refusal body as
+     *   `context.response`, as it does for every other contract code, so a consumer that hands the
+     *   service's own words on can read them here too.
+     */
+    constructor(message?: string, violations?: ValidationViolation[], statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+    /**
+     * Get violations for a specific field
+     */
+    getViolationsForField(fieldName: string): ValidationViolation[];
+    /**
+     * Check if a specific field has validation errors
+     */
+    hasFieldError(fieldName: string): boolean;
+    /**
+     * Get all validation messages as a formatted string
+     */
+    getFormattedMessages(): string;
+}
+declare class ValidationError extends BaseValidationError {
+    readonly code = "VALIDATION_ERROR";
+}
+declare class InvalidPayloadError extends BaseValidationError {
+    readonly code = "INVALID_PAYLOAD";
+    constructor(message?: string, violations?: ValidationViolation[], cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+
+/**
+ * View definitions for SDK schema
+ *
+ * Views define pre-configured entry list configurations with filters,
+ * columns, and metadata display settings.
+ */
+/**
+ * View scope defines which content types a view applies to.
+ *
+ * When using `contentTypes` (plural) or `all`, the view displays entries
+ * from multiple content types. In this case:
+ *
+ * - Columns/fields may only exist on some content types
+ * - For entries where a field doesn't exist, the UI displays "—"
+ * - System fields (id, status, createdAt, updatedAt) exist on all entries
+ * - Filters on non-existent fields are skipped for that entry type
+ *
+ * Example display:
+ * | Content Type | title | author | productCode |
+ * |--------------|-------|--------|-------------|
+ * | post         | ✓     | ✓      | —           |
+ * | product      | ✓     | —      | ✓           |
+ */
+/**
+ * Scope for a single content type
+ */
+interface ContentTypeScopeConfig {
+    type: 'contentType';
+    contentType: string;
+}
+/**
+ * Scope for multiple content types
+ *
+ * Fields not present on all content types will show "—" in the UI
+ */
+interface ContentTypesScopeConfig {
+    type: 'contentTypes';
+    contentTypes: string[];
+}
+/**
+ * Scope for an entry type (content, singleton, settings, asset)
+ */
+interface EntryTypeScopeConfig {
+    type: 'entryType';
+    entryType: 'content' | 'singleton' | 'settings' | 'asset';
+}
+/**
+ * Scope for all content
+ *
+ * Fields not present on all content types will show "—" in the UI
+ */
+interface AllScopeConfig {
+    type: 'all';
+}
+/**
+ * View scope options
+ */
+type ViewScopeConfig = ContentTypeScopeConfig | ContentTypesScopeConfig | EntryTypeScopeConfig | AllScopeConfig;
+/**
+ * The operators a view filter may name: the schema's `FILTER_OPERATORS`, which deploy parses a view
+ * with and the read core compiles every one of.
+ *
+ * This list used to be its own: ten of its names — `doesNotContain`, `isNotEmpty`, `isOnOrBefore`,
+ * `isOnOrAfter`, `tomorrow`, `lastWeek`, `lastMonth`, `includesAll`, `includesAny`, `excludes` —
+ * are none the schema declares, so a view naming one was refused at deploy, and six the schema does
+ * declare — `notContains`, `notIncludes`, `isOn`, `isBetween`, `thisYear`, `hasValue` — could not be
+ * written here, so a view pulled by `relyio generate-types` that named one did not compile.
+ * `@relyio/codegen-typescript`'s `src/__tests__/sdk-definition-config.types.ts` holds the two to each
+ * other (REL-1457).
+ */
+type ViewFilterOperator = 'is' | 'isNot' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'isAnyOf' | 'isNoneOf' | 'includes' | 'notIncludes' | 'isTrue' | 'isFalse' | 'equals' | 'notEquals' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual' | 'between' | 'isOn' | 'isBefore' | 'isAfter' | 'isBetween' | 'inTheLast' | 'inTheNext' | 'today' | 'yesterday' | 'thisWeek' | 'thisMonth' | 'thisYear' | 'isEmpty' | 'hasValue';
+/** A span of time back or forward from now, for `inTheLast` and `inTheNext`. */
+interface ViewFilterRelativeDate {
+    amount: number;
+    unit: 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
+}
+/** What a filter compares against: the schema's `FilterValueSchema`. */
+type ViewFilterValue = string | number | boolean | null | (string | number)[] | {
+    from: string | number | Date;
+    to: string | number | Date;
+} | ViewFilterRelativeDate | Date;
+/**
+ * One filter of a view: a field, an operator and the value it compares with.
+ */
+interface ViewFilterCondition {
+    /**
+     * The Property to filter on, as the Studio's entry list names it: `fields.<id>` for a field your
+     * schema declares (`fields.seo.title` for a field of an object's value), `_metadata.<id>` for a system
+     * field — `_metadata.status`, `_metadata.createdAt`, `_metadata.updatedAt`. So a field called
+     * `status` (`fields.status`) and the entry's own lifecycle (`_metadata.status`) are both
+     * filterable.
+     */
+    field: string;
+    /**
+     * Filter operator
+     */
+    operator: ViewFilterOperator;
+    /**
+     * Filter value (optional for some operators like isEmpty)
+     */
+    value?: ViewFilterValue;
+}
+/**
+ * A view's filter. A view's filters are a flat list joined by AND — the Filters the Studio's entry
+ * list takes, each drawn as a Chip — so there is no filter group: an OR within one field is
+ * `isAnyOf`. RelyIO refuses a group by name when you deploy.
+ */
+type ViewFilter = ViewFilterCondition;
+/**
+ * View definition configuration
+ */
+interface ViewConfig {
+    /**
+     * Display name for the view
+     */
+    name: string;
+    /**
+     * URL-friendly slug for the view, used in Studio URLs like /studio/views/:slug. Absent, the
+     * platform derives one from the id when it reads the schema.
+     */
+    slug?: string;
+    /**
+     * Optional description for the view
+     */
+    description?: string;
+    /**
+     * Icon (emoji or icon name) for the view
+     */
+    icon?: string;
+    /**
+     * Color for the view in the sidebar
+     */
+    color?: string;
+    /**
+     * View scope - what content types this view applies to
+     */
+    scope: ViewScopeConfig;
+    /**
+     * Filter conditions (optional), combined with AND. A flat list: an OR within one field is
+     * `isAnyOf`, and there is no filter group.
+     *
+     * Deploy judges each against the entries the view lists: the field must be one they can be
+     * narrowed by, and it must offer the operator — a boolean field takes `is` with `true` or
+     * `false`, for example, not `isTrue`.
+     */
+    filters?: ViewFilter[];
+    /**
+     * Column field IDs to display (optional)
+     * If not specified, uses default columns
+     */
+    columns?: string[];
+    /**
+     * Metadata field IDs to show under title (max 3)
+     */
+    metadataFields?: string[];
+    /**
+     * Default sort (optional). `field` names the Property to sort by, as a filter names one —
+     * `fields.<id>` or `_metadata.<id>` — and deploy refuses one the view's entries cannot be sorted
+     * by. `columns` and `metadataFields` are display settings and name field IDs as written.
+     */
+    sort?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    /**
+     * Sort order in the sidebar (lower = higher priority)
+     */
+    sortOrder?: number;
+}
+/**
+ * Complete view definition with ID
+ */
+interface ViewDefinition extends ViewConfig {
+    /**
+     * Internal tag for type discrimination
+     */
+    readonly _tag: 'view';
+    /**
+     * Unique view ID (must start with a letter)
+     */
+    readonly id: string;
+}
+/**
+ * Define a schema view
+ *
+ * Views are pre-configured entry list displays with filters,
+ * columns, and metadata settings.
+ *
+ * @example
+ * const featuredPosts = defineView('featuredPosts', {
+ *   name: 'Featured Posts',
+ *   description: 'Blog posts marked as featured',
+ *   icon: '📝',
+ *   scope: { type: 'contentType', contentType: 'post' },
+ *   filters: [
+ *     { field: 'fields.featured', operator: 'is', value: true }
+ *   ],
+ *   columns: ['title', 'author', 'publishedAt'],
+ *   metadataFields: ['category', 'views'],
+ *   sort: { field: '_metadata.publishedAt', direction: 'desc' }
+ * })
+ *
+ * @example
+ * const archivedContent = defineView('archivedContent', {
+ *   name: 'Archived',
+ *   scope: { type: 'all' },
+ *   filters: [
+ *     { field: '_metadata.status', operator: 'is', value: 'archived' }
+ *   ]
+ * })
+ *
+ * @param id - Unique view ID (must start with a letter)
+ * @param config - View configuration
+ * @returns View definition object
+ */
+declare function defineView(id: string, config: ViewConfig): ViewDefinition;
+
+/**
+ * Core type definitions for the RelyIO SDK
+ */
+
+/**
+ * Base interface for all content items
+ * Matches the actual RelyIO API structure with _metadata object
+ */
+interface BaseContent {
+    /**
+     * What the read reports about the entry beside its fields: the committed document's
+     * `EntryMetadata`, and nothing added to it. A `sourceDatasetId` was declared here for an entry
+     * inherited from a linked dataset's source; no read sends one.
+     */
+    _metadata: EntryMetadata;
+}
+/**
+ * Whether `T` declares no field: `BaseContent`, the entry of a client with no schema registered.
+ *
+ * Every input that names fields — a condition, a sort, a selection, a write — takes any name then,
+ * because nothing declares which exist; the API checks them against the deployed schema. Before
+ * REL-1406 only `where` asked, so the others took no field at all from an unregistered client.
+ */
+type DeclaresNoField<T> = [Exclude<keyof T, '_metadata'>] extends [never] ? true : false;
+/**
+ * The value a `where` condition compares a field against: one of the values the field holds.
+ *
+ * Not the field's read type. The REST dialect (`fromRestWhere` in `@relyio/entry-reads`) reads a
+ * bare value as `eq`, an array as `in` and an object as operators — refusing an object with none —
+ * and drops `null`. So a list field (`tags`) is matched by one of its items, a reference by the
+ * target's id, and an object's value or an expanded entry is never a value to send.
+ */
+type WhereScalar<V> = Exclude<V extends readonly (infer Item)[] ? Item : V, null | undefined | object>;
+/** One field's condition: a value (`eq`), a list of values (`in`), or operators. */
+type WhereFieldCondition<V> = WhereScalar<V> | WhereScalar<V>[] | WhereOperator<WhereScalar<V>>;
+/**
+ * Query conditions for filtering content: conditions on the fields the content type declares.
+ *
+ * Typed by the content type's fields where a schema types the client: each key is a declared field
+ * and each value one of that field's values. Untyped (`BaseContent`, which declares no fields), any
+ * field name is accepted — nothing declares which exist.
+ *
+ * Nothing under `_metadata` is a field. This type used to accept `{ _metadata: { status } }`, and
+ * the API filters on no `_metadata` key: measured through a real request (REL-1413), that condition
+ * answered `500 INTERNAL_ERROR` and a dotted `_metadata.status` an empty page. A typed client is now
+ * refused at compile time, and every client before sending (`refuseMetadataConditions`).
+ */
+type WhereClause<T extends BaseContent = BaseContent> = DeclaresNoField<T> extends true ? {
+    [field: string]: unknown;
+} : {
+    [K in Exclude<keyof T, '_metadata'>]?: WhereFieldCondition<T[K]>;
+};
+/**
+ * Query operators for advanced filtering: the REST dialect's spellings (`@relyio/entry-reads`'
+ * `REST_PREFIXED_OPERATOR_TO_ID`). `$regex` was here and is no spelling the API reads: alone it was
+ * refused, beside another operator dropped (REL-2136).
+ */
+interface WhereOperator<T = unknown> {
+    /** Equals */
+    $eq?: T;
+    /** Not equals */
+    $ne?: T;
+    /** Greater than */
+    $gt?: T;
+    /** Greater than or equal */
+    $gte?: T;
+    /** Less than */
+    $lt?: T;
+    /** Less than or equal */
+    $lte?: T;
+    /** In array */
+    $in?: T[];
+    /** Not in array */
+    $nin?: T[];
+    /** Contains (for strings) */
+    $contains?: string;
+    /** Starts with (for strings) */
+    $startsWith?: string;
+    /** Ends with (for strings) */
+    $endsWith?: string;
+    /** Exists (field is not null/undefined) */
+    $exists?: boolean;
+    /**
+     * `true`: the value is empty — no value, or no block or tree holding a reference there; `false`:
+     * it has one. Taken by every path a filter names (REL-2136).
+     */
+    $isNull?: boolean;
+    /**
+     * Within the span back from the moment of the read, both ends included, counted in UTC: `{ amount:
+     * 7, unit: 'days' }`. Asked of a field that holds a date — `date` or `dateTime` — only; the API
+     * refuses it on any other (REL-1817), and a typed read does not offer it there (REL-2195).
+     */
+    $inTheLast?: ViewFilterRelativeDate;
+    /** Within the span forward from the moment of the read, as {@link WhereOperator.$inTheLast}. */
+    $inTheNext?: ViewFilterRelativeDate;
+}
+/** The operators the API asks only of a field that holds a date (`NotADateError` elsewhere). */
+type DateOnlyOperator = '$inTheLast' | '$inTheNext';
+/**
+ * Sort options for query results: by a key `T` declares, or by any field where it declares none.
+ */
+type SortOptions<T extends BaseContent = BaseContent> = {
+    [K in DeclaresNoField<T> extends true ? string : keyof T]?: 'asc' | 'desc';
+};
+/**
+ * Query options for content requests
+ *
+ * `F` is the shape whose fields a condition or a sort names, which is the read's own except for an
+ * asset: its read adds the `file` and `urls` blocks beside the fields, and a condition on those
+ * would name no field — and would make an unregistered asset client refuse every field it was given.
+ */
+interface QueryOptions<T extends BaseContent = BaseContent, F extends BaseContent = T> {
+    /** Conditions to filter by */
+    where?: WhereClause<F>;
+    /** Fields to include in response: any, where nothing declares them */
+    select?: (DeclaresNoField<F> extends true ? string : keyof T)[];
+    /** Related content to include */
+    include?: string[];
+    /** Sort options */
+    sort?: SortOptions<F>;
+    /** Limit number of results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+    /** Cursor for cursor-based pagination */
+    cursor?: string;
+}
+/**
+ * The fields a write sends: the ones the content type declares, as it declares them — or, where
+ * nothing declares any (`BaseContent`, the entry of a client with no schema registered), any field.
+ * The API validates the body against the deployed schema, the only place those names exist.
+ *
+ * `Omit<BaseContent, '_metadata'>` declares no key at all, so before this every write from an
+ * unregistered client — `relyio.content('post').create({ title })`, the SDK without codegen — was
+ * TS2353, and so was every `batch()` operation, whose `content` is untyped for every client.
+ */
+type WriteFields<T extends BaseContent> = DeclaresNoField<T> extends true ? {
+    [field: string]: unknown;
+} : Omit<T, '_metadata'>;
+/**
+ * Content creation input - excludes metadata fields that are managed by the system
+ */
+type CreateInput<T extends BaseContent> = WriteFields<T> & {
+    /** Optional metadata that can be set during creation */
+    _metadata?: {
+        /** Parent ID for hierarchical content */
+        parentId?: string | null;
+        /** Content locale */
+        locale?: string;
+    };
+};
+/**
+ * What a revision answers: the entry, its `_metadata` also listing the entry links other entries
+ * publish that the revision left pointing nowhere — the document's `RevisedEntryMetadata`
+ * (REL-2110, REL-2130). The write is never refused for them; the linking entry's next publish is.
+ */
+type RevisedContent<T extends BaseContent> = Omit<T, '_metadata'> & {
+    _metadata: T['_metadata'] & Pick<components['schemas']['RevisedEntryMetadata'], 'brokenLinks'>;
+};
+/**
+ * What a version restore answers: the entry, its `_metadata` also listing what the restore left out
+ * and the links it left pointing nowhere — the document's `RestoredEntryMetadata` (REL-1793,
+ * REL-2130).
+ */
+type RestoredContent<T extends BaseContent> = Omit<T, '_metadata'> & {
+    _metadata: T['_metadata'] & Pick<components['schemas']['RestoredEntryMetadata'], 'leftOut' | 'brokenLinks'>;
+};
+/**
+ * Content update input - excludes system-managed metadata fields
+ */
+type UpdateInput<T extends BaseContent> = Partial<WriteFields<T>> & {
+    /** Optional metadata that can be updated */
+    _metadata?: {
+        /** Parent ID for hierarchical content */
+        parentId?: string | null;
+        /** Content locale */
+        locale?: string;
+    };
+};
+/**
+ * What the entry list serves — **read from the committed document**, not
+ * written down here.
+ *
+ * It used to be a hand-written `{ items, total?, hasMore, nextCursor }`, and
+ * every field of it was wrong after API2: the route is the cursor dialect, so
+ * the body is `{ data, page: { nextCursor, hasMore } }` and there is no total
+ * at all. `execute()` therefore resolved `result.items` — `undefined` — for
+ * every caller of the SDK's most-used method, and nothing could see it because
+ * the type said otherwise.
+ *
+ * Deriving it means the next dialect change is a compile error in user code
+ * rather than an `undefined` at runtime (`INV-API-CLIENT-IS-DERIVED`).
+ */
+type ContentQueryResult<T extends BaseContent = BaseContent> = Wire<'/v1/{contentType}', 'get', T>;
+/**
+ * A singleton as `GET /v1/singletons/{key}` serves it: its fields at the top level and
+ * `_metadata`, the document's `Singleton` rather than a second declaration of it.
+ */
+type SingletonContent = components['schemas']['Singleton'];
+/**
+ * Custom query definition
+ */
+interface CustomQuery<TVariables = unknown, TResponse = unknown> {
+    /** Query name */
+    name: string;
+    /** Query variables */
+    variables?: TVariables;
+    /** Expected response type */
+    response?: TResponse;
+}
+/**
+ * Content type schema information
+ */
+interface ContentTypeSchema {
+    /** Content type name */
+    name: string;
+    /** Display name */
+    displayName: string;
+    /** Description */
+    description?: string;
+    /** Field definitions */
+    fields: FieldDefinition[];
+    /** Whether this content type is hierarchical */
+    hierarchical?: boolean;
+    /** Preview configuration */
+    preview?: {
+        select?: Record<string, string>;
+        prepare?: (_selection: Record<string, unknown>) => Record<string, unknown>;
+    };
+}
+/**
+ * Field definition for content types
+ */
+interface FieldDefinition {
+    /** Field name */
+    name: string;
+    /** Field type */
+    type: FieldTypeName;
+    /** Display title */
+    title?: string;
+    /** Field description */
+    description?: string;
+    /** Whether field is required */
+    required?: boolean;
+    /** Default value */
+    default?: unknown;
+    /** Validation rules */
+    validation?: ValidationRule[];
+    /** Field options */
+    options?: FieldOptions;
+}
+/**
+ * Supported field type names (string identifiers)
+ */
+type FieldTypeName = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'text' | 'markdown' | 'richtext' | 'slug' | 'url' | 'email' | 'image' | 'file' | 'reference' | 'array' | 'object' | 'geopoint' | 'color';
+/**
+ * Field validation rules
+ */
+interface ValidationRule {
+    /** Rule type */
+    type: 'required' | 'min' | 'max' | 'pattern' | 'custom';
+    /** Rule value */
+    value?: unknown;
+    /** Error message */
+    message?: string;
+}
+/**
+ * Field-specific options
+ */
+interface FieldOptions {
+    /** For array fields */
+    of?: FieldDefinition;
+    /** For reference fields */
+    to?: string | string[];
+    /** For string fields */
+    list?: string[];
+    /** For number fields */
+    min?: number;
+    max?: number;
+    /** For image/file fields */
+    accept?: string[];
+    /** For rich text fields */
+    marks?: string[];
+    blocks?: string[];
+}
+/**
+ * Real-time event types
+ */
+type RealtimeEventType = 'created' | 'updated' | 'deleted' | 'published' | 'unpublished';
+/**
+ * Real-time event payload
+ */
+interface RealtimeEvent<T extends BaseContent = BaseContent> {
+    /** Event type */
+    type: RealtimeEventType;
+    /** Content type */
+    contentType: string;
+    /** Content item (for created/updated events) */
+    item?: T;
+    /** Content ID (for deleted events) */
+    id?: string;
+    /** Timestamp */
+    timestamp: number;
+    /** Event metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Subscription options
+ */
+interface SubscriptionOptions<T extends BaseContent = BaseContent> {
+    /** Content type to subscribe to */
+    contentType: string;
+    /** Filter conditions */
+    where?: WhereClause<T>;
+    /** Events to listen for */
+    events?: RealtimeEventType[];
+    /** Subscription metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Performance metrics
+ */
+interface PerformanceMetrics {
+    /** Request duration in milliseconds */
+    duration: number;
+    /** Request timestamp */
+    timestamp: number;
+    /** Request URL */
+    url: string;
+    /** HTTP method */
+    method: string;
+    /** Response status code */
+    statusCode: number;
+    /** Whether response came from cache */
+    fromCache: boolean;
+    /** Cache hit ratio */
+    cacheHitRatio?: number;
+}
+
 /**
  * Include paths, typed (REL-1801, design decision 12): a read's type follows the paths it names.
  *
@@ -8664,12 +10561,190 @@ type FieldsOfDefinition<D> = D extends {
     readonly fields: readonly unknown[];
 } ? DeclaredFields<D> : never;
 /** `true` when a field is a reference, or a list or object holding one at any depth. */
-type HoldsReference<F> = F extends AnyFieldDefinition ? IsReference<F> extends true ? true : true extends HoldsReference<ShapeFields<F>> ? true : false : false;
+type HoldsReference<F> = F extends AnyFieldDefinition ? IsReference<F> extends true ? true : true extends HoldsReference<ShapeFields<F>> ? true : true extends IsLinkingRichText<F> ? true : false : false;
+type RichTextKind = Extract<FieldType, 'richText'>;
+/** The fields of a rich-text field's declared Blocks and Inline elements (REL-1807). */
+type DeclaredNodeFields<F> = F extends {
+    readonly config?: infer C;
+} ? NonNullable<C> extends {
+    readonly blocks?: ReadonlyArray<infer B>;
+    readonly inline?: ReadonlyArray<infer N>;
+} ? FieldsOfShapes<B | N> : never : never;
+/**
+ * `true` for a rich-text field holding references (REL-1808): its entry links, where it declares
+ * `links`, or a reference among its declared nodes' fields. Such a field is **one** include path —
+ * nothing inside rich text is a path — and including it expands every reference in it.
+ */
+type IsLinkingRichText<F> = F extends {
+    readonly type: RichTextKind;
+    readonly config?: infer C;
+} ? [LinkTargetsIn<NonNullable<C>>] extends [never] ? true extends HoldsReference<DeclaredNodeFields<F>> ? true : false : true : false;
+/**
+ * The fields of every entry a rich-text field's references reach — its entry links' targets and
+ * those of the references its declared nodes declare directly — what a pick or a hop past it names.
+ */
+type RichTextTargetFields<F, S> = F extends {
+    readonly config?: infer C;
+} ? S extends FieldSchemaContext ? FieldsOfDefinition<Declared<S['contentTypes'], RichTextTargets<NonNullable<C>, F>> | Declared<S['singletonContentTypes'], RichTextTargets<NonNullable<C>, F>>> : never : never;
+type RichTextTargets<C, F> = LinkTargetsIn<C> | (Extract<DeclaredNodeFields<F>, {
+    readonly type: ReferenceKind;
+}> extends {
+    readonly config?: infer R;
+} ? ReferenceTarget<NonNullable<R>> : never);
 /**
  * Every path a record can include, below `Prefix`: each reference, and each list or object holding
  * one, then the paths inside it. Distributes over the record's fields.
  */
-type IncludablePaths<Fields, Prefix extends string = ''> = Fields extends AnyFieldDefinition ? IsReference<Fields> extends true ? `${Prefix}${Fields['id']}` : true extends HoldsReference<ShapeFields<Fields>> ? `${Prefix}${Fields['id']}` | IncludablePaths<ShapeFields<Fields>, `${Prefix}${Fields['id']}.`> : never : never;
+type IncludablePaths<Fields, Prefix extends string = ''> = Fields extends AnyFieldDefinition ? IsReference<Fields> extends true ? `${Prefix}${Fields['id']}` : true extends IsLinkingRichText<Fields> ? `${Prefix}${Fields['id']}` : true extends HoldsReference<ShapeFields<Fields>> ? `${Prefix}${Fields['id']}` | IncludablePaths<ShapeFields<Fields>, `${Prefix}${Fields['id']}.`> : never : never;
+type ListKind = Extract<FieldType, 'list'>;
+type ObjectKind = Extract<FieldType, 'object'>;
+type JsonKind = Extract<FieldType, 'json'>;
+/**
+ * The kinds a filter reads as dates, which alone take `$inTheLast` and `$inTheNext`: those whose
+ * field-kind declaration gives a `filter` facet of kind `date`. `__tests__/where-paths.types.ts`
+ * holds the two to one answer, as it does {@link FiltersByValue}.
+ */
+type DateKind = Extract<FieldType, 'date' | 'dateTime'>;
+/**
+ * Whether a filter names a field of each kind by its own value: `true` where `@relyio/schema`'s
+ * field-kind declaration gives the kind a `filter` facet, `false` where it says `NOT_FILTERED`.
+ * Restated as a type, because the declaration object is not rolled into this package's `.d.ts`;
+ * `__tests__/where-paths.types.ts` holds the two to one answer, so a kind whose facet changes fails
+ * to compile there.
+ */
+type FiltersByValue = OverEveryFieldKind<{
+    shortText: true;
+    longText: true;
+    richText: false;
+    table: false;
+    code: false;
+    email: true;
+    url: true;
+    slug: true;
+    integer: true;
+    decimal: true;
+    boolean: true;
+    enum: true;
+    date: true;
+    dateTime: true;
+    reference: true;
+    tags: true;
+    list: false;
+    object: false;
+    json: false;
+}>;
+/**
+ * Whether a field says `localization` the API reads as translated (`isFieldLocalized`): `true`, a
+ * list of locales, or `{ enabled: true }`. A builder keeps what was written (`LocalizedAs`,
+ * REL-2136); a definition whose type does not — one written without a builder, or `LocalizationConfig`
+ * as a whole — reads as shared, which is how the API answers a field that says nothing.
+ */
+type SaysLocalized<F> = [Exclude<LocalizationOf<F>, undefined>] extends [never] ? false : [Exclude<LocalizationOf<F>, undefined>] extends [
+    true | readonly string[] | {
+        readonly enabled: true;
+    }
+] ? true : false;
+/**
+ * Where a value's translation is held, walking a path down from the record: `shared` while no field
+ * on it is translated, `root` once the field at its root is (the whole value, a list's items and all,
+ * held per locale), `deep` once a field below the root is — inside a block, the item-by-item
+ * translation no stored path names.
+ */
+type Translation = 'shared' | 'root' | 'deep';
+/** The translation below field `F`, which `Prefix` reaches, under the translation `T` above it. */
+type TranslationBelow<F, T extends Translation, Prefix extends string> = T extends 'shared' ? true extends SaysLocalized<F> ? Prefix extends '' ? 'root' : 'deep' : 'shared' : T;
+/**
+ * One stored path a field's declaration holds, with what it is to a filter and the condition it
+ * takes. A path several shapes declare is held once by each, and {@link FilterPaths} reads them
+ * together, as the API does.
+ *
+ * - `field`: a value a filter compares, outside every block — at the top level or in an object.
+ * - `reference`: a reference inside a block — named by the API's one path resolver, or, where a
+ *   shared list translates it item by item, by each locale's per-item resolution the write derives
+ *   (`itemRefs`, REL-2134).
+ * - `richText`, `plainRichText`: rich text whose tree a filter asks for the entries it points at —
+ *   one that can point at an entry, or one that cannot.
+ * - `blockValue`: any other value inside a block. `whole`: a list, an object, a table, code, or rich
+ *   text whose tree no stored path names, as a whole. `json`: a json field.
+ */
+interface Held<P extends string, Role extends string, Condition> {
+    readonly path: P;
+    readonly role: Role;
+    readonly condition: Condition;
+}
+/**
+ * A condition on a value that holds no date: {@link WhereFieldCondition} without `$inTheLast` and
+ * `$inTheNext`, which the API asks of a date alone (`NotADateError`, REL-2195).
+ */
+type UndatedCondition<V> = WhereScalar<V> | WhereScalar<V>[] | Omit<WhereOperator<WhereScalar<V>>, DateOnlyOperator>;
+/** A reference, or rich text pointing at entries, compared with an entry id. */
+type EntryIdCondition = UndatedCondition<string>;
+/** What a record's fields hold, path by path, below `Prefix`. Distributes over the fields. */
+type HeldPaths<Fields, S, Prefix extends string = '', InItems extends boolean = false, T extends Translation = 'shared'> = Fields extends AnyFieldDefinition ? HeldBy<Fields, S, `${Prefix}${Fields['id']}`, InItems, T, TranslationBelow<Fields, T, Prefix>> : never;
+type HeldBy<F extends AnyFieldDefinition, S, Path extends string, InItems extends boolean, Above extends Translation, Below extends Translation> = F extends {
+    readonly type: JsonKind;
+} ? Held<Path, 'json', never> : F extends {
+    readonly type: ListKind;
+} ? Held<Path, 'whole', never> | HeldPaths<ShapeFields<F>, S, `${Path}.`, true, Below> : F extends {
+    readonly type: ObjectKind;
+} ? Held<Path, 'whole', never> | HeldPaths<ShapeFields<F>, S, `${Path}.`, InItems, Below> : F extends {
+    readonly type: RichTextKind;
+} ? RichTextNamed<F, InItems, Above, Below> extends true ? Held<Path, true extends IsLinkingRichText<F> ? 'richText' : 'plainRichText', EntryIdCondition> : Held<Path, 'whole', never> : F extends {
+    readonly type: ReferenceKind;
+} ? InItems extends true ? Held<Path, 'reference', EntryIdCondition> : Held<Path, 'field', FieldCondition<F, S>> : F['type'] extends FieldType ? FiltersByValue[F['type']] extends true ? InItems extends true ? Held<Path, 'blockValue', never> : Held<Path, 'field', FieldCondition<F, S>> : Held<Path, 'whole', never> : Held<Path, 'field', unknown>;
+/**
+ * A field's own condition: one of the values it holds (`WhereScalar`), as its read types them — and,
+ * where it holds a date, a span back or forward from the read (`$inTheLast`, `$inTheNext`).
+ */
+type FieldCondition<F extends AnyFieldDefinition, S> = F extends {
+    readonly type: DateKind;
+} ? WhereFieldCondition<FieldValue<F, S extends FieldSchemaContext ? S : undefined>> : UndatedCondition<FieldValue<F, S extends FieldSchemaContext ? S : undefined>>;
+/**
+ * Whether a filter names rich text's trees: shared, translated with the field at the root of the
+ * path, translated itself outside every block, or translated item by item inside a list, which each
+ * locale's per-item resolution names (`itemRefs`, REL-2134) — never translated by an object between
+ * the root and it outside every list, which nothing names (`nameableRichText`).
+ */
+type RichTextNamed<F, InItems extends boolean, Above extends Translation, Below extends Translation> = Below extends 'shared' | 'root' ? true : InItems extends true ? true : Above extends 'shared' ? true extends SaysLocalized<F> ? true : false : false;
+/**
+ * Whether a filter names a path its declarations hold as `Roles` — the API's one filter check
+ * (`assertFilterableInBlocks`, REL-1810, REL-1811, REL-2135), read in its order: a json field
+ * anywhere at the path refuses it; rich text every declaration of which a stored path names, one of
+ * them pointing at entries, is filtered by them; a reference inside a block that no other value there
+ * shares the path with is; outside every block, a value a filter compares is, unless a whole value
+ * shares the path.
+ */
+type Admits<Roles> = 'json' extends Roles ? false : [Roles] extends ['richText' | 'plainRichText'] ? 'richText' extends Roles ? true : false : 'reference' extends Roles ? 'blockValue' extends Roles ? false : true : [Roles] extends ['field'] ? true : false;
+type PathsOf<H> = H extends Held<infer P, string, unknown> ? P : never;
+type RolesAt<H, P extends string> = H extends Held<P, infer Role, unknown> ? Role : never;
+type AdmittedPaths<H, P = PathsOf<H>> = P extends string ? Admits<RolesAt<H, P>> extends true ? P : never : never;
+/**
+ * The conditions a typed read's `where` takes, by path (REL-2136): exactly the keys the API filters
+ * by, each taking the condition the value at it does.
+ *
+ * - A field a filter compares, at the top level or in an object, by its path — `title`,
+ *   `'pricing.basePrice'` — taking one of the values it holds, a list of them, or operators.
+ * - A reference inside a block, at any depth (`'sections.features'`, REL-1810), and rich text that
+ *   can point at an entry, at the top level or inside one (`body`, `'sections.text'`), each compared
+ *   with an entry id: some block or tree points at it.
+ *
+ * And no other key: a json field or a key inside one, a list, an object, a table, code, rich text
+ * that points at nothing, any value inside a block but a reference, a reference or rich text a shared
+ * list translates item by item, or `_metadata` — each refused by the API by name, and here by the
+ * compiler. A read no schema types names any key, and the API holds it to the deployed schema.
+ */
+type FilterPaths<Fields, S> = {
+    [P in AdmittedPaths<HeldPaths<Fields, S>>]?: Extract<HeldPaths<Fields, S>, {
+        readonly path: P;
+    }>['condition'];
+};
+/**
+ * A read's `where`: {@link FilterPaths} where a schema types the read (`R['where']`), and `W`, the
+ * conditions its record's own keys take, where none does.
+ */
+type ReadWhere<W, R> = R extends {
+    readonly where: infer C;
+} ? C : W;
 /** The path part of a written path, and what its parentheses pick. */
 type PathOf<X extends string> = X extends `${infer Path}(${string})` ? Path : X;
 type PickedOf<X extends string> = X extends `${string}(${infer Picked})` ? Picked : never;
@@ -8692,7 +10767,7 @@ type Step<F, Root, S, Segment extends string, Tail extends string, Picked extend
     readonly type: ReferenceKind;
 }>, S>, TargetFields<Extract<F, {
     readonly type: ReferenceKind;
-}>, S>, S, Tail, Picked, `${Done}${Segment}.`, `${Done}${Segment}.`> : true extends HoldsReference<ShapeFields<F>> ? Tail extends '' ? [Picked] extends [never] ? true : Suggest<Root, Entry> : Walk<ShapeFields<F>, Root, S, Tail, Picked, `${Done}${Segment}.`, Entry> : Suggest<Root, Entry>;
+}>, S>, S, Tail, Picked, `${Done}${Segment}.`, `${Done}${Segment}.`> : true extends IsLinkingRichText<F> ? Tail extends '' ? [Picked] extends [never] ? true : CheckPicked<RichTextTargetFields<F, S>, Picked, `${Done}${Segment}`> : Walk<RichTextTargetFields<F, S>, RichTextTargetFields<F, S>, S, Tail, Picked, `${Done}${Segment}.`, `${Done}${Segment}.`> : true extends HoldsReference<ShapeFields<F>> ? Tail extends '' ? [Picked] extends [never] ? true : Suggest<Root, Entry> : Walk<ShapeFields<F>, Root, S, Tail, Picked, `${Done}${Segment}.`, Entry> : Suggest<Root, Entry>;
 /** `true` when every picked field is one the reached entry declares; otherwise each pick it could. */
 type CheckPicked<Target, Picked extends string, Path extends string> = [
     Exclude<Split<Picked>, Target extends AnyFieldDefinition ? Target['id'] : never>
@@ -8740,6 +10815,8 @@ interface UntypedReading<T> extends Reading {
 interface ContentReading<D extends AnyContentTypeDefinition, S extends FieldSchemaContext | undefined> extends Reading {
     readonly read: InferContentType<D, S, this['include']>;
     readonly checked: CheckInclude<FieldsOfDefinition<D>, S, this['path']>;
+    /** What its `where` takes: every key the API filters it by ({@link FilterPaths}, REL-2136). */
+    readonly where: FilterPaths<FieldsOfDefinition<D>, S>;
 }
 /** A read of the singleton `D` defines, in schema `S`. */
 interface SingletonReading<D extends AnySingletonContentTypeDefinition, S extends FieldSchemaContext | undefined> extends Reading {
@@ -8750,6 +10827,12 @@ interface SingletonReading<D extends AnySingletonContentTypeDefinition, S extend
 interface AssetReading<D extends AnyAssetTypeDefinition, S extends FieldSchemaContext | undefined> extends Reading {
     readonly read: InferAssetType<D, S, this['include']>;
     readonly checked: CheckInclude<FieldsOfDefinition<D>, S, this['path']>;
+    /**
+     * What its `where` takes: every key the API filters its fields by, as a content type's
+     * ({@link FilterPaths}) — an asset is an entry on the same routes, held to the same check (REL-2195).
+     * Its `fields` are optional, so they are read with `DeclaredFields`, which takes them so.
+     */
+    readonly where: FilterPaths<DeclaredFields<D>, S>;
 }
 /** A read of the settings group `D` defines, in schema `S`. */
 interface SettingsReading<D extends AnySettingsGroupDefinition, S extends FieldSchemaContext | undefined> extends Reading {
@@ -8757,4 +10840,4 @@ interface SettingsReading<D extends AnySettingsGroupDefinition, S extends FieldS
     readonly checked: CheckInclude<FieldsOfDefinition<D>, S, this['path']>;
 }
 
-export { defineContentType as $, type AnyFieldset as A, type BooleanConfig as B, type CodeConfig as C, type DecimalConfig as D, type EmailConfig as E, type FieldUIConfig as F, type BlockOf as G, type ShapeValue as H, type IntegerConfig as I, type AssetReading as J, type Keyed as K, type LocalizationConfig as L, type CheckedIncludes as M, type CheckInclude as N, type ObjectConfig as O, type ContentReading as P, type IncludablePaths as Q, type RichTextConfig as R, type ShortTextConfig as S, type TableConfig as T, type UrlConfig as U, type ValidationRule as V, type Reading as W, type ReadWith as X, type SettingsReading as Y, type SingletonReading as Z, type UntypedReading as _, type FieldAIConfig as a, fieldset as a0, type Fieldset as a1, type FieldMember as a2, type ContentTypeConfig as a3, type ContentTypeDefinition as a4, type EntryMetadata as a5, type InferContentType as a6, type LocalePublicationFields as a7, defineSingletonContentType as a8, defineSingleton as a9, type VideoCaptionsConfig as aA, type VideoDownloadConfig as aB, type VideoWatermarkConfig as aC, type FileUploadConfig as aD, type FileScanConfig as aE, defineWorkflow as aF, defineWorkflowStage as aG, defineContentTypeWorkflow as aH, isWorkflowDefinition as aI, isWorkflowStageDefinition as aJ, getWorkflowStageIds as aK, findWorkflowStage as aL, getNextWorkflowStage as aM, getFirstWorkflowStage as aN, isFinalWorkflowStage as aO, type WorkflowEscalation as aP, type WorkflowAutoAssign as aQ, type WorkflowStageConfig as aR, type WorkflowStageDefinition as aS, type WorkflowConfig as aT, type WorkflowDefinition as aU, type ContentTypeWorkflowConfig as aV, type paths as aW, type components as aX, type CheckedInclude as aY, type SingletonConfig as aa, type SingletonContentTypeDefinition as ab, type SingletonMetadata as ac, type InferSingletonContentType as ad, type InferSingleton as ae, defineSettingsGroup as af, type SettingsGroupConfig as ag, type SettingsGroupDefinition as ah, type SettingsGroupMetadata as ai, type InferSettingsGroup as aj, defineAssetType as ak, type AssetTypeConfig as al, type AssetTypeDefinition as am, type InferAssetType as an, type ImageKindConfig as ao, type VideoKindConfig as ap, type FileKindConfig as aq, type ImageTransform as ar, type ImageFitMode as as, type ImageOutputFormat as at, type ImageUploadConfig as au, type ImageSourceConfig as av, type ImageExifConfig as aw, type VariantDefinition as ax, type VideoUploadConfig as ay, type VideoPosterConfig as az, type FieldRule as b, type FieldDefinition as c, type LongTextConfig as d, type SlugConfig as e, type EnumConfig as f, type DateConfig as g, type DateTimeConfig as h, type ReferenceConfig as i, type TagsConfig as j, type ListConfig as k, type AIConfig as l, type AnyFieldDefinition as m, type AssetAIConfig as n, type BaseFieldConfig as o, type FieldType as p, type ReadOnlyRule as q, type RequirementRule as r, type RuleCondition as s, type RuleConditions as t, type VisibilityRule as u, type FieldSchemaContext as v, type FieldValue as w, type FieldValues as x, type DeclaredFields as y, type UnresolvedEntry as z };
+export { tags as $, type AIConfig as A, type BaseFieldConfig as B, type CodeConfig as C, type DateConfig as D, type EmailConfig as E, type FieldAIConfig as F, email as G, enumField as H, type IntegerConfig as I, type JsonConfig as J, integer as K, type ListConfig as L, json as M, list as N, type ObjectConfig as O, longText as P, object as Q, type ReadOnlyRule as R, type ShortTextConfig as S, type TableConfig as T, type UrlConfig as U, type ValidationRule$1 as V, reference as W, richText as X, shortText as Y, slug as Z, table as _, type AnyFieldDefinition as a, defineWorkflow as a$, url as a0, type FieldSchemaContext as a1, type FieldValue as a2, type FieldValues as a3, type DeclaredFields as a4, type UnresolvedEntry as a5, type Keyed as a6, type BlockOf as a7, type ShapeValue as a8, type AssetReading as a9, type SettingsGroupConfig as aA, type SettingsGroupDefinition as aB, type SettingsGroupMetadata as aC, type InferSettingsGroup as aD, defineAssetType as aE, type AssetTypeConfig as aF, type AssetTypeDefinition as aG, type InferAssetType as aH, type InferAssetEntry as aI, type AssetServedBlocks as aJ, type ImageKindConfig as aK, type VideoKindConfig as aL, type FileKindConfig as aM, type ImageTransform as aN, type ImageFitMode as aO, type ImageOutputFormat as aP, type ImageUploadConfig as aQ, type ImageSourceConfig as aR, type ImageExifConfig as aS, type VariantDefinition as aT, type VideoUploadConfig as aU, type VideoPosterConfig as aV, type VideoCaptionsConfig as aW, type VideoDownloadConfig as aX, type VideoWatermarkConfig as aY, type FileUploadConfig as aZ, type FileScanConfig as a_, type CheckedIncludes as aa, type CheckInclude as ab, type ContentReading as ac, type IncludablePaths as ad, type Reading as ae, type ReadWith as af, type SettingsReading as ag, type SingletonReading as ah, type UntypedReading as ai, defineContentType as aj, fieldset as ak, type Fieldset as al, type FieldMember as am, type ContentTypeConfig as an, type ContentTypeDefinition as ao, type EntryMetadata as ap, type InferContentType as aq, type LocalePublicationFields as ar, defineSingletonContentType as as, defineSingleton as at, type SingletonConfig as au, type SingletonContentTypeDefinition as av, type SingletonMetadata as aw, type InferSingletonContentType as ax, type InferSingleton as ay, defineSettingsGroup as az, type AssetAIConfig as b, type FieldTypeName as b$, defineWorkflowStage as b0, defineContentTypeWorkflow as b1, isWorkflowDefinition as b2, isWorkflowStageDefinition as b3, getWorkflowStageIds as b4, findWorkflowStage as b5, getNextWorkflowStage as b6, getFirstWorkflowStage as b7, isFinalWorkflowStage as b8, type WorkflowEscalation as b9, type LiveWebSocket as bA, type LiveWebSocketConstructor as bB, type ApiPath as bC, type ApiMethod as bD, type ApiSuccessBody as bE, type Wire as bF, matchRoute as bG, type RouteMatch as bH, type MatchRouteOptions as bI, type AssetFileBlock as bJ, type AssetUrls as bK, type BaseContent as bL, type WhereScalar as bM, type WhereFieldCondition as bN, type WhereClause as bO, type WhereOperator as bP, type DateOnlyOperator as bQ, type SortOptions as bR, type QueryOptions as bS, type CreateInput as bT, type RevisedContent as bU, type RestoredContent as bV, type UpdateInput as bW, type ContentQueryResult as bX, type SingletonContent as bY, type CustomQuery as bZ, type ContentTypeSchema as b_, type WorkflowAutoAssign as ba, type WorkflowStageConfig as bb, type WorkflowStageDefinition as bc, type WorkflowConfig as bd, type WorkflowDefinition as be, type ContentTypeWorkflowConfig as bf, defineView as bg, type ViewScopeConfig as bh, type ContentTypeScopeConfig as bi, type ContentTypesScopeConfig as bj, type EntryTypeScopeConfig as bk, type AllScopeConfig as bl, type ViewFilterOperator as bm, type ViewFilterValue as bn, type ViewFilterRelativeDate as bo, type ViewFilterCondition as bp, type ViewFilter as bq, type ViewConfig as br, type ViewDefinition as bs, type InferJsonSchema as bt, type JsonFieldValue as bu, type JsonSchema as bv, type JsonValue as bw, SDKError as bx, type RelyIOConfig as by, type RelyIOConfigUpdate as bz, type BooleanConfig as c, type ValidationRule as c0, type FieldOptions as c1, type RealtimeEventType as c2, type RealtimeEvent as c3, type SubscriptionOptions as c4, type PerformanceMetrics as c5, type CacheConfig as c6, type RealtimeConfig as c7, type DebugConfig as c8, type RequestConfig as c9, type ApiResponse as ca, type RetryConfig as cb, type CacheStrategy as cc, type LogLevel as cd, type Environment as ce, type ValidationViolation as cf, BaseValidationError as cg, ValidationError as ch, InvalidPayloadError as ci, type MergedRelyIOConfig as cj, type PathParamsOf as ck, type ReadWhere as cl, type CheckedInclude as cm, type components as cn, type paths as co, type FieldDefinition as cp, type DateTimeConfig as d, type DecimalConfig as e, type EnumConfig as f, type FieldDefinition$1 as g, type FieldRule as h, type FieldType as i, type FieldUIConfig as j, type LocalizationConfig as k, type LongTextConfig as l, type ReferenceConfig as m, type RequirementRule as n, type RichTextConfig as o, type RichTextLinks as p, type RuleCondition as q, type RuleConditions as r, type SlugConfig as s, type TagsConfig as t, type VisibilityRule as u, boolean as v, code as w, date as x, dateTime as y, decimal as z };