@relyio/sdk 0.6.0 → 0.7.0

package/dist/{index-yPbhZc6q.d.ts → define-content-type-DiVpbwNs.d.ts}

@@ -1,5 +1,3 @@
-import { P as EntryMetadata } from './define-content-type-CDB3kyeA.js';
-
 /**
  * Generated by scripts/emit-openapi-types.mjs from @relyio/api's committed
  * openapi-spec.json. Do not edit: run `pnpm codegen:openapi` in this package, which
@@ -237,7 +235,11 @@ interface paths {
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /**
+         * Read a file binding's upload status
+         * @description Where the binding's upload got to — `status` and `processing` (stage, progress, error) — whatever the asset entry is published in. Takes the capability the upload routes take, so a key that could have uploaded the file can see whether it failed; the entry itself is read through the key's own lens.
+         */
+        get: operations['getFileStatus'];
         put?: never;
         post?: never;
         /** Delete a file binding */
@@ -837,6 +839,111 @@ interface paths {
 }
 interface components {
     schemas: {
+        /** @description An asset entry’s `file`: the binary’s lifecycle and what was read from it, at the locale the entry’s fields were composed for. Sent beside the asset’s fields on every read of it, with `urls` once `status` is `ready`. How storage addresses the bytes is not part of it. */
+        AssetFile: {
+            /**
+             * @description Where the binary is: `pending_upload` before any bytes, `uploading` once presigned, `processing` once the pipeline has it, then `ready` or `failed`. Independent of the entry’s publication.
+             * @enum {string}
+             */
+            status: 'failed' | 'pending_upload' | 'processing' | 'ready' | 'uploading';
+            /**
+             * @description `r2` for image and file kinds, `stream` for video.
+             * @enum {string}
+             */
+            backend: 'r2' | 'stream';
+            fileName: string;
+            mimeType?: string | null;
+            /** @description In bytes. */
+            size?: number | null;
+            /** @description The SHA-256 the client declared: advisory, for duplicate detection only. */
+            hash?: string | null;
+            /**
+             * @description Enforced by the delivery gateway; a `protected` or `private` URL carries a token.
+             * @enum {string}
+             */
+            visibility: 'private' | 'protected' | 'public';
+            /** @description What was read from the file. Enrichment adds keys as its stages finish, so the object is open beyond the ones named here. */
+            extracted?: {
+                width?: number;
+                height?: number;
+                format?: string;
+                duration?: number;
+                hasAlpha?: boolean;
+                isAnimated?: boolean;
+                orientation?: number;
+                placeholder?: string;
+                dominantColor?: string;
+                palette?: string[];
+                exif?: {
+                    [key: string]: unknown;
+                };
+                video?: {
+                    codec?: string;
+                    bitrate?: number;
+                    framerate?: number;
+                    audioTracks?: unknown[];
+                } & {
+                    [key: string]: unknown;
+                };
+                pageCount?: number;
+                text?: string;
+                safety?: {
+                    nsfwScore?: number;
+                    flagged?: boolean;
+                    categories?: string[];
+                } & {
+                    [key: string]: unknown;
+                };
+            } & {
+                [key: string]: unknown;
+            };
+            /** @description The smart-crop anchor, each axis `0`–`1`. */
+            focalPoint?: {
+                x: number;
+                y: number;
+            };
+            /** @description Where metadata enrichment got to. Independent of `status`. */
+            enrichment?: {
+                /** @enum {string} */
+                status: 'complete' | 'failed' | 'partial' | 'pending' | 'running';
+            };
+            /** @description The malware scan of a file-kind binding. */
+            scan?: {
+                /** @enum {string} */
+                status: 'clean' | 'error' | 'infected' | 'pending' | 'skipped';
+            };
+            processing?: components['schemas']['AssetFileProcessing'];
+            /** @description Whether a video can be played yet. */
+            playback?: {
+                ready?: boolean;
+            };
+        };
+        /** @description Where the pipeline got to with a file, and why it failed. Present when the pipeline recorded a stage, a progress or an error. */
+        AssetFileProcessing: {
+            /** @description The stage the pipeline last recorded. */
+            stage?: string;
+            /** @description How far the pipeline got, `0`–`100`, where it reports that (video encoding). */
+            progress?: number;
+            /** @description Why the file failed. Present exactly while `status` is `failed`. */
+            error?: {
+                /** @description The reason, e.g. `UNSUPPORTED_MIME`, `UPLOAD_TOO_LARGE` or `INTERNAL`. */
+                code?: string;
+                message?: string;
+                /** @description `true` only for `INTERNAL`, a failure no property of the file caused. */
+                retriable?: boolean;
+            };
+        };
+        /** @description One distinct value of the field, and the entry it was first found in. */
+        AutocompleteSuggestion: {
+            /** @description The suggested value. */
+            text: string;
+            /** @description The best relevance among the entries holding it. */
+            score: number;
+            /** @description An entry holding the value. */
+            id: string;
+            /** @description The value with its matched part wrapped in `<em>`, when Atlas highlighted it. */
+            highlight?: string;
+        };
         /** @description One change to one entry, ids only. Refetch the entry through the ordinary read path to see it. */
         Change: {
             entryId: string;
@@ -852,6 +959,104 @@ 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. */
+        Entry: {
+            _metadata: components['schemas']['EntryMetadata'];
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description One locale an entry has content in. */
+        EntryLocale: {
+            code: string;
+            /** @enum {string} */
+            status: 'archived' | 'draft' | 'published';
+            /** @description That locale’s own version counter. */
+            version: number;
+            /**
+             * Format: date-time
+             * @description When that locale was last published. Absent until it is.
+             */
+            publishedAt?: string;
+        };
+        /** @description What this service reports about an entry beside its fields. */
+        EntryMetadata: {
+            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, sorted. A shared-field draft is listed under the default locale. */
+            draftLocales: string[];
+            /** @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 Whether the shared (non-localized) fields have unpublished changes. */
+            hasDraft: boolean;
+            /** @description Each field whose value came from another locale, mapped to that locale. Absent when none did. */
+            localeFallbacksApplied?: {
+                [key: string]: 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 One outgoing reference. */
+        EntryRef: {
+            /** @description The declaring field’s path — `hero.link` for a reference inside a component. */
+            path: string;
+            /** @description The referenced entry’s id. */
+            entryUid: string;
+        };
         ErrorResponse: {
             error: {
                 /** @enum {string} */
@@ -862,6 +1067,15 @@ interface components {
                 };
             };
         };
+        /** @description Where a binding’s upload got to — its lifecycle and nothing of the entry: no fields, no URL. */
+        FileStatus: {
+            /**
+             * @description Where the binary is: `pending_upload` before any bytes, `uploading` once presigned, `processing` once the pipeline has it, then `ready` or `failed`. Independent of the entry’s publication.
+             * @enum {string}
+             */
+            status: 'failed' | 'pending_upload' | 'processing' | 'ready' | 'uploading';
+            processing?: components['schemas']['AssetFileProcessing'];
+        };
         MultiPayload: {
             results: (components['schemas']['SubSuccess'] | components['schemas']['SubFailure'])[];
             summary: components['schemas']['MultiSummary'];
@@ -1035,6 +1249,213 @@ interface components {
                 };
             };
         };
+        /** @description How a hit’s relevance was reached. Sent on a search that asked for `explain`. */
+        ScoreBreakdown: {
+            keyword: number;
+            semantic: number;
+            combined: number;
+        };
+        /** @description One highlighted match, as Atlas Search reports it: the path it matched on and the text around the match, split into `hit` and `text` runs. */
+        SearchHighlight: {
+            path: string;
+            score: number;
+            texts: ({
+                value: string;
+                /** @enum {string} */
+                type: 'hit' | 'text';
+            } & {
+                [key: string]: unknown;
+            })[];
+        } & {
+            [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`. */
+        SearchHit: {
+            _metadata: components['schemas']['SearchHitMetadata'];
+            /** @description Relevance. Sent on a search that asked for `includeScore`, and on every similar hit. */
+            _score?: number;
+            _scoreBreakdown?: components['schemas']['ScoreBreakdown'];
+            /** @description Sent when the search asked for `highlight` and Atlas matched a highlighted path. */
+            _highlights?: components['schemas']['SearchHighlight'][];
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description What this service reports about a hit beside its fields. Narrower than an entry read’s `EntryMetadata`: a hit is built from the search row, so it carries no `entryType`, `defaultLocale`, `availableLocales`, `refs`, `firstPublishedAt` or version history — read the entry for those. */
+        SearchHitMetadata: {
+            id: string;
+            /** @description The content type. */
+            type: string;
+            /** @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 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, sorted. A shared-field draft is listed under the default locale. */
+            draftLocales: string[];
+            /** @description Whether the shared (non-localized) fields have unpublished changes. */
+            hasDraft: boolean;
+            /**
+             * 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;
+        };
+        /** @description One settings group: its fields at the top level, as the group declares them, and `_metadata`. */
+        SettingsGroup: {
+            _metadata: components['schemas']['SettingsGroupMetadata'];
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description One group on the listing: its fields at the top level — its declared defaults until it is first written — and `_metadata`. */
+        SettingsGroupListing: {
+            _metadata: components['schemas']['SettingsGroupListingMetadata'];
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description The group as the schema declares it, and — once the group has been written — what a single read reports about it, less the version history. */
+        SettingsGroupListingMetadata: {
+            /** @description The group’s name, as the schema declares it. */
+            displayName: string;
+            /** @description The group’s description, when the schema declares one. */
+            description?: string;
+        } | {
+            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 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, sorted. A shared-field draft is listed under the default locale. */
+            draftLocales: string[];
+            /**
+             * Format: date-time
+             * @description When the group was last written.
+             */
+            updatedAt: string;
+            /** @description The group’s name, as the schema declares it. */
+            displayName: string;
+            /** @description The group’s description, when the schema declares one. */
+            description?: string;
+        };
+        /** @description What this service reports about a settings group beside its fields: the group, the per-locale facts and when it was last written. */
+        SettingsGroupMetadata: {
+            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, sorted. A shared-field draft is listed under the default locale. */
+            draftLocales: string[];
+            /**
+             * Format: date-time
+             * @description When the group was last written.
+             */
+            updatedAt: string;
+        };
+        /** @description Every settings group the schema declares, keyed by group id, at the locale the request resolved to. */
+        SettingsGroups: {
+            [key: string]: components['schemas']['SettingsGroupListing'];
+        };
+        /** @description One singleton: its fields at the top level, as the singleton type declares them, and `_metadata`. */
+        Singleton: {
+            _metadata: components['schemas']['SingletonMetadata'];
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description What this service reports about a singleton beside its fields. Narrower than an entry’s: no slug, no default locale, no available locales, no references. */
+        SingletonMetadata: {
+            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, sorted. A shared-field draft is listed under the default locale. */
+            draftLocales: string[];
+            /** @description Whether the shared (non-localized) fields have unpublished changes. */
+            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;
+        };
         SubFailure: {
             index: number;
             id?: string;
@@ -1778,8 +2199,7 @@ interface operations {
                 };
                 content: {
                     'application/json': {
-                        /** @description The payload itself. */
-                        data: unknown;
+                        data: components['schemas']['Entry'];
                     };
                 };
             };
@@ -2156,6 +2576,94 @@ interface operations {
             };
         };
     };
+    getFileStatus: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                contentType: string;
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Success. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': {
+                        data: components['schemas']['FileStatus'];
+                    };
+                };
+            };
+            /** @description CONTENT_INVALID, REQUEST_INVALID */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalContentInvalidOrRequestInvalid'];
+                };
+            };
+            /** @description INVALID_API_KEY, MISSING_API_KEY */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalInvalidApiKeyOrMissingApiKey'];
+                };
+            };
+            /** @description ACCESS_DENIED, PLAN_FEATURE_UNAVAILABLE, READ_ONLY_KEY, USAGE_QUOTA_EXCEEDED */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalAccessDeniedOrPlanFeatureUnavailableOrReadOnlyKeyOrUsageQuotaExceeded'];
+                };
+            };
+            /** @description RESOURCE_NOT_FOUND */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalResourceNotFound'];
+                };
+            };
+            /** @description RATE_LIMIT_EXCEEDED */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalRateLimitExceeded'];
+                };
+            };
+            /** @description INTERNAL_ERROR */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalInternalError'];
+                };
+            };
+            /** @description SERVICE_INDETERMINATE */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    'application/json': components['schemas']['RefusalServiceIndeterminate'];
+                };
+            };
+        };
+    };
     deleteFileBinding: {
         parameters: {
             query?: never;
@@ -4455,7 +4963,7 @@ interface operations {
                 };
                 content: {
                     'application/json': {
-                        data: unknown[];
+                        data: components['schemas']['SearchHit'][];
                         page: components['schemas']['OffsetPage'];
                         meta: {
                             [key: string]: unknown;
@@ -4546,7 +5054,7 @@ interface operations {
                 };
                 content: {
                     'application/json': {
-                        data: unknown[];
+                        data: components['schemas']['AutocompleteSuggestion'][];
                         page: components['schemas']['OffsetPage'];
                         meta: {
                             [key: string]: unknown;
@@ -4628,7 +5136,7 @@ interface operations {
                 };
                 content: {
                     'application/json': {
-                        data: unknown[];
+                        data: components['schemas']['SearchHit'][];
                         page: components['schemas']['OffsetPage'];
                         meta: {
                             [key: string]: unknown;
@@ -4721,8 +5229,7 @@ interface operations {
                 };
                 content: {
                     'application/json': {
-                        /** @description The payload itself. */
-                        data: unknown;
+                        data: components['schemas']['SettingsGroups'];
                     };
                 };
             };
@@ -4805,8 +5312,7 @@ interface operations {
                 };
                 content: {
                     'application/json': {
-                        /** @description The payload itself. */
-                        data: unknown;
+                        data: components['schemas']['SettingsGroup'];
                     };
                 };
             };
@@ -5381,8 +5887,7 @@ interface operations {
                 };
                 content: {
                     'application/json': {
-                        /** @description The payload itself. */
-                        data: unknown;
+                        data: components['schemas']['Singleton'];
                     };
                 };
             };
@@ -5828,779 +6333,1205 @@ interface operations {
 }
 
 /**
- * Where the SDK's transport gets its truth.
- *
- * 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.
- *
- * 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:
- *
- * - 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.
+ * Field type definitions matching @relyio/schema package
  *
- * Spec: `devtools/docs/guide/engineering/api-contract-spec.md`,
- * `INV-API-CLIENT-IS-DERIVED`.
+ * Every config option here is spelled as `@relyio/schema`'s field config schema spells it, because
+ * the CLI sends a field's `config` to deploy verbatim, and deploy — and `relyio validate` before it —
+ * refuses an option the field's type does not declare, naming its path (REL-1480). This package does
+ * not depend on `@relyio/schema`, so the
+ * options are pinned from `@relyio/codegen-typescript`, which depends on both: its
+ * `src/__tests__/sdk-field-config.types.ts` fails to compile when a key, whether it is required, or
+ * the values it accepts differs between the two (REL-1408).
  */
-
-/** 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`.
+ * AI configuration. A single prompt — `instructions` — describes what the
+ * element is and how AI should produce its value. Attaches to fields, content
+ * types, components, fieldsets, and (extended) asset types.
  *
- * 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.
+ * @example
+ * ```typescript
+ * fields.richText('body', {
+ *   ai: {
+ *     instructions: `
+ *       Write in a conversational tone.
+ *       Use short paragraphs (2-3 sentences).
+ *       Target grade 8 reading level.
+ *     `
+ *   }
+ * })
+ * ```
  */
-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 {
+interface AIConfig {
     /**
-     * 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`.
+     * AI brief for this element: what it should contain and how to produce it.
+     *
+     * Used by the Studio authoring agent and — on asset types with
+     * `ai.autoGenerate` — by the automatic post-upload run.
+     *
+     * The fallback chain for AI guidance is:
+     * 1. ai.instructions (most specific)
+     * 2. ui.description (general field description)
+     * 3. Field displayName + type (inferred from semantics)
      */
-    baseUrl?: string;
+    instructions?: 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.
+ * Field-level AI config. `inputs` names the fields this instruction reads.
+ * Unknown ids and cycles are refused when the schema is parsed.
  */
-declare function matchRoute(url: string | URL, options?: MatchRouteOptions): RouteMatch | null;
-
+interface FieldAIConfig extends AIConfig {
+    /** Field ids this instruction reads. Never inferred from instruction text. */
+    inputs?: string[];
+}
 /**
- * Configuration types for the RelyIO SDK
+ * Asset-type AI configuration. Extends {@link AIConfig} with `autoGenerate`,
+ * the single switch that turns on automatic field generation after upload.
  */
-
-interface RelyIOConfig {
+interface AssetAIConfig extends AIConfig {
     /**
-     * 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.
+     * Master switch for automatic, post-upload field generation. When `true`, the
+     * derived analysis agent fills every field that declares `ai.instructions`,
+     * applied as a review proposal. Only meaningful for image asset types in v1.
      */
-    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;
-    /** Request timeout in milliseconds (defaults to 30000) */
-    timeout?: number;
-    /** Number of retry attempts for failed requests (defaults to 3) */
-    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;
-    /** 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;
+    autoGenerate?: boolean;
 }
-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 BaseFieldConfig {
+    /** Whether the field is required */
+    required?: boolean;
+    /** Whether the field value must be unique */
+    unique?: boolean;
+    /** Default value for the field. Each field type narrows it to the values its schema accepts. */
+    defaultValue?: unknown;
 }
-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 FieldUIConfig {
+    /** Display name shown in the UI */
+    displayName: string;
+    /** Field description/help text */
+    description?: string;
+    /** Widget-specific options */
+    options?: Record<string, unknown>;
 }
-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;
+interface RuleCondition {
+    field: string;
+    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'is_empty' | 'is_not_empty';
+    value?: unknown;
+}
+interface RuleConditions {
+    mode: 'all' | 'any' | 'none';
+    conditions: RuleCondition[];
+}
+interface VisibilityRule {
+    type: 'visibility';
+    action: 'show' | 'hide';
+    conditions: RuleConditions;
+}
+interface RequirementRule {
+    type: 'requirement';
+    action: 'require' | 'optional';
+    conditions: RuleConditions;
+}
+interface ValidationRule {
+    type: 'validation';
+    action: 'validate' | 'skip';
+    message?: string;
+    conditions: RuleConditions;
+}
+interface ReadOnlyRule {
+    type: 'readOnly';
+    action: 'enable' | 'disable';
+    conditions: RuleConditions;
+}
+type FieldRule = VisibilityRule | RequirementRule | ValidationRule | ReadOnlyRule;
+type LocalizationConfig = boolean | string[] | {
+    enabled: boolean;
+    requiredLocales?: string[];
+    fallback?: boolean;
+};
+interface FieldDefinition<TId extends string = string, TType extends string = string, TConfig = unknown> {
+    /** Unique field identifier - preserves literal type for type inference */
+    readonly id: TId;
+    /** Field type */
+    readonly type: TType;
+    /** Type-specific configuration */
+    config?: TConfig;
+    /** UI display configuration */
+    ui?: FieldUIConfig;
+    /** AI configuration: generation/review guidance for this field */
+    ai?: FieldAIConfig;
+    /** Dynamic field rules */
+    rules?: FieldRule[];
+    /** Localization settings */
+    localization?: LocalizationConfig;
+    /** Fallback value when field is empty */
+    fallback?: unknown;
+    /** Whether this field is deprecated */
+    deprecated?: boolean;
 }
 /**
- * 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`).
+ * Any field definition - used in arrays where we need to preserve specific field types
  */
-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;
+type AnyFieldDefinition = FieldDefinition<string, string, unknown>;
+interface ShortTextConfig extends BaseFieldConfig {
+    /** Maximum character length */
+    maxLength?: number;
+    /** Regex pattern for validation */
+    pattern?: string;
+    defaultValue?: string;
 }
-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 LongTextConfig extends BaseFieldConfig {
+    minLength?: number;
+    maxLength?: number;
+    defaultValue?: string;
 }
-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 RichTextConfig extends BaseFieldConfig {
+    /** Maximum character length for the rich text content */
+    maxLength?: number;
+    /** Allowed formatting options (e.g., bold, italic, underline) */
+    allowedFormats?: string[];
+    /** Allowed embed types (e.g., image, video, code) */
+    embedTypes?: string[];
+    defaultValue?: string;
 }
-interface BrowserConfig {
-    /**
-     * Whether requests the client sends from a web page carry the browser's cookies to another
-     * origin (defaults to `true`).
-     *
-     * `true` sends every request with `credentials: 'include'`. `false` sends it 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. The RelyIO
-     * API authenticates with your API key and reads no cookie, so `false` changes nothing it
-     * answers.
-     *
-     * Applied only where `window` exists. 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;
+interface SlugConfig extends BaseFieldConfig {
+    /** Source field to generate slug from */
+    sourceField?: string;
+    /** Maximum character length */
+    maxLength?: number;
+    defaultValue?: string;
+}
+interface UrlConfig extends BaseFieldConfig {
+    /** Allowed URL protocols */
+    allowedProtocols?: ('http' | 'https' | 'ftp' | 'ftps')[];
+    /** Maximum character length */
+    maxLength?: number;
+    defaultValue?: string;
+}
+interface EmailConfig extends BaseFieldConfig {
+    /** Maximum character length */
+    maxLength?: number;
+    /** Whitelist of allowed email domains */
+    domainWhitelist?: string[];
+    defaultValue?: string;
+}
+interface IntegerConfig extends BaseFieldConfig {
+    min?: number;
+    max?: number;
+    defaultValue?: number;
+}
+interface DecimalConfig extends BaseFieldConfig {
+    min?: number;
+    max?: number;
+    decimalPlaces?: number;
+    roundingMode?: 'HALF_UP' | 'FLOOR' | 'CEILING' | 'ROUND' | 'TRUNCATE';
+    defaultValue?: number;
+}
+interface BooleanConfig extends BaseFieldConfig {
+    /** The editor's word for `true` (e.g. `'Published'`). */
+    labelTrue?: string;
+    /** The editor's word for `false` (e.g. `'Draft'`). */
+    labelFalse?: string;
+    defaultValue?: boolean;
 }
-type CacheStrategy = 'memory' | 'persistent' | 'network-first' | 'cache-first' | 'stale-while-revalidate';
-type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-type Environment = 'development' | 'staging' | 'production';
 /**
- * `fetch` stays optional after the merge: absent means the runtime's own, and
- * that is read per request rather than captured here, so no default value
- * stands in for it.
+ * `TValue` is the union of the option values and `TMulti` whether the field holds a list of them.
+ * `fields.enum()` infers both from the declaration, so a read of the field is typed by its options
+ * (`INV-SS-TYPES-INFERRED`); the defaults describe any enum field.
  */
-type MergedRelyIOConfig = Required<Omit<RelyIOConfig, 'dataset' | 'locale' | 'dev' | 'fetch'>> & Pick<RelyIOConfig, 'dataset' | 'locale' | 'dev' | 'fetch'>;
-
+interface EnumConfig<TValue extends string = string, TMulti extends boolean = boolean> extends BaseFieldConfig {
+    /** The values the field may hold, each with the `label` an editor shows. Deploy refuses an option without one. */
+    options: Array<{
+        value: TValue;
+        label: string;
+    }>;
+    multi?: TMulti;
+    /** One option's value, or a list of them when `multi` is true. */
+    defaultValue?: string | string[];
+}
+/** A display format is not config: it is `ui.options.format`, where the schema declares it. */
+interface DateConfig extends BaseFieldConfig {
+    minDate?: string;
+    maxDate?: string;
+    /** `YYYY-MM-DD` */
+    defaultValue?: string;
+}
+/** A display format is not config: it is `ui.options.format`, where the schema declares it. */
+interface DateTimeConfig extends BaseFieldConfig {
+    minDateTime?: string;
+    maxDateTime?: string;
+    /** Store the instant in UTC (`'UTC'`), or keep the author's local time (`'local'`). */
+    timeZoneHandling?: 'UTC' | 'local';
+    defaultValue?: string;
+}
 /**
- * Base error class for all RelyIO SDK errors
- * Provides consistent error handling, context tracking, and retry logic
+ * `TTo` is the union of the target type ids and `TMulti` whether the field holds a list.
+ * `fields.reference()` infers both, so a read of the field is typed by what it points at
+ * (`INV-SS-TYPES-INFERRED`); the defaults describe any reference field.
  */
-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;
+interface ReferenceConfig<TTo extends string = string, TMulti extends boolean = boolean> extends BaseFieldConfig {
     /**
-     * Create a new error with additional context
+     * Target entry type id(s) — content type or asset type ids. Pass a single id
+     * for one target or an array for several. All ids must belong to the same
+     * family (all content types or all asset types).
      */
-    withContext(context: Record<string, unknown>): this;
+    to: TTo | TTo[];
+    /** Allow multiple references (the field value is a list). */
+    multi?: TMulti;
+    /** Reference strength for publish/unpublish behavior. */
+    referenceStrength?: 'strong' | 'weak';
+    /** Behavior when a referenced entry is deleted. */
+    onTargetDelete?: 'block' | 'nullify';
+    /** A target entry's id, or a list of them when `multi` is true. */
+    defaultValue?: string | string[];
 }
+interface TagsConfig extends BaseFieldConfig {
+    allowCustom?: boolean;
+    predefinedTags?: string[];
+    maxTags?: number;
+}
+/**
+ * `TSubfields` is the declared subfields, which `fields.list()` infers so a read types each item by
+ * them (`INV-SS-TYPES-INFERRED`); the default describes any list field.
+ */
+interface ListConfig<TSubfields extends readonly AnyFieldDefinition[] = FieldDefinition[]> extends BaseFieldConfig {
+    dragAndDrop?: boolean;
+    minItems?: number;
+    maxItems?: number;
+    /** Subfields for list items */
+    subfields?: TSubfields;
+}
+/**
+ * A component field's config: the options every field type takes, and no more — what the schema
+ * declares for a `component(<id>)` field, which has no config of its own. The validation document
+ * reads `required` from it as it does from any field's.
+ */
+type ComponentFieldConfig = BaseFieldConfig;
+type FieldType = 'shortText' | 'longText' | 'richText' | 'slug' | 'url' | 'email' | 'integer' | 'decimal' | 'boolean' | 'enum' | 'date' | 'dateTime' | 'reference' | 'tags' | 'list';
+type ComponentFieldType = `component(${string})`;
+type AllFieldTypes = FieldType | ComponentFieldType;
 
 /**
- * Validation errors and related interfaces
+ * 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',
+ *       requiredApprovals: 1,
+ *       allowedRoles: ['legal-reviewer']
+ *     }),
+ *     defineWorkflowStage('final-approval', {
+ *       displayName: 'Final Approval',
+ *       requiredApprovals: 2,
+ *       allowedRoles: ['publisher', 'admin']
+ *     })
+ *   ]
+ * })
  */
-interface ValidationViolation {
-    field: string;
-    message: string;
-    code: string;
-    value?: unknown;
-    path?: string[];
+/**
+ * Escalation configuration when a workflow stage times out
+ */
+interface WorkflowEscalation {
+    /** Roles to notify when stage times out */
+    notifyRoles?: string[];
+    /** Roles to escalate to if still pending after another timeout period */
+    escalateToRoles?: 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;
+/**
+ * Auto-assignment configuration for workflow stages
+ */
+interface WorkflowAutoAssign {
+    /** Roles whose users should be notified when content enters this stage */
+    roles: string[];
 }
-declare class ValidationError extends BaseValidationError {
-    readonly code = "VALIDATION_ERROR";
+/**
+ * Workflow stage configuration
+ */
+interface WorkflowStageConfig {
+    /** Human-readable name shown in Studio */
+    displayName: string;
+    /** Optional description for reviewers */
+    description?: string;
+    /** Number of approvals needed to pass this stage (default: 1) */
+    requiredApprovals?: number;
+    /** Roles that can approve this stage */
+    allowedRoles?: string[];
+    /** Auto-assignment configuration */
+    autoAssign?: WorkflowAutoAssign;
+    /** Days before escalation triggers (optional) */
+    timeoutDays?: number;
+    /** Escalation configuration when stage times out */
+    escalation?: WorkflowEscalation;
 }
-declare class InvalidPayloadError extends BaseValidationError {
-    readonly code = "INVALID_PAYLOAD";
-    constructor(message?: string, violations?: ValidationViolation[], cause?: Error, context?: Record<string, unknown>);
-    getUserMessage(): string;
+/**
+ * Complete workflow stage definition
+ */
+interface WorkflowStageDefinition {
+    readonly _tag: 'workflowStage';
+    readonly id: string;
+    readonly displayName: string;
+    readonly description?: string;
+    /** Absent means the schema's default of 1 */
+    readonly requiredApprovals?: number;
+    readonly allowedRoles?: string[];
+    readonly autoAssign?: WorkflowAutoAssign;
+    readonly timeoutDays?: number;
+    readonly escalation?: WorkflowEscalation;
 }
-declare class SchemaValidationError extends BaseValidationError {
-    readonly code = "SCHEMA_VALIDATION_ERROR";
-    constructor(message?: string, violations?: ValidationViolation[], cause?: Error);
-    getUserMessage(): string;
+/**
+ * Workflow configuration
+ */
+interface WorkflowConfig {
+    /** Enable/disable workflow for the branch (default: false) */
+    enabled?: boolean;
+    /** Array of approval stage definitions */
+    stages?: WorkflowStageDefinition[];
 }
-declare class RequiredFieldError extends BaseValidationError {
-    readonly code = "REQUIRED_FIELD_ERROR";
-    constructor(fieldName: string, message?: string, cause?: Error);
-    getUserMessage(): string;
+/**
+ * Complete workflow definition
+ */
+interface WorkflowDefinition {
+    readonly _tag: 'workflow';
+    /** Absent means the schema's default, disabled */
+    readonly enabled?: boolean;
+    readonly stages?: WorkflowStageDefinition[];
 }
-declare class InvalidFieldTypeError extends BaseValidationError {
-    readonly code = "INVALID_FIELD_TYPE";
-    constructor(fieldName: string, expectedType: string, actualType: string, value?: unknown, cause?: Error);
-    getUserMessage(): string;
+/**
+ * Per-content-type workflow configuration
+ */
+interface ContentTypeWorkflowConfig {
+    /** Enable workflow for this content type (inherits from global if not set) */
+    enabled?: boolean;
+    /** Which global stages apply to this content type (subset of global stages) */
+    stages?: string[];
+    /** Publish automatically after all stages are approved */
+    autoPublish?: boolean;
+    /** Require all locales to be approved before publishing */
+    requireAllLocales?: boolean;
 }
+/**
+ * Define a workflow stage
+ *
+ * @param id - Unique identifier for the stage (kebab-case or camelCase)
+ * @param config - Stage configuration
+ *
+ * @example
+ * const editorialReview = defineWorkflowStage('editorial-review', {
+ *   displayName: 'Editorial Review',
+ *   description: 'Content quality and style check',
+ *   requiredApprovals: 1,
+ *   allowedRoles: ['editor', 'senior-editor']
+ * })
+ *
+ * @example
+ * // Stage with auto-assignment and timeout
+ * const legalApproval = defineWorkflowStage('legal-approval', {
+ *   displayName: 'Legal Approval',
+ *   allowedRoles: ['legal-reviewer'],
+ *   autoAssign: { roles: ['legal-reviewer'] },
+ *   timeoutDays: 3,
+ *   escalation: {
+ *     notifyRoles: ['legal-reviewer'],
+ *     escalateToRoles: ['admin']
+ *   }
+ * })
+ */
+declare function defineWorkflowStage(id: string, config: WorkflowStageConfig): WorkflowStageDefinition;
+/**
+ * Define a workflow configuration
+ *
+ * @param config - Workflow configuration with enabled flag and stages
+ *
+ * @example
+ * // Simple workflow
+ * const workflow = defineWorkflow({
+ *   enabled: true,
+ *   stages: [
+ *     defineWorkflowStage('review', {
+ *       displayName: 'Review',
+ *       allowedRoles: ['editor']
+ *     })
+ *   ]
+ * })
+ *
+ * @example
+ * // Disabled workflow (direct publish)
+ * const workflow = defineWorkflow({
+ *   enabled: false
+ * })
+ */
+declare function defineWorkflow(config: WorkflowConfig): WorkflowDefinition;
+/**
+ * Define content-type specific workflow configuration
+ *
+ * @param config - Content type workflow configuration
+ *
+ * @example
+ * // Use specific stages from global workflow
+ * const blogPostWorkflow = defineContentTypeWorkflow({
+ *   enabled: true,
+ *   stages: ['editorial-review', 'final-approval'], // Skip legal
+ *   autoPublish: false
+ * })
+ *
+ * @example
+ * // Disable workflow for this content type
+ * const quickUpdateWorkflow = defineContentTypeWorkflow({
+ *   enabled: false
+ * })
+ *
+ * @example
+ * // Require all locales to be approved
+ * const marketingPageWorkflow = defineContentTypeWorkflow({
+ *   enabled: true,
+ *   stages: ['translation-review', 'regional-approval'],
+ *   requireAllLocales: true
+ * })
+ */
+declare function defineContentTypeWorkflow(config: ContentTypeWorkflowConfig): ContentTypeWorkflowConfig;
+/**
+ * Check if a value is a workflow stage definition
+ */
+declare function isWorkflowStageDefinition(value: unknown): value is WorkflowStageDefinition;
+/**
+ * Check if a value is a workflow definition
+ */
+declare function isWorkflowDefinition(value: unknown): value is WorkflowDefinition;
+/**
+ * Get all stage IDs from a workflow definition
+ */
+declare function getWorkflowStageIds(workflow: WorkflowDefinition): string[];
+/**
+ * Find a stage by ID in a workflow definition
+ */
+declare function findWorkflowStage(workflow: WorkflowDefinition, stageId: string): WorkflowStageDefinition | undefined;
+/**
+ * Get the next stage after a given stage ID (null if last stage)
+ */
+declare function getNextWorkflowStage(workflow: WorkflowDefinition, currentStageId: string): WorkflowStageDefinition | null;
+/**
+ * Get the first stage in the workflow (null if no stages)
+ */
+declare function getFirstWorkflowStage(workflow: WorkflowDefinition): WorkflowStageDefinition | null;
+/**
+ * Check if a stage is the final stage in the workflow
+ */
+declare function isFinalWorkflowStage(workflow: WorkflowDefinition, stageId: string): boolean;
 
 /**
- * Core type definitions for the RelyIO SDK
+ * Singleton content type definition matching @relyio/schema
+ *
+ * In RelyIO, singletons are just content types with a special flag.
+ * They share the same structure as regular content types.
+ *
+ * Uses advanced TypeScript generics to preserve literal field IDs through
+ * the type system, enabling full autocomplete in SDK methods.
  */
 
 /**
- * Base interface for all content items
- * Matches the actual RelyIO API structure with _metadata object
+ * Type alias for a fieldset with any fields.
  */
-interface BaseContent {
-    /**
-     * RelyIO metadata object containing system fields.
-     *
-     * `EntryMetadata` rather than a second copy of it: this interface and
-     * `schema/define-content-type.ts` declared the same fifteen fields independently, so the
-     * per-locale publication half lived twice inside one package and a field added to one was
-     * silently absent from the other (`INV-LM-PUBLICATION-IS-REPORTED-PER-LOCALE`).
-     */
-    _metadata: EntryMetadata & {
-        /**
-         * Present when the entry is inherited from a source dataset (linked dataset CoW).
-         * If set, this entry was not modified in the linked dataset and comes from the source.
-         */
-        sourceDatasetId?: string;
-    };
+type AnyFieldset$2 = Fieldset<any>;
+/**
+ * What a singleton takes: a content type's settings, since the schema declares a singleton with the
+ * same `ContentTypeSchema` — except `hierarchical`, which is `false` or absent. A singleton is one
+ * entry, with no parent and no children, and deploy refuses `true` for one
+ * (`SINGLETON_CANNOT_BE_HIERARCHICAL`). It used to take a content type's `boolean` and write `false`
+ * whatever it was given.
+ */
+interface SingletonConfigWithFields<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> extends Omit<ContentTypeConfigWithFields<TFields>, 'hierarchical'> {
+    hierarchical?: false;
+}
+/** {@link SingletonConfigWithFields}, with its fields organised into fieldsets. */
+interface SingletonConfigWithFieldsets<TFieldsets extends readonly AnyFieldset$2[] = readonly AnyFieldset$2[]> extends Omit<ContentTypeConfigWithFieldsets<TFieldsets>, 'hierarchical'> {
+    hierarchical?: false;
+}
+/**
+ * Singleton content type definition - preserves field types for inference
+ */
+interface SingletonContentTypeDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset$2[] = readonly AnyFieldset$2[]> {
+    readonly _tag: 'singletonContentType';
+    readonly name: string;
+    readonly displayName: string;
+    readonly displayNamePlural?: string;
+    readonly description?: string;
+    /** AI configuration: generation guidance + entry intelligence */
+    readonly ai?: AIConfig;
+    /** Field ID to use as entry display title */
+    readonly displayField?: string;
+    readonly hierarchical?: false;
+    readonly accessTags?: string[];
+    /** Workflow configuration for this singleton */
+    readonly workflow?: ContentTypeWorkflowConfig;
+    readonly fields?: TFields;
+    readonly fieldsets?: TFieldsets;
 }
 /**
- * The value a `where` condition compares a field against: one of the values the field holds.
+ * Define a singleton content type
+ *
+ * Singletons are single-instance content types like homepage, site settings, etc.
+ * They use the same field structure as regular content types.
  *
- * 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 a component or an expanded entry is never a value to send.
+ * The generic type parameters preserve the literal field IDs through the type
+ * system, enabling autocomplete in SDK methods.
+ *
+ * @example
+ * const homepage = defineSingletonContentType('homepage', {
+ *   displayName: 'Homepage',
+ *   fields: [
+ *     fields.shortText('heroTitle', { config: { required: true } }),
+ *     fields.reference('heroImage', { config: { to: 'productPhoto' } }), // an asset type's entry
+ *   ]
+ * })
  */
-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>>;
+declare function defineSingletonContentType<TFields extends readonly AnyFieldDefinition[], _TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: SingletonConfigWithFields<TFields>): SingletonContentTypeDefinition<TFields, readonly []>;
+declare function defineSingletonContentType<_TFields extends readonly AnyFieldDefinition[], TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: SingletonConfigWithFieldsets<TFieldsets>): SingletonContentTypeDefinition<readonly [], TFieldsets>;
+declare const defineSingleton: typeof defineSingletonContentType;
 /**
- * Query conditions for filtering content
- * Supports both content fields and metadata fields
+ * What a read reports about a singleton beside its fields: the committed document's
+ * `SingletonMetadata`, read through `http/api-schema.ts` rather than declared again here.
  *
- * 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.
+ * Narrower than an entry's — no slug, default locale, available locales or references — and it
+ * names the singleton by `id` and `type`. The hand-written type this replaces declared a `key` and a
+ * `singletonType` the wire does not carry, and `Date` timestamps where it sends ISO 8601 strings.
  */
-type WhereClause<T extends BaseContent = BaseContent> = ([
-    Exclude<keyof T, '_metadata'>
-] extends [never] ? {
-    [field: string]: unknown;
-} : {
-    [K in Exclude<keyof T, '_metadata'>]?: WhereFieldCondition<T[K]>;
-}) & {
-    /** Metadata field conditions */
-    _metadata?: {
-        [K in keyof T['_metadata']]?: T['_metadata'][K] | WhereOperator<T['_metadata'][K]>;
-    };
+type SingletonMetadata = components['schemas']['SingletonMetadata'];
+/**
+ * Type alias for any singleton content type definition.
+ */
+type AnySingletonContentTypeDefinition = SingletonContentTypeDefinition<any, any>;
+/**
+ * Infer the TypeScript type from a singleton definition: every field typed as a read returns it
+ * (`schema/infer-fields.ts`), plus `_metadata`. `S` is the schema, as for `InferContentType`.
+ */
+type InferSingletonContentType<T extends AnySingletonContentTypeDefinition, S extends FieldSchemaContext | undefined = undefined> = FieldValues<DeclaredFields<T>, S> & {
+    _metadata: SingletonMetadata;
 };
+type InferSingleton<T extends AnySingletonContentTypeDefinition, S extends FieldSchemaContext | undefined = undefined> = InferSingletonContentType<T, S>;
+
 /**
- * Query operators for advanced filtering
+ * Asset type definition matching @relyio/schema AssetTypeSchema
+ *
+ * Asset types are first-class entries (entryType: 'asset') that pair a binary
+ * pipeline family (declared via exactly one kind key: `image`, `video`, or
+ * `file`) with user-defined metadata fields that reuse the standard field
+ * system — including fieldsets, workflow, access tags, and AI config.
+ *
+ * The kind config blocks are strongly typed below (mirroring the zod-inferred
+ * `@relyio/schema` types), so authoring asset types in TypeScript gets full
+ * autocomplete. The authoritative validation still lives in @relyio/schema's
+ * `AssetTypesValidator` and runs on deploy.
  */
-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;
-    /** Regular expression match */
-    $regex?: string;
-    /** Exists (field is not null/undefined) */
-    $exists?: boolean;
+
+/** Resize fit modes supported by the Cloudflare Images binding. */
+type ImageFitMode = 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
+/** Output formats the Cloudflare Images binding can produce (`heic` is input-only). */
+type ImageOutputFormat = 'avif' | 'webp' | 'jpeg' | 'png';
+/** Shared image transform props (CF Images vocabulary). */
+interface ImageTransform {
+    width?: number;
+    height?: number;
+    fit?: ImageFitMode;
+    format?: ImageOutputFormat;
+    quality?: number;
+}
+/** Upload gate for the `image` kind (rejects bad files at the door). */
+interface ImageUploadConfig {
+    allowedMimeTypes?: string[];
+    maxFileSize?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    /** `width:height`, e.g. `16:9`. */
+    aspectRatio?: string;
+}
+/** Upload gate for the `video` kind. */
+interface VideoUploadConfig {
+    allowedMimeTypes?: string[];
+    maxFileSize?: number;
+    maxDuration?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+}
+/** Upload gate for the `file` kind (MIME + size only in v1). */
+interface FileUploadConfig {
+    allowedMimeTypes?: string[];
+    maxFileSize?: number;
+}
+/** Delivery rendition preset (max 20 per asset type), applied on the fly by the gateway. */
+interface VariantDefinition extends ImageTransform {
+    /** Variant id; must start with a letter (codegen emits the `*Variant` union from these). */
+    id: string;
 }
 /**
- * Sort options for query results
+ * Ingest normalization of the canonical stored original (image v1 only).
+ * `true` expands to the platform default on deploy.
  */
-type SortOptions<T extends BaseContent = BaseContent> = {
-    [K in keyof T]?: 'asc' | 'desc';
-};
+type ImageSourceConfig = boolean | (ImageTransform & {
+    stripMetadata?: boolean;
+});
+/** EXIF retention policy for the `image` kind (plan 15). */
+interface ImageExifConfig {
+    /** Retain GPS in `extracted.exif` (default strips it for privacy). */
+    keepGps?: boolean;
+}
+/** Image kind config (`upload`, `source`, `variants`, `localization`, `exif`). */
+interface ImageKindConfig {
+    upload?: ImageUploadConfig;
+    source?: ImageSourceConfig;
+    /** Max 20 variants per asset type. */
+    variants?: VariantDefinition[];
+    localization?: LocalizationConfig;
+    exif?: ImageExifConfig;
+}
+/** Poster/thumbnail strategy for the `video` kind. */
+interface VideoPosterConfig {
+    /** 0.0–1.0 → Stream thumbnailTimestampPct. */
+    defaultTimestampPct?: number;
+    /** Enable an animated preview (gif/webp). */
+    animated?: boolean;
+}
+/** Subtitle track strategy for the `video` kind. */
+interface VideoCaptionsConfig {
+    enabled?: boolean;
+    requiredLocales?: string[];
+    /** Stream AI transcription when no track is uploaded. */
+    autoGenerate?: boolean;
+}
+/** Downloadable-MP4 toggle for the `video` kind. */
+interface VideoDownloadConfig {
+    enabled?: boolean;
+}
+/** Stream watermark profile for the `video` kind. */
+interface VideoWatermarkConfig {
+    enabled?: boolean;
+    /** Account-level Stream watermark profile uid. */
+    profileId?: string;
+}
 /**
- * Query options for content requests
+ * Video kind config (`upload`, `poster`, `captions`, `download`, `watermark`,
+ * `localization`). Stream auto-generates the ABR ladder — there is intentionally
+ * NO `variants` and NO `encoding` block.
  */
-interface QueryOptions<T extends BaseContent = BaseContent> {
-    /** Conditions to filter by */
-    where?: WhereClause<T>;
-    /** Fields to include in response */
-    select?: (keyof T)[];
-    /** Related content to include */
-    include?: string[];
-    /** Sort options */
-    sort?: SortOptions<T>;
-    /** Limit number of results */
-    limit?: number;
-    /** Offset for pagination */
-    offset?: number;
-    /** Cursor for cursor-based pagination */
-    cursor?: string;
+interface VideoKindConfig {
+    upload?: VideoUploadConfig;
+    poster?: VideoPosterConfig;
+    captions?: VideoCaptionsConfig;
+    download?: VideoDownloadConfig;
+    watermark?: VideoWatermarkConfig;
+    localization?: LocalizationConfig;
+}
+/** Malware scan config for the `file` kind (plan 19). */
+interface FileScanConfig {
+    enabled?: boolean;
+    blockUntilClean?: boolean;
+}
+/** File kind config (`upload`, `localization`, `scan`, `extractText`). */
+interface FileKindConfig {
+    upload?: FileUploadConfig;
+    localization?: LocalizationConfig;
+    /** Malware scan (plan 19). */
+    scan?: FileScanConfig;
+    /** Extract searchable text + metadata for PDFs (plan 15). */
+    extractText?: boolean;
+}
+interface AssetTypeBaseConfig {
+    /** Display name shown in the UI */
+    displayName: string;
+    /** Plural display name (e.g., "Product Photos" for "Product Photo") */
+    displayNamePlural?: string;
+    /** Description of the asset type */
+    description?: string;
+    /**
+     * AI configuration. `ai.instructions` is an optional global brief; per-field
+     * `ai.instructions` describe individual fields. `ai.autoGenerate` (image
+     * kind, v1) is the master switch: when true, the derived analysis agent runs
+     * after upload and fills every field that declares `ai.instructions`, applied
+     * as a review proposal.
+     */
+    ai?: AssetAIConfig;
+    /** Field ID to use as the asset display title */
+    displayField?: string;
+    /** Access tags for role-based access control */
+    accessTags?: string[];
+    /** Workflow configuration for this asset type */
+    workflow?: ContentTypeWorkflowConfig;
+    /** Image pipeline config — mutually exclusive with `video`/`file` */
+    image?: ImageKindConfig;
+    /** Video pipeline config — mutually exclusive with `image`/`file` */
+    video?: VideoKindConfig;
+    /** File pipeline config — mutually exclusive with `image`/`video` */
+    file?: FileKindConfig;
 }
 /**
- * Content creation input - excludes metadata fields that are managed by the system
+ * Type alias for a fieldset with any fields.
  */
-type CreateInput<T extends BaseContent> = Omit<T, '_metadata'> & {
-    /** Optional metadata that can be set during creation */
-    _metadata?: {
-        /** Parent ID for hierarchical content */
-        parentId?: string | null;
-        /** Content locale */
-        locale?: string;
-    };
-};
+type AnyFieldset$1 = Fieldset<any>;
+/** Asset type configuration using direct fields. */
+interface AssetTypeConfigWithFields<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> extends AssetTypeBaseConfig {
+    /** Direct field definitions - preserves literal types */
+    fields: TFields;
+    /** Cannot have fieldsets when using fields */
+    fieldsets?: never;
+}
+/** Asset type configuration using fieldsets. */
+interface AssetTypeConfigWithFieldsets<TFieldsets extends readonly AnyFieldset$1[] = readonly AnyFieldset$1[]> extends AssetTypeBaseConfig {
+    /** Field organization via fieldsets - preserves literal types */
+    fieldsets: TFieldsets;
+    /** Cannot have direct fields when using fieldsets */
+    fields?: never;
+}
 /**
- * Content update input - excludes system-managed metadata fields
+ * Asset type configuration with no metadata fields: the asset is its file. `AssetTypeSchema` makes
+ * `fields` and `fieldsets` both optional, so this is an asset type deploy accepts (REL-1454).
  */
-type UpdateInput<T extends BaseContent> = Partial<Omit<T, '_metadata'>> & {
-    /** Optional metadata that can be updated */
-    _metadata?: {
-        /** Parent ID for hierarchical content */
-        parentId?: string | null;
-        /** Content locale */
-        locale?: string;
-    };
+interface AssetTypeConfigWithoutFields extends AssetTypeBaseConfig {
+    fields?: never;
+    fieldsets?: never;
+}
+/** Asset type configuration: direct fields, fieldsets, or neither. */
+type AssetTypeConfig<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset$1[] = readonly AnyFieldset$1[]> = AssetTypeConfigWithFields<TFields> | AssetTypeConfigWithFieldsets<TFieldsets> | AssetTypeConfigWithoutFields;
+/** Asset type definition - preserves field types for inference. */
+interface AssetTypeDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset$1[] = readonly AnyFieldset$1[]> {
+    readonly _tag: 'assetType';
+    readonly name: string;
+    readonly displayName: string;
+    readonly displayNamePlural?: string;
+    readonly description?: string;
+    readonly ai?: AssetAIConfig;
+    readonly displayField?: string;
+    readonly accessTags?: string[];
+    readonly workflow?: ContentTypeWorkflowConfig;
+    readonly image?: ImageKindConfig;
+    readonly video?: VideoKindConfig;
+    readonly file?: FileKindConfig;
+    readonly fields?: TFields;
+    readonly fieldsets?: TFieldsets;
+}
+/**
+ * Define an asset type.
+ *
+ * Exactly one kind key (`image`, `video`, or `file`) must be supplied. Metadata
+ * fields are optional: declare `fields`, `fieldsets`, or neither. The generic
+ * type parameters preserve literal field IDs for inference, mirroring
+ * `defineContentType`.
+ *
+ * @example
+ * const productPhoto = defineAssetType('productPhoto', {
+ *   displayName: 'Product Photo',
+ *   image: {
+ *     upload: { allowedMimeTypes: ['image/jpeg', 'image/png', 'image/webp'], maxFileSize: 10485760 },
+ *     variants: [{ id: 'thumb', width: 200, height: 200, fit: 'cover', format: 'webp' }],
+ *   },
+ *   fields: [
+ *     fields.shortText('altText', { ui: { displayName: 'Alt Text' } }),
+ *   ],
+ * })
+ */
+declare function defineAssetType(name: string, config: AssetTypeConfigWithoutFields): AssetTypeDefinition<readonly [], readonly []>;
+declare function defineAssetType<TFields extends readonly AnyFieldDefinition[], _TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: AssetTypeConfigWithFields<TFields>): AssetTypeDefinition<TFields, readonly []>;
+declare function defineAssetType<_TFields extends readonly AnyFieldDefinition[], TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: AssetTypeConfigWithFieldsets<TFieldsets>): AssetTypeDefinition<readonly [], TFieldsets>;
+/**
+ * Type alias for any asset type definition.
+ */
+type AnyAssetTypeDefinition = AssetTypeDefinition<any, any>;
+/**
+ * Infer the TypeScript type from an asset type definition.
+ *
+ * Mirrors {@link InferContentType}: produces the (optional) metadata field shape
+ * 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.
+ */
+type InferAssetType<T extends AnyAssetTypeDefinition, S extends FieldSchemaContext | undefined = undefined> = FieldValues<DeclaredFields<T>, S> & {
+    _metadata: EntryMetadata;
 };
+
 /**
- * What the entry list serves — **read from the committed document**, not
- * written down here.
+ * What a read returns for each field, derived from the field's declaration (`INV-SS-TYPES-INFERRED`).
  *
- * 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.
+ * Every `Infer*` in this package — content types, singletons, asset types, settings groups — types
+ * its fields here and nowhere else, so an entry, a referenced entry, a component and a list item are
+ * typed by one table. The types describe **what a read returns**, which is not always what a write
+ * accepts:
  *
- * 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`).
+ * - `richText` is the stored HTML string; `date` is `YYYY-MM-DD` and `dateTime` an ISO 8601 string —
+ *   the client does not revive dates.
+ * - A `reference` is the target's id until `include` names it, and then the target entry itself.
+ *   The type cannot see `include`, so it is both: `string | <entry>`. A single reference whose target
+ *   was deleted with `onTargetDelete: 'nullify'` is `null`.
+ * - A localized field is the value for the one locale the read composed, like any other field; the
+ *   other locales of a `locales=` read sit under `_metadata.localizations`, not here.
+ * - Every field is optional. The wire omits a field with no value — a draft, a `fields` projection, a
+ *   locale with nothing to fall back to, an entry older than a field — so `required` does not make
+ *   one present.
  */
-type ContentQueryResult<T extends BaseContent = BaseContent> = Wire<'/v1/{contentType}', 'get', T>;
+
 /**
- * Singleton content (single instance per type)
- * Matches the actual RelyIO API structure
+ * The parts of a schema a field's value type reads: the types a reference may expand to and the
+ * components a component field names. Structural, so every `defineSchema()` result fits.
+ *
+ * Without one in view — `InferContentType<typeof post>` with no second argument — a reference
+ * expands to an {@link UnresolvedEntry} and a component to an {@link UnresolvedComponent}: the field
+ * is still typed, but what it names is not.
  */
-interface SingletonContent {
-    /** Content fields at top level */
-    [key: string]: unknown;
-    /** RelyIO metadata object for singletons */
-    _metadata: {
-        /** Singleton key identifier */
-        key: string;
-        /** When the singleton was created */
-        createdAt: Date;
-        /** When the singleton was last updated */
-        updatedAt: Date;
-        /** Singleton type identifier */
-        singletonType: string;
-        /** Content version */
-        version: number;
-        /** Content locale */
-        locale: string;
-    };
+interface FieldSchemaContext {
+    readonly contentTypes: object;
+    readonly components: object;
+    readonly singletonContentTypes: object;
+    readonly assetTypes?: object;
 }
+/** A schema in view, or `undefined` when none is. */
+type Context = FieldSchemaContext | undefined;
+/** An expanded reference whose target type is not in view: an entry, with fields nothing declared. */
+interface UnresolvedEntry {
+    _metadata: EntryMetadata;
+    [field: string]: unknown;
+}
+/** A component whose definition is not in view: an object, with fields nothing declared. */
+type UnresolvedComponent = Record<string, unknown>;
 /**
- * Settings group
+ * One row per field type the schema declares. `OverEveryFieldType` makes the table exhaustive by
+ * construction: a field type added to `FieldType` without a row here fails to compile, rather than
+ * reading as `unknown`.
  */
-interface SettingsGroup {
-    /** Unique identifier for the settings group */
-    id: string;
-    /** Settings group name */
-    name: string;
-    /** Settings data */
-    settings: Record<string, unknown>;
-    /** When the settings were created */
-    createdAt: string;
-    /** When the settings were last updated */
-    updatedAt: string;
-}
+type OverEveryFieldType<T extends {
+    [K in FieldType]: unknown;
+}> = T;
+type FieldValueByType<C, S extends Context> = OverEveryFieldType<{
+    shortText: string;
+    longText: string;
+    /** The stored HTML. */
+    richText: string;
+    email: string;
+    url: string;
+    slug: string;
+    integer: number;
+    decimal: number;
+    boolean: boolean;
+    enum: EnumValue<C>;
+    /** `YYYY-MM-DD`. */
+    date: string;
+    /** ISO 8601. */
+    dateTime: string;
+    reference: ReferenceValue<C, S>;
+    tags: string[];
+    list: ListValue<C, S>;
+}>;
 /**
- * Custom query definition
+ * The value a read returns for field `F`.
+ *
+ * The last arm is the one `unknown` in this module, and it is deliberate: a field whose `type` is not
+ * a declared literal — a definition built from a plain `string` rather than through `fields.*` — has
+ * no row to read.
  */
-interface CustomQuery<TVariables = unknown, TResponse = unknown> {
-    /** Query name */
-    name: string;
-    /** Query variables */
-    variables?: TVariables;
-    /** Expected response type */
-    response?: TResponse;
+type FieldValue<F extends AnyFieldDefinition, S extends Context = undefined> = F['type'] extends `component(${infer Id})` ? ComponentValue<Id, S> : F['type'] extends FieldType ? FieldValueByType<NonNullable<F['config']>, S>[F['type']] : unknown;
+/** The fields `F` (a union of field definitions) as an object, each optional — see the module note. */
+type FieldValues<F extends AnyFieldDefinition, S extends Context = undefined> = {
+    [K in F['id']]?: FieldValue<Extract<F, {
+        readonly id: K;
+    }>, S>;
+};
+/**
+ * Every field a definition declares, directly or through its fieldsets, as one union — the one walk
+ * over `fields` / `fieldsets` every `Infer*` shares.
+ */
+type DeclaredFields<T extends {
+    readonly fields?: unknown;
+    readonly fieldsets?: unknown;
+}> = Extract<(NonNullable<T['fields']> extends readonly (infer F)[] ? F : never) | (NonNullable<T['fieldsets']> extends readonly (infer FS)[] ? FS extends {
+    readonly fields: readonly (infer F)[];
+} ? F : never : never), AnyFieldDefinition>;
+/** `multi` as declared: `true`, `false`, or `boolean` when the declaration does not say. */
+type Multiplicity<C> = C extends {
+    readonly multi?: infer M;
+} ? M : false;
+/** One `V`, a list of them, or — when `multi` is not a literal — either. */
+type OneOrMany<C, V> = [Multiplicity<C>] extends [true] ? V[] : [Multiplicity<C>] extends [false | undefined] ? V : V | V[];
+type EnumValue<C> = OneOrMany<C, C extends {
+    readonly options: ReadonlyArray<{
+        readonly value: infer V;
+    }>;
+} ? V : string>;
+type ReferenceTarget<C> = C extends {
+    readonly to: infer T;
+} ? T extends readonly (infer E)[] ? E : T : string;
+/** `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> = D extends ContentTypeDefinition ? InferContentType<D, S> : never;
+type SingletonEntryOf<D, S extends Context> = D extends SingletonContentTypeDefinition ? InferSingletonContentType<D, S> : never;
+type AssetEntryOf<D, S extends Context> = D extends AssetTypeDefinition ? InferAssetType<D, S> : never;
+type OrUnresolved<T> = [T] extends [never] ? UnresolvedEntry : T;
+/** What `include` expands a reference to `Target` into: that type's entry, typed by the schema. */
+type ExpandedEntry<Target, S extends Context> = S extends FieldSchemaContext ? OrUnresolved<ContentEntryOf<Declared<S['contentTypes'], Target>, S> | SingletonEntryOf<Declared<S['singletonContentTypes'], Target>, S> | AssetEntryOf<Declared<NonNullable<S['assetTypes']>, Target>, S>> : UnresolvedEntry;
+type ReferenceValue<C, S extends Context> = [Multiplicity<C>] extends [true] ? Array<string | ExpandedEntry<ReferenceTarget<C>, S>> : [Multiplicity<C>] extends [false | undefined] ? string | null | ExpandedEntry<ReferenceTarget<C>, S> : string | null | Array<string | ExpandedEntry<ReferenceTarget<C>, S>> | ExpandedEntry<ReferenceTarget<C>, S>;
+type ComponentFields<D, S extends Context> = [D] extends [never] ? UnresolvedComponent : D extends {
+    readonly fields: readonly (infer F)[];
+} ? FieldValues<Extract<F, AnyFieldDefinition>, S> : UnresolvedComponent;
+type ComponentValue<Id extends string, S extends Context> = S extends FieldSchemaContext ? ComponentFields<Declared<S['components'], Id>, S> : UnresolvedComponent;
+/**
+ * A list with subfields is a list of objects typed by them; a list without is a list of strings,
+ * which is what the validation document enforces for it.
+ */
+type ListValue<C, S extends Context> = C extends {
+    readonly subfields?: infer Sub;
+} ? Sub extends readonly (infer F)[] ? [F] extends [never] ? string[] : Array<FieldValues<Extract<F, AnyFieldDefinition>, S>> : string[] : string[];
+
+/**
+ * Content type definition matching @relyio/schema ContentTypeSchema
+ *
+ * Uses advanced TypeScript generics to preserve each field's declaration through the type system,
+ * so `InferContentType` types every field by what a read returns and `where()` autocompletes.
+ */
+
+/**
+ * Fieldset for organizing related fields
+ * Generic over fields to preserve literal field IDs
+ */
+interface Fieldset<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
+    /** Unique fieldset identifier */
+    readonly id: string;
+    /** Display name shown in the UI */
+    readonly displayName: string;
+    /** Optional description */
+    readonly description?: string;
+    /** Whether an editing surface shows this fieldset collapsed to begin with */
+    readonly collapsedByDefault?: boolean;
+    /** AI configuration for content generation and review */
+    readonly ai?: AIConfig;
+    /** Fields within this fieldset - preserves literal types */
+    readonly fields: TFields;
 }
 /**
- * Content type schema information
+ * Type alias for a fieldset with any fields.
+ * Used in generic constraints where we need to accept any fieldset type.
+ */
+type AnyFieldset = Fieldset<any>;
+/**
+ * Create a fieldset for organizing fields
+ * Generic to preserve the specific field types for type inference
+ *
+ * @example
+ * const seoFieldset = fieldset('seo', {
+ *   displayName: 'SEO Settings',
+ *   fields: [
+ *     fields.shortText('metaTitle', { config: { maxLength: 60 } }),
+ *     fields.longText('metaDescription', { config: { maxLength: 160 } }),
+ *   ]
+ * })
+ */
+declare function fieldset<TFields extends readonly AnyFieldDefinition[]>(id: string, config: {
+    displayName: string;
+    description?: string;
+    /** Show the fieldset collapsed until an editor opens it */
+    collapsedByDefault?: boolean;
+    ai?: AIConfig;
+    fields: TFields;
+}): Fieldset<TFields>;
+/**
+ * Content type configuration using direct fields
+ * Generic to preserve literal field IDs for type inference
  */
-interface ContentTypeSchema {
-    /** Content type name */
-    name: string;
-    /** Display name */
+interface ContentTypeConfigWithFields<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
+    /** Display name shown in the UI */
     displayName: string;
-    /** Description */
+    /** Plural display name shown in the UI (e.g., "Products" for "Product") */
+    displayNamePlural?: string;
+    /** Description of the content type */
     description?: string;
-    /** Field definitions */
-    fields: FieldDefinition[];
-    /** Whether this content type is hierarchical */
+    /** AI configuration: generation/review guidance */
+    ai?: AIConfig;
+    /**
+     * Field ID to use as entry display title in lists, references, and editor header.
+     * If not set, falls back to: title → name → slug → first shortText field → entryUid
+     */
+    displayField?: string;
+    /** Whether this content type supports hierarchical (parent-child) relationships */
     hierarchical?: boolean;
-    /** Preview configuration */
-    preview?: {
-        select?: Record<string, string>;
-        prepare?: (_selection: Record<string, unknown>) => Record<string, unknown>;
-    };
+    /** Access tags for role-based access control */
+    accessTags?: string[];
+    /** Workflow configuration for this content type */
+    workflow?: ContentTypeWorkflowConfig;
+    /** Direct field definitions - preserves literal types */
+    fields: TFields;
+    /** Cannot have fieldsets when using fields */
+    fieldsets?: never;
 }
 /**
- * Field definition for content types
+ * Content type configuration using fieldsets
+ * Generic to preserve fieldset field types
  */
-interface FieldDefinition {
-    /** Field name */
-    name: string;
-    /** Field type */
-    type: FieldTypeName;
-    /** Display title */
-    title?: string;
-    /** Field description */
+interface ContentTypeConfigWithFieldsets<TFieldsets extends readonly AnyFieldset[] = readonly AnyFieldset[]> {
+    /** Display name shown in the UI */
+    displayName: string;
+    /** Plural display name shown in the UI (e.g., "Products" for "Product") */
+    displayNamePlural?: string;
+    /** Description of the content type */
     description?: string;
-    /** Whether field is required */
-    required?: boolean;
-    /** Default value */
-    default?: unknown;
-    /** Validation rules */
-    validation?: ValidationRule[];
-    /** Field options */
-    options?: FieldOptions;
+    /** AI configuration: generation/review guidance */
+    ai?: AIConfig;
+    /**
+     * Field ID to use as entry display title in lists, references, and editor header.
+     * If not set, falls back to: title → name → slug → first shortText field → entryUid
+     */
+    displayField?: string;
+    /** Access tags for role-based access control */
+    accessTags?: string[];
+    /** Whether this content type supports hierarchical (parent-child) relationships */
+    hierarchical?: boolean;
+    /** Workflow configuration for this content type */
+    workflow?: ContentTypeWorkflowConfig;
+    /** Field organization via fieldsets - preserves literal types */
+    fieldsets: TFieldsets;
+    /** Cannot have direct fields when using fieldsets */
+    fields?: never;
 }
 /**
- * Supported field type names (string identifiers)
+ * Content type configuration (either fields OR fieldsets, not both)
  */
-type FieldTypeName = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'text' | 'markdown' | 'richtext' | 'slug' | 'url' | 'email' | 'image' | 'file' | 'reference' | 'array' | 'object' | 'geopoint' | 'color';
+type ContentTypeConfig<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset[] = readonly AnyFieldset[]> = ContentTypeConfigWithFields<TFields> | ContentTypeConfigWithFieldsets<TFieldsets>;
 /**
- * Field validation rules
+ * Content type definition - preserves field types for inference
  */
-interface ValidationRule {
-    /** Rule type */
-    type: 'required' | 'min' | 'max' | 'pattern' | 'custom';
-    /** Rule value */
-    value?: unknown;
-    /** Error message */
-    message?: string;
+interface ContentTypeDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset[] = readonly AnyFieldset[]> {
+    readonly _tag: 'contentType';
+    readonly name: string;
+    readonly displayName: string;
+    readonly displayNamePlural?: string;
+    readonly description?: string;
+    /** AI configuration: generation/review guidance */
+    readonly ai?: AIConfig;
+    /** Field ID to use as entry display title */
+    readonly displayField?: string;
+    readonly hierarchical?: boolean;
+    readonly accessTags?: string[];
+    readonly workflow?: ContentTypeWorkflowConfig;
+    readonly fields?: TFields;
+    readonly fieldsets?: TFieldsets;
 }
 /**
- * Field-specific options
+ * Define a content type with type-safe fields
+ *
+ * The generic type parameters preserve the literal field IDs through the type
+ * system, enabling autocomplete in SDK methods like where(), select(), etc.
+ *
+ * @example
+ * // Using direct fields
+ * const product = defineContentType('product', {
+ *   displayName: 'Product',
+ *   fields: [
+ *     fields.shortText('title', { config: { required: true } }),
+ *     fields.decimal('price', { config: { min: 0, decimalPlaces: 2 } }),
+ *   ]
+ * })
+ *
+ * @example
+ * // Using fieldsets for organization
+ * const product = defineContentType('product', {
+ *   displayName: 'Product',
+ *   fieldsets: [
+ *     fieldset('basic', {
+ *       displayName: 'Basic Info',
+ *       fields: [
+ *         fields.shortText('title', { config: { required: true } }),
+ *       ]
+ *     }),
+ *     fieldset('pricing', {
+ *       displayName: 'Pricing',
+ *       fields: [
+ *         fields.decimal('price', { config: { min: 0, decimalPlaces: 2 } }),
+ *       ]
+ *     }),
+ *   ]
+ * })
  */
-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[];
-}
+declare function defineContentType<TFields extends readonly AnyFieldDefinition[], _TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: ContentTypeConfigWithFields<TFields>): ContentTypeDefinition<TFields, readonly []>;
+declare function defineContentType<_TFields extends readonly AnyFieldDefinition[], TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: ContentTypeConfigWithFieldsets<TFieldsets>): ContentTypeDefinition<readonly [], TFieldsets>;
 /**
- * Real-time event types
+ * Type alias for any content type definition.
  */
-type RealtimeEventType = 'created' | 'updated' | 'deleted' | 'published' | 'unpublished';
+type AnyContentTypeDefinition = ContentTypeDefinition<any, any>;
 /**
- * Real-time event payload
+ * What a read reports about an entry beside its fields: the committed document's `EntryMetadata`
+ * (`apps/services/api/openapi-spec.json`), read through `http/api-schema.ts`, its one derivation in
+ * this package — not declared a second time here.
+ *
+ * It used to be written out by hand, and the copy had drifted from the wire: it declared a
+ * `parentId` no read sends, typed `createdAt` and `updatedAt` as `Date` where the wire sends ISO 8601
+ * strings, and left out what a reader most needs — `availableLocales`, `defaultLocale`, `slug`,
+ * `refs` — so the preview toolbar took them through a structural type of its own. A field the
+ * service adds or changes now reaches this type when `api-schema.ts` is regenerated, and
+ * `__tests__/read-metadata.types.ts` fails `type:check` if a read stops declaring it.
+ *
+ * Every entry-shaped value carries it — a single read, each item of a list or of `children()`, and
+ * an entry an `include` expanded — because the service builds each of them with one transform.
+ * `versionCount` and `versions` are sent on a single read only, so they are optional.
  */
-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>;
-}
+type EntryMetadata = components['schemas']['EntryMetadata'];
 /**
- * Subscription options
+ * The per-locale publication facts every one-document read reports, an entry's, a singleton's and a
+ * settings group's alike (`INV-LM-PUBLICATION-IS-REPORTED-PER-LOCALE`): a `Pick` of the document's
+ * {@link EntryMetadata}, so this package holds no copy of them. `localeStatus` is absent when the
+ * locale has no content of its own.
  */
-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>;
-}
+type LocalePublicationFields = Pick<EntryMetadata, 'localeStatus' | 'localeHasDraft' | 'draftLocales'>;
 /**
- * Performance metrics
+ * Infer the TypeScript type of an entry from a content type definition: every field it declares,
+ * directly or through fieldsets, typed as a read returns it (`INV-SS-TYPES-INFERRED`), plus
+ * `_metadata`. Each field is optional — `schema/infer-fields.ts` says why, and what each field type
+ * reads as.
+ *
+ * `S` is the schema the type belongs to. With it, a reference expanded by `include` is typed as the
+ * entry it points at and a component field by the component's fields; without it, those two are
+ * typed as an entry or an object whose fields are not known. A client typed by a schema passes it.
+ *
+ * @example
+ * const product = defineContentType('product', {
+ *   displayName: 'Product',
+ *   fields: [
+ *     fields.shortText('title'),
+ *     fields.decimal('price'),
+ *     fields.enum('status', {
+ *       config: {
+ *         options: [
+ *           { value: 'draft', label: 'Draft' },
+ *           { value: 'live', label: 'Live' },
+ *         ],
+ *       },
+ *     }),
+ *   ]
+ * })
+ *
+ * type Product = InferContentType<typeof product>
+ * // { title?: string; price?: number; status?: 'draft' | 'live'; _metadata: EntryMetadata }
  */
-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;
-}
+type InferContentType<T extends AnyContentTypeDefinition, S extends FieldSchemaContext | undefined = undefined> = FieldValues<DeclaredFields<T>, S> & {
+    _metadata: EntryMetadata;
+};
 
-export { type ApiPath as A, type BaseContent as B, type CreateInput as C, type DebugConfig as D, type Environment as E, type FieldTypeName as F, ValidationError as G, SchemaValidationError as H, InvalidPayloadError as I, RequiredFieldError as J, InvalidFieldTypeError as K, type LogLevel as L, type MatchRouteOptions as M, type MergedRelyIOConfig as N, type PathParamsOf as O, type PerformanceMetrics as P, type QueryOptions as Q, type RelyIOConfig as R, SDKError as S, type components as T, type UpdateInput as U, type ValidationRule as V, type Wire as W, type paths as X, type FieldDefinition as Y, type ApiMethod as a, type ApiSuccessBody as b, type RouteMatch as c, type WhereScalar as d, type WhereFieldCondition as e, type WhereClause as f, type WhereOperator as g, type SortOptions as h, type ContentQueryResult as i, type SingletonContent as j, type SettingsGroup as k, type CustomQuery as l, matchRoute as m, type ContentTypeSchema as n, type FieldOptions as o, type RealtimeEventType as p, type RealtimeEvent as q, type SubscriptionOptions as r, type CacheConfig as s, type RealtimeConfig as t, type RequestConfig as u, type ApiResponse as v, type RetryConfig as w, type CacheStrategy as x, type ValidationViolation as y, BaseValidationError as z };
+export { type SingletonConfigWithFieldsets as $, type AnyFieldDefinition as A, type BooleanConfig as B, type ComponentFieldConfig as C, type DecimalConfig as D, type EmailConfig as E, type FieldUIConfig as F, type UnresolvedComponent as G, defineContentType as H, type IntegerConfig as I, fieldset as J, type Fieldset as K, type LocalizationConfig as L, type ContentTypeConfig as M, type ContentTypeConfigWithFields as N, type ContentTypeConfigWithFieldsets as O, type ContentTypeDefinition as P, type EntryMetadata as Q, type RichTextConfig as R, type ShortTextConfig as S, type TagsConfig as T, type UrlConfig as U, type ValidationRule as V, type InferContentType as W, type LocalePublicationFields as X, defineSingletonContentType as Y, defineSingleton as Z, type SingletonConfigWithFields as _, type FieldAIConfig as a, type SingletonContentTypeDefinition as a0, type SingletonMetadata as a1, type InferSingletonContentType as a2, type InferSingleton as a3, defineAssetType as a4, type AssetTypeConfig as a5, type AssetTypeConfigWithFields as a6, type AssetTypeConfigWithFieldsets as a7, type AssetTypeConfigWithoutFields as a8, type AssetTypeDefinition as a9, getFirstWorkflowStage as aA, isFinalWorkflowStage as aB, type WorkflowEscalation as aC, type WorkflowAutoAssign as aD, type WorkflowStageConfig as aE, type WorkflowStageDefinition as aF, type WorkflowConfig as aG, type WorkflowDefinition as aH, type ContentTypeWorkflowConfig as aI, type paths as aJ, type components as aK, type InferAssetType as aa, type ImageKindConfig as ab, type VideoKindConfig as ac, type FileKindConfig as ad, type ImageTransform as ae, type ImageFitMode as af, type ImageOutputFormat as ag, type ImageUploadConfig as ah, type ImageSourceConfig as ai, type ImageExifConfig as aj, type VariantDefinition as ak, type VideoUploadConfig as al, type VideoPosterConfig as am, type VideoCaptionsConfig as an, type VideoDownloadConfig as ao, type VideoWatermarkConfig as ap, type FileUploadConfig as aq, type FileScanConfig as ar, defineWorkflow as as, defineWorkflowStage as at, defineContentTypeWorkflow as au, isWorkflowDefinition as av, isWorkflowStageDefinition as aw, getWorkflowStageIds as ax, findWorkflowStage as ay, getNextWorkflowStage 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 ListConfig as j, type AIConfig as k, type AllFieldTypes as l, type AssetAIConfig as m, type BaseFieldConfig as n, type ComponentFieldType 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 };