@relyio/sdk 0.13.0 → 0.14.0

package/dist/{define-schema-sWJ8Zn7C.d.cts → define-schema-nCfZeboB.d.cts}

@@ -1,4 +1,4 @@
-import { ao as ContentTypeDefinition, av as SingletonContentTypeDefinition, aB as SettingsGroupDefinition, be as WorkflowDefinition, bs as ViewDefinition, aG as AssetTypeDefinition, aq as InferContentType } from './include-paths-Bs5FhNw2.cjs';
+import { aL as ContentTypeDefinition, aR as SingletonContentTypeDefinition, aW as SettingsGroupDefinition, aC as LocaleDefinition, bw as RoleDefinition, bP as WorkflowDefinition, c5 as ViewDefinition, a$ as AssetTypeDefinition, aN as InferContentType, bz as KeyedRoles, c8 as KeyedViews, ce as CheckedLocales, cf as CheckedRoles, cg as CheckedWorkflow, ch as CheckedSection, ci as KeysDeclared, cj as LocaleCodesOf, ck as StagesDeclared, bA as KeyedRolesAsList, c9 as KeyedViewsAsList } from './define-content-type-BUZeWtpk.cjs';
 
 /**
  * Query definition matching @relyio/schema QueryDefinitionSchema
@@ -16,61 +16,78 @@ import { ao as ContentTypeDefinition, av as SingletonContentTypeDefinition, aB a
 /** One value a query clause compares with. */
 type QueryScalar = string | number | boolean;
 /**
- * The operators `where` and `filters` compare a field with — `{ price: { gte: 10 } }`.
+ * A window back or forward from the moment of the read — `{ amount: 7, unit: 'days' }` — which
+ * `$inTheLast` and `$inTheNext` take, as a list's `where` takes them.
+ */
+type QueryRelativeWindow = {
+    amount: number;
+    unit: 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
+};
+/**
+ * The operators `where` and `filters` compare a field with — `{ price: { $gte: 10 } }` — the
+ * `$`-prefixed operators a list's `where` takes, meaning what they mean there (REL-2439).
  *
  * The service's one vocabulary for `where`, `filters` and `having`, which deploy refuses any other
- * key against (REL-1479). There were four copies, and this one's `where` had no `eq` while `filters`
- * took six operators, each a `${…}` string. A value may be a parameter expression: a list operator
- * takes a list or a parameter that supplies one, a flag a boolean or a parameter.
+ * key against (REL-1479). The bare form (`{ price: { gte: 10 } }`) is gone: deploy refuses it,
+ * saying what to write. A value may be a parameter expression: a list operator takes a list or a
+ * parameter that supplies one, a flag a boolean or a parameter. A parameter only ever fills a value;
+ * which operators a condition asks is written here, never supplied.
  * `@relyio/codegen-typescript`'s `sdk-definition-config.types.ts` fails to compile when an operator,
  * or what it takes, differs from the schema's.
  */
 type WhereOperator = {
     /** Equal to */
-    eq?: QueryScalar;
+    $eq?: QueryScalar;
     /** Not equal to */
-    ne?: QueryScalar;
+    $ne?: QueryScalar;
     /** Greater than */
-    gt?: QueryScalar;
+    $gt?: QueryScalar;
     /** Greater than or equal to */
-    gte?: QueryScalar;
+    $gte?: QueryScalar;
     /** Less than */
-    lt?: QueryScalar;
+    $lt?: QueryScalar;
     /** Less than or equal to */
-    lte?: QueryScalar;
+    $lte?: QueryScalar;
     /** One of the values given */
-    in?: QueryScalar[] | string;
+    $in?: QueryScalar[] | string;
     /** None of the values given */
-    nin?: QueryScalar[] | string;
+    $nin?: QueryScalar[] | string;
     /** Contains the text, ignoring case */
-    contains?: QueryScalar;
-    /** Starts with the text, ignoring case */
-    startsWith?: QueryScalar;
-    /** Ends with the text, ignoring case */
-    endsWith?: QueryScalar;
+    $contains?: QueryScalar;
+    /** Starts with the text, matching case */
+    $startsWith?: QueryScalar;
+    /** Ends with the text, matching case */
+    $endsWith?: QueryScalar;
     /** The field holds a value (true) or does not (false) */
-    exists?: boolean | string;
-    /** The field holds no value (true) or does (false) */
-    notExists?: boolean | string;
+    $exists?: boolean | string;
+    /** The value is empty (true) or not (false) */
+    $isNull?: boolean | string;
+    /** A date within the span back from the moment of the read */
+    $inTheLast?: QueryRelativeWindow;
+    /** A date within the span forward from the moment of the read */
+    $inTheNext?: QueryRelativeWindow;
 };
 /**
  * The operators `having` compares a metric with: the same as `where`'s, each with a literal, since
- * `having` reads the values the aggregate computed and substitutes no parameter.
+ * `having` reads the values the aggregate computed and substitutes no parameter. A metric holds no
+ * date of an entry's, so neither relative window is taken.
  */
 type HavingOperator = {
-    eq?: QueryScalar;
-    ne?: QueryScalar;
-    gt?: QueryScalar;
-    gte?: QueryScalar;
-    lt?: QueryScalar;
-    lte?: QueryScalar;
-    in?: QueryScalar[];
-    nin?: QueryScalar[];
-    contains?: QueryScalar;
-    startsWith?: QueryScalar;
-    endsWith?: QueryScalar;
-    exists?: boolean;
-    notExists?: boolean;
+    $eq?: QueryScalar;
+    $ne?: QueryScalar;
+    $gt?: QueryScalar;
+    $gte?: QueryScalar;
+    $lt?: QueryScalar;
+    $lte?: QueryScalar;
+    $in?: QueryScalar[];
+    $nin?: QueryScalar[];
+    $contains?: QueryScalar;
+    $startsWith?: QueryScalar;
+    $endsWith?: QueryScalar;
+    $exists?: boolean;
+    $isNull?: boolean;
+    $inTheLast?: never;
+    $inTheNext?: never;
 };
 type WhereValue = string | number | boolean | (string | number | boolean)[] | WhereOperator;
 type WhereCondition = Record<string, WhereValue>;
@@ -284,12 +301,26 @@ interface QueryConfig {
     /** Whether the response is the record itself or a list. Defaults to `many` */
     cardinality?: QueryCardinality;
 }
+/** A value a query parameter takes, as the query string carries it to the query. */
+type QueryParameterValue = QueryScalar | readonly QueryScalar[];
+/** What a query whose parameters no type states accepts: any name, any value. */
+type AnyQueryParameters = {
+    readonly [name: string]: QueryParameterValue | undefined;
+};
+/** Type only: where a keyed definition keeps the parameters it declares (`InferQueryParams`). */
+declare const parametersAs: unique symbol;
 /**
  * Query definition
+ *
+ * `TParameters` is what the query accepts, read from the definition as written (REL-2421); a
+ * definition typed by nothing more than this interface accepts any.
  */
-interface QueryDefinition {
+interface QueryDefinition<TParameters extends object = AnyQueryParameters> {
+    /** Type only: never present at runtime. */
+    readonly [parametersAs]?: TParameters;
     readonly _tag: 'query';
-    readonly name: string;
+    /** Written from its key by `defineSchema` */
+    readonly name?: string;
     readonly type?: QueryType;
     readonly endpoint: string;
     readonly description?: string;
@@ -305,10 +336,23 @@ interface QueryDefinition {
     readonly cardinality?: QueryCardinality;
 }
 /**
- * Define a predefined query
+ * Define a predefined query (REL-1969): it takes no name, because its key under `defineSchema`'s
+ * `queries` is its id. Its `where` is the one a list takes, its operators `$`-prefixed (REL-2439).
+ *
+ * @example
+ * defineSchema({
+ *   contentTypes: { product },
+ *   queries: {
+ *     featuredProducts: defineQuery({
+ *       endpoint: '/api/featured-products',
+ *       fetch: { contentType: 'product', where: { featured: true }, limit: 10 },
+ *     }),
+ *   },
+ * })
  *
  * @example
- * const featuredProducts = defineQuery('featuredProducts', {
+ * // queries: { featuredProducts }
+ * const featuredProducts = defineQuery({
  *   endpoint: '/api/featured-products',
  *   description: 'Get featured products for homepage',
  *   fetch: {
@@ -329,7 +373,8 @@ interface QueryDefinition {
  * })
  *
  * @example
- * const searchProducts = defineQuery('searchProducts', {
+ * // queries: { searchProducts }
+ * const searchProducts = defineQuery({
  *   endpoint: '/api/search',
  *   description: 'Search products with semantic understanding',
  *   search: {
@@ -340,14 +385,15 @@ interface QueryDefinition {
  *     limit: 20,
  *   },
  *   filters: {
- *     'price.base': { gte: '${minPrice?0}', lte: '${maxPrice?}' },
+ *     'price.base': { $gte: '${minPrice?0}', $lte: '${maxPrice?}' },
  *     category: '${categoryId?}',
  *   },
  *   cache: 'public 60s',
  * })
  *
  * @example
- * const productStats = defineQuery('productStats', {
+ * // queries: { productStats }
+ * const productStats = defineQuery({
  *   endpoint: '/api/products/stats',
  *   description: 'Get product statistics by category',
  *   aggregate: {
@@ -365,299 +411,105 @@ interface QueryDefinition {
  *   cache: 'public 300s',
  * })
  */
-declare function defineQuery(name: string, config: QueryConfig): QueryDefinition;
+declare function defineQuery<const TConfig extends QueryConfig>(config: TConfig): QueryDefinition<DeclaredParameters<TConfig>>;
 /**
  * Infer basic response type from a query definition
  * Note: For accurate types, use the codegen tool
  */
 type InferQueryResponse<_T extends QueryDefinition> = unknown[];
 /**
- * Infer parameters from a query definition
- * Note: For accurate types, use the codegen tool
- */
-type InferQueryParams<_T extends QueryDefinition> = Record<string, unknown>;
-
-/**
- * Locale definition for multi-language support
- *
- * Locales define the languages and regions available for content
- * within your RelyIO project. Each locale can have:
- * - A fallback chain for missing content
- * - RTL text direction support
- * - Active/inactive status for gradual rollouts
- *
- * @example
- * import { defineLocale, defineSchema } from '@relyio/sdk/schema'
- *
- * const enUS = defineLocale('en-US', {
- *   displayName: 'English (US)',
- *   default: true,
- * })
- *
- * const esES = defineLocale('es-ES', {
- *   displayName: 'Spanish (Spain)',
- *   fallback: ['en-US'],
- * })
- *
- * const arSA = defineLocale('ar-SA', {
- *   displayName: 'Arabic (Saudi Arabia)',
- *   direction: 'rtl',
- *   fallback: ['en-US'],
- * })
- *
- * export const schema = defineSchema({
- *   locales: [enUS, esES, arSA],
- *   contentTypes: { ... },
- * })
- */
-/**
- * Text direction for RTL language support
- */
-type TextDirection = 'ltr' | 'rtl';
-/**
- * Options for defining a locale
- */
-interface LocaleOptions {
-    /** Human-readable name shown in the Studio UI */
-    displayName: string;
-    /**
-     * Marks the default locale (exactly one required per schema)
-     * The default locale serves as the ultimate fallback for all other locales
-     */
-    default?: boolean;
-    /**
-     * Ordered fallback chain when content is missing in this locale
-     * Locales are tried in order until content is found
-     *
-     * @example
-     * // Spanish Mexico falls back to Spain Spanish, then US English
-     * fallback: ['es-ES', 'en-US']
-     */
-    fallback?: string[];
-    /**
-     * Text direction for RTL languages like Arabic, Hebrew
-     * @default 'ltr'
-     */
-    direction?: TextDirection;
-    /**
-     * Enable/disable locale without removing translations
-     * Useful for:
-     * - Testing new locales before enabling them
-     * - Temporarily disabling locales for compliance review
-     * - Gradual market rollouts
-     *
-     * Note: Inactive locales can still serve as fallback targets
-     * @default true
-     */
-    active?: boolean;
-}
-/**
- * Locale definition with type tag for SDK type inference
- */
-interface LocaleDefinition {
-    readonly _tag: 'locale';
-    readonly code: string;
-    readonly displayName: string;
-    readonly default?: boolean;
-    readonly fallback?: readonly string[];
-    readonly direction?: TextDirection;
-    readonly active?: boolean;
-}
-/**
- * Define a locale for multi-language support
- *
- * Creates a locale definition that can be included in your schema.
- * Locales control:
- * - What languages/regions are available for content
- * - Fallback behavior when content is missing
- * - Text direction for RTL languages
- *
- * @param code BCP 47 locale code (e.g., 'en-US', 'fr-FR', 'ar-SA')
- * @param options Locale configuration
- * @returns Locale definition for use in defineSchema()
- *
- * @example
- * // Basic locale
- * const enUS = defineLocale('en-US', {
- *   displayName: 'English (US)',
- *   default: true,
- * })
- *
- * @example
- * // Locale with fallback chain
- * const esMX = defineLocale('es-MX', {
- *   displayName: 'Spanish (Mexico)',
- *   fallback: ['es-ES', 'en-US'],
- * })
- *
- * @example
- * // RTL language
- * const arSA = defineLocale('ar-SA', {
- *   displayName: 'Arabic (Saudi Arabia)',
- *   direction: 'rtl',
- *   fallback: ['en-US'],
- * })
- *
- * @example
- * // Inactive locale for testing
- * const jaJP = defineLocale('ja-JP', {
- *   displayName: 'Japanese',
- *   fallback: ['en-US'],
- *   active: false, // Hidden from Studio UI, but translations preserved
- * })
- */
-declare function defineLocale(code: string, options: LocaleOptions): LocaleDefinition;
-/**
- * Type guard to check if a value is a LocaleDefinition
- */
-declare function isLocaleDefinition(value: unknown): value is LocaleDefinition;
-/**
- * Extract locale codes from an array of locale definitions
- */
-declare function getLocaleCodes(locales: readonly LocaleDefinition[]): string[];
-/**
- * Find the default locale from an array of locale definitions
- */
-declare function findDefaultLocale(locales: readonly LocaleDefinition[]): LocaleDefinition | undefined;
-/**
- * Get active locales (excludes inactive ones)
- */
-declare function getActiveLocales(locales: readonly LocaleDefinition[]): LocaleDefinition[];
-/**
- * Build the complete fallback chain for a locale, resolving transitive fallbacks
- *
- * @param localeCode The locale to build the fallback chain for
- * @param locales All defined locales
- * @param maxDepth Maximum depth to prevent infinite loops (default: 10)
- * @returns Ordered array of locale codes to try as fallbacks
- *
- * @example
- * // Given: es-MX → es-ES → en-US (default)
- * buildFallbackChain('es-MX', locales)
- * // Returns: ['es-ES', 'en-US']
- */
-declare function buildFallbackChain(localeCode: string, locales: readonly LocaleDefinition[], maxDepth?: number): string[];
-
-/**
- * Role definition for fine-grained access control
- *
- * Roles define what users can do within a project. They can:
- * - Inherit from built-in roles (admin, editor, viewer)
- * - Compose from other roles using 'includes'
- * - Define granular permissions by access tags
- * - Set field visibility (hidden/readonly)
- */
-/**
- * Built-in roles that are always available
- */
-declare const BUILT_IN_ROLES: readonly ["admin", "editor", "viewer"];
-type BuiltInRole = (typeof BUILT_IN_ROLES)[number];
-/**
- * All available content actions
- */
-declare const ROLE_ACTIONS: readonly ["create", "read", "update", "delete", "publish", "unpublish", "duplicate", "comment", "approveElevated"];
-type RoleAction = (typeof ROLE_ACTIONS)[number];
-/**
- * Default actions for each built-in role
- */
-declare const BUILT_IN_ROLE_ACTIONS: Record<BuiltInRole, readonly RoleAction[]>;
-/**
- * Resource permission rule - defines what actions are allowed for specific tags
- */
-interface ResourcePermission {
-    /** Access tags this permission applies to */
-    tags: string[];
-    /** Actions allowed for resources with these tags */
-    actions: RoleAction[];
-}
-/**
- * Field visibility permissions
- */
-interface FieldVisibility {
-    /** Fields that are hidden from this role (cannot see) */
-    hidden?: string[];
-    /** Fields that are readonly for this role (can see but not edit) */
-    readonly?: string[];
-}
-/**
- * Role configuration
- */
-interface RoleConfig {
-    /** Human-readable name shown in Studio */
-    displayName: string;
-    /** Optional description for administrators */
-    description?: string;
-    /** Inherit from a built-in role (admin, editor, viewer) */
-    baseRole?: BuiltInRole;
-    /** Compose from other roles (built-in or custom) */
-    includes?: string[];
-    /** Resource permission rules */
-    permissions?: ResourcePermission[];
-    /** Field visibility settings */
-    fields?: FieldVisibility;
-}
-/**
- * Complete role definition
- */
-interface RoleDefinition {
-    readonly _tag: 'role';
-    readonly id: string;
-    readonly displayName: string;
-    readonly description?: string;
-    readonly baseRole?: BuiltInRole;
-    readonly includes?: string[];
-    readonly permissions?: ResourcePermission[];
-    readonly fields?: FieldVisibility;
+ * The parameters a query accepts, by name (REL-2421): what `client.query(name, { params })` takes.
+ *
+ * Read from the keyed definition as written, as the API's `declareQueryParameters` reads the
+ * deployed one: each `{name}` segment of the endpoint (required — the route cannot match without
+ * it), each `${name}` in the definition's values (required) or `${name?…}` (optional), and each
+ * entry of `parameters`, whose `type` types the value and whose `required` decides. A name the
+ * query does not declare is not a parameter, so it does not compile.
+ */
+type InferQueryParams<T extends QueryDefinition<object>> = T extends QueryDefinition<infer P> ? P : AnyQueryParameters;
+/** Every string value in `T`, at any depth — values only: a key is a field path, never a parameter. */
+type StringsIn<T> = T extends string ? T : T extends readonly (infer Item)[] ? StringsIn<Item> : T extends object ? {
+    [K in keyof T]-?: StringsIn<T[K]>;
+}[keyof T] : never;
+/** The `${…}` expressions in one string, each as its name and whether it is optional. */
+type ExpressionsIn<S extends string> = S extends `${string}\${${infer Body}}${infer Rest}` ? (Body extends `${infer Name}?${string}` ? {
+    readonly name: Name;
+    readonly optional: true;
+} : {
+    readonly name: Body;
+    readonly optional: false;
+}) | ExpressionsIn<Rest> : never;
+/** The `{name}` segments of an endpoint. */
+type EndpointNames<E> = E extends `${string}{${infer Name}}${infer Rest}` ? Name | EndpointNames<Rest> : never;
+/** The expressions of a definition: its values but `parameters` and `description`, as the API scans. */
+type Expressions<C> = ExpressionsIn<StringsIn<Omit<C, 'parameters' | 'description'>>>;
+/** The `parameters` entries a definition declares. */
+type Declared<C> = C extends {
+    readonly parameters: readonly (infer Entry)[];
+} ? Entry : never;
+/** What a declared `type` makes a value. */
+type ValueOfType<T> = T extends 'string' ? string : T extends 'number' | 'integer' ? number : T extends 'boolean' ? boolean : T extends 'array' ? readonly QueryScalar[] : T extends 'object' ? never : QueryParameterValue;
+/** What a definition declares, read once: its endpoint's segments, its expressions, its entries. */
+type Declaration<C> = {
+    readonly segments: EndpointNames<C extends {
+        readonly endpoint: infer E;
+    } ? E : never>;
+    readonly expressions: Expressions<C>;
+    readonly entries: Declared<C>;
+};
+/** What any declaration is. */
+interface AnyDeclaration {
+    readonly segments: string;
+    readonly expressions: {
+        readonly name: string;
+        readonly optional: boolean;
+    };
+    readonly entries: unknown;
 }
-/**
- * Define a custom role
- *
- * @example
- * // Inherit from built-in role
- * const blogEditor = defineRole('blog-editor', {
- *   displayName: 'Blog Editor',
- *   baseRole: 'editor',
- *   permissions: [
- *     { tags: ['blog'], actions: ['create', 'read', 'update', 'publish'] }
- *   ]
- * })
- *
- * @example
- * // Compose from other roles
- * const seniorEditor = defineRole('senior-editor', {
- *   displayName: 'Senior Editor',
- *   includes: ['blog-editor', 'news-editor'],
- *   permissions: [
- *     { tags: ['featured'], actions: ['publish', 'unpublish'] }
- *   ]
- * })
- *
- * @example
- * // Full permissions control
- * const moderator = defineRole('moderator', {
- *   displayName: 'Content Moderator',
- *   permissions: [
- *     { tags: ['comments'], actions: ['read', 'delete'] }
- *   ],
- *   fields: {
- *     hidden: ['internalNotes'],
- *     readonly: ['authorId']
- *   }
- * })
- */
-declare function defineRole(id: string, config: RoleConfig): RoleDefinition;
-/**
- * Check if a value is a role definition
- */
-declare function isRoleDefinition(value: unknown): value is RoleDefinition;
-/**
- * Check if a role ID is a built-in role
- */
-declare function isBuiltInRole(roleId: string): roleId is BuiltInRole;
-/**
- * Get the default actions for a built-in role
- */
-declare function getBuiltInRoleActions(roleId: BuiltInRole): readonly RoleAction[];
+/** Every name a declaration holds. */
+type NamesOf<D extends AnyDeclaration> = D['segments'] | NameOf<D['expressions']> | NameOf<D['entries']>;
+/**
+ * The names a union of expressions or entries holds. Distributive on purpose: none is `never`,
+ * which a bare `extends` would match and answer the constraint, `string`, for.
+ */
+type NameOf<E> = E extends {
+    readonly name: infer N extends string;
+} ? N : never;
+/** Whether `Name` is used bare (`${name}`) anywhere — which makes it required. */
+type UsedBare<D extends AnyDeclaration, Name> = [
+    Extract<D['expressions'], {
+        readonly name: Name;
+        readonly optional: false;
+    }>
+] extends [never] ? false : true;
+/** The `parameters` entry naming `Name`, or `never` where none does. */
+type EntryFor<D extends AnyDeclaration, Name> = Extract<D['entries'], {
+    readonly name: Name;
+}>;
+/**
+ * Whether `Name` is required: an endpoint segment always; else its entry's `required`; else an entry
+ * that says nothing about it is required unless some use says it is optional and none is bare; else
+ * any bare use. No entry is asked about first: `never` matches every shape.
+ */
+type IsRequired<D extends AnyDeclaration, Name> = [Name] extends [D['segments']] ? true : [EntryFor<D, Name>] extends [never] ? UsedBare<D, Name> : [EntryFor<D, Name>] extends [{
+    readonly required: infer R extends boolean;
+}] ? R : [Extract<D['expressions'], {
+    readonly name: Name;
+}>] extends [never] ? true : UsedBare<D, Name>;
+/** The value `Name` takes: its entry's declared `type`, else any value a parameter takes. */
+type ParameterValue<D extends AnyDeclaration, Name> = [EntryFor<D, Name>] extends [never] ? QueryParameterValue : [EntryFor<D, Name>] extends [{
+    readonly type: infer T;
+}] ? ValueOfType<T> : QueryParameterValue;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/** The parameters a keyed definition declares: required ones required, the rest optional. */
+type DeclaredParameters<C> = ParametersOf<Declaration<C>>;
+type ParametersOf<D extends AnyDeclaration> = Simplify<{
+    readonly [Name in NamesOf<D> as IsRequired<D, Name> extends true ? Name : never]: ParameterValue<D, Name>;
+} & {
+    readonly [Name in NamesOf<D> as IsRequired<D, Name> extends true ? never : Name]?: ParameterValue<D, Name>;
+}>;
 
 /**
  * Schema definition matching @relyio/schema SchemaDefinitionSchema
@@ -674,7 +526,7 @@ declare function getBuiltInRoleActions(roleId: BuiltInRole): readonly RoleAction
  * - singletonContentTypes: Required record of singleton definitions (can be empty {})
  * - queries: Required record of query definitions (can be empty {})
  * - settingsGroups: Optional record of settings groups
- * - roles: Optional array of custom role definitions for access control
+ * - roles: Optional record of custom roles, each keyed by its id
  * - workflow: Optional workflow configuration with approval stages
  *
  * Note: `version` is auto-generated by the backend, not user-defined!
@@ -692,12 +544,12 @@ interface SchemaConfig {
     settingsGroups?: Record<string, SettingsGroupDefinition>;
     /** Asset type definitions (optional) */
     assetTypes?: Record<string, AssetTypeDefinition>;
-    /** Custom role definitions for fine-grained access control (optional) */
-    roles?: RoleDefinition[];
+    /** Custom roles for fine-grained access control, each under its id (optional) */
+    roles?: KeyedRoles;
     /** Global workflow configuration with approval stages (optional) */
     workflow?: WorkflowDefinition;
-    /** View definitions for pre-configured entry list views (optional) */
-    views?: ViewDefinition[];
+    /** Pre-configured entry list views, each under its id (optional) */
+    views?: KeyedViews;
 }
 /**
  * Complete schema definition - Generic version for type inference
@@ -717,7 +569,7 @@ interface SchemaDefinition<TContentTypes extends Record<string, ContentTypeDefin
 /**
  * Typed schema config for type inference
  */
-interface TypedSchemaConfig<TContentTypes extends Record<string, ContentTypeDefinition>, TSingletons extends Record<string, SingletonContentTypeDefinition>, TQueries extends Record<string, QueryDefinition>, TSettings extends Record<string, SettingsGroupDefinition>, TLocales extends readonly LocaleDefinition[] = readonly LocaleDefinition[], TRoles extends readonly RoleDefinition[] = readonly RoleDefinition[], TWorkflow extends WorkflowDefinition | undefined = WorkflowDefinition | undefined, TViews extends readonly ViewDefinition[] = readonly ViewDefinition[], TAssets extends Record<string, AssetTypeDefinition> = Record<string, AssetTypeDefinition>> {
+interface TypedSchemaConfig<TContentTypes extends Record<string, ContentTypeDefinition>, TSingletons extends Record<string, SingletonContentTypeDefinition>, TQueries extends Record<string, QueryDefinition>, TSettings extends Record<string, SettingsGroupDefinition>, TLocales extends readonly LocaleDefinition[] = readonly LocaleDefinition[], TRoles extends KeyedRoles = KeyedRoles, TWorkflow extends WorkflowDefinition | undefined = WorkflowDefinition | undefined, TViews extends KeyedViews = KeyedViews, TAssets extends Record<string, AssetTypeDefinition> = Record<string, AssetTypeDefinition>> {
     locales?: TLocales;
     contentTypes: TContentTypes;
     singletonContentTypes?: TSingletons;
@@ -736,30 +588,26 @@ interface TypedSchemaConfig<TContentTypes extends Record<string, ContentTypeDefi
  * 2. Used for type inference in the SDK client
  *
  * @example
- * import { defineSchema, defineContentType, defineLocale, fields } from '@relyio/sdk/schema'
+ * import { defineSchema, defineContentType, defineLocale, fields, fieldset } from '@relyio/sdk/schema'
  *
  * const enUS = defineLocale('en-US', { displayName: 'English (US)', default: true })
  * const esES = defineLocale('es-ES', { displayName: 'Spanish', fallback: ['en-US'] })
  *
- * const product = defineContentType('product', {
- *   displayName: 'Product',
- *   fields: [
- *     fields.shortText('title', { config: { required: true }, localization: true }),
- *     fields.decimal('price', { config: { min: 0, decimalPlaces: 2 } }),
+ * const product = defineContentType({
+ *   fields: {
+ *     title: fields.shortText({ required: true, localized: true }),
+ *     price: fields.decimal({ min: 0, decimalPlaces: 2 }),
  *     // One value of a fieldset: `{ _type: 'seo', _key, metaTitle?, metaDescription? }`
- *     fields.object('seo', {
- *       config: {
- *         of: {
- *           id: 'seo',
- *           displayName: 'SEO Metadata',
- *           fields: [
- *             fields.shortText('metaTitle', { config: { maxLength: 60 } }),
- *             fields.longText('metaDescription', { config: { maxLength: 160 } }),
- *           ],
+ *     seo: fields.object({
+ *       of: fieldset('seo', {
+ *         displayName: 'SEO metadata',
+ *         fields: {
+ *           metaTitle: fields.shortText({ maxLength: 60 }),
+ *           metaDescription: fields.longText({ maxLength: 160 }),
  *         },
- *       },
+ *       }),
  *     }),
- *   ]
+ *   },
  * })
  *
  * export const schema = defineSchema({
@@ -767,7 +615,38 @@ interface TypedSchemaConfig<TContentTypes extends Record<string, ContentTypeDefi
  *   contentTypes: { product },
  * })
  */
-declare function defineSchema<TContentTypes extends Record<string, ContentTypeDefinition>, TSingletons extends Record<string, SingletonContentTypeDefinition> = Record<string, never>, TQueries extends Record<string, QueryDefinition> = Record<string, never>, TSettings extends Record<string, SettingsGroupDefinition> = Record<string, never>, TLocales extends readonly LocaleDefinition[] = readonly LocaleDefinition[], TRoles extends readonly RoleDefinition[] = readonly RoleDefinition[], TWorkflow extends WorkflowDefinition | undefined = WorkflowDefinition | undefined, TViews extends readonly ViewDefinition[] = readonly ViewDefinition[], TAssets extends Record<string, AssetTypeDefinition> = Record<string, never>>(config: TypedSchemaConfig<TContentTypes, TSingletons, TQueries, TSettings, TLocales, TRoles, TWorkflow, TViews, TAssets>): SchemaDefinition<TContentTypes, TSingletons, TQueries, TSettings, TLocales, TRoles, TWorkflow, TViews, TAssets>;
+declare function defineSchema<TContentTypes extends Record<string, ContentTypeDefinition>, TSingletons extends Record<string, SingletonContentTypeDefinition> = Record<string, never>, TQueries extends Record<string, QueryDefinition> = Record<string, never>, TSettings extends Record<string, SettingsGroupDefinition> = Record<string, never>, TLocales extends readonly LocaleDefinition[] = readonly never[], TRoles extends KeyedRoles = Record<never, never>, TWorkflow extends WorkflowDefinition | undefined = undefined, TViews extends KeyedViews = Record<never, never>, TAssets extends Record<string, AssetTypeDefinition> = Record<string, never>>(config: TypedSchemaConfig<TContentTypes, TSingletons, TQueries, TSettings, TLocales, TRoles, TWorkflow, TViews, TAssets> & NamesChecked<TContentTypes, TSingletons, TSettings, TAssets, TLocales, TRoles, TWorkflow>): SchemaDefinition<TContentTypes, TSingletons, TQueries, TSettings, TLocales, RolesAsList<TRoles>, TWorkflow, ViewsAsList<TViews>, TAssets>;
+/**
+ * What `defineSchema` holds a schema's names to (REL-2416): each section of types against what the
+ * schema declares — a reference's `to` and rich text's `links.to` against its content, singleton and
+ * asset type keys (a reference may point at a singleton: `@relyio/schema`'s
+ * `ResolvedReferenceTarget`), and a Field's `requiredLocales` against its locale codes; its locales'
+ * `fallback` against their codes; the roles its workflow's stages name, and its roles' `includes`,
+ * against the built-in roles and its role keys; and a type's stages against its workflow's stage
+ * keys. Types only; `./checked-names.ts` says how.
+ */
+type NamesChecked<TContentTypes, TSingletons, TSettings, TAssets, TLocales, TRoles, TWorkflow> = {
+    readonly locales?: CheckedLocales<TLocales>;
+    readonly roles?: CheckedRoles<TRoles>;
+    readonly workflow?: CheckedWorkflow<TWorkflow, TRoles>;
+    readonly contentTypes: CheckedSection<TContentTypes, DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow>>;
+    readonly singletonContentTypes?: CheckedSection<TSingletons, DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow>>;
+    readonly settingsGroups?: CheckedSection<TSettings, DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow>>;
+    readonly assetTypes?: CheckedSection<TAssets, DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow>>;
+};
+/** The names a schema declares, for its sections' names to be checked against. */
+interface DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow> {
+    readonly targets: KeysDeclared<TContentTypes> | KeysDeclared<TSingletons> | KeysDeclared<TAssets>;
+    readonly locales: LocaleCodesOf<TLocales>;
+    readonly stages: StagesDeclared<TWorkflow>;
+}
+/**
+ * The roles `defineSchema` returns for the keyed record it was given: the list it compiles to, each
+ * role carrying its key as a literal `id` (REL-2414).
+ */
+type RolesAsList<R extends KeyedRoles> = KeyedRolesAsList<R>;
+/** The views `defineSchema` returns for the ones it was given, as {@link RolesAsList} says of roles. */
+type ViewsAsList<V extends KeyedViews> = KeyedViewsAsList<V>;
 /**
  * Type alias for any schema definition.
  * Uses `any` intentionally for type inference utilities that need to accept any schema.
@@ -802,7 +681,7 @@ type SchemaQueryNames<T extends AnySchemaDefinition> = keyof T['queries'] & stri
  *
  * `settingsGroups`, `assetTypes` and `locales` are optional members of `SchemaDefinition`, so
  * indexing one yields `X | undefined`, which never extends the record — every typed client's
- * `settings()`, `asset()` and `withLocale()` took `never`. The three read through `NonNullable`.
+ * `settings()`, `asset()` and `with({ locale })` took `never`. The three read through `NonNullable`.
  */
 type SchemaSettingsGroupNames<T extends AnySchemaDefinition> = NonNullable<T['settingsGroups']> extends Record<string, SettingsGroupDefinition> ? keyof NonNullable<T['settingsGroups']> & string : never;
 /**
@@ -810,8 +689,11 @@ type SchemaSettingsGroupNames<T extends AnySchemaDefinition> = NonNullable<T['se
  */
 type SchemaAssetTypeNames<T extends AnySchemaDefinition> = NonNullable<T['assetTypes']> extends Record<string, AssetTypeDefinition> ? keyof NonNullable<T['assetTypes']> & string : never;
 /**
- * Get locale codes from a schema
+ * Get locale codes from a schema: the codes its locales declare, or `string` for a schema that
+ * declares none. `defineSchema` now types an absent `locales` as an empty list, so that a Field's
+ * `requiredLocales` is checked against no locale (REL-2416); a read's locale keeps what it took
+ * before — any code — until the read options check it (REL-2417).
  */
-type SchemaLocaleCodes<T extends AnySchemaDefinition> = NonNullable<T['locales']> extends readonly LocaleDefinition[] ? NonNullable<T['locales']>[number]['code'] : never;
+type SchemaLocaleCodes<T extends AnySchemaDefinition> = NonNullable<T['locales']> extends readonly LocaleDefinition[] ? [NonNullable<T['locales']>[number]] extends [never] ? string : NonNullable<T['locales']>[number]['code'] : never;
 
-export { type CachePolicyObject as $, type RoleDefinition as A, BUILT_IN_ROLES as B, defineQuery as C, type QueryDefinition as D, type QueryType as E, type FieldVisibility as F, type FullTextSearch as G, type FetchBlock as H, type AggregateBlock as I, type SearchBlock as J, type WhereValue as K, type LocaleOptions as L, type WhereOperator as M, type HavingOperator as N, type QueryScalar as O, type SortCondition as P, type QueryConfig as Q, ROLE_ACTIONS as R, type SchemaConfig as S, type TextDirection as T, type SortDirection as U, type IncludeDefinition as V, type WhereCondition as W, type IncludeRelationship as X, type SelectMapping as Y, type FilterDefinition as Z, type CachePolicy as _, type SchemaDefinition as a, type IncludeSubQuery as a0, type IncludeSubQueries as a1, type Parameterizable as a2, type QueryParameter as a3, type QueryParameterType as a4, type QueryCardinality as a5, type InferQueryResponse as a6, type InferQueryParams as a7, type FilterOperator as a8, type SchemaContentTypeNames as b, type SchemaSingletonNames as c, defineSchema as d, type SchemaQueryNames as e, type SchemaLocaleCodes as f, type SchemaSettingsGroupNames as g, type SchemaAssetTypeNames as h, type SchemaEntry as i, type SchemaEntryOf as j, defineLocale as k, isLocaleDefinition as l, getLocaleCodes as m, findDefaultLocale as n, getActiveLocales as o, buildFallbackChain as p, type LocaleDefinition as q, defineRole as r, isRoleDefinition as s, isBuiltInRole as t, getBuiltInRoleActions as u, BUILT_IN_ROLE_ACTIONS as v, type BuiltInRole as w, type RoleAction as x, type ResourcePermission as y, type RoleConfig as z };
+export { type AggregateBlock as A, type QueryParameter as B, type CachePolicy as C, type QueryParameterType as D, type QueryCardinality as E, type FullTextSearch as F, type InferQueryResponse as G, type HavingOperator as H, type IncludeDefinition as I, type InferQueryParams as J, type QueryParameterValue as K, type AnyQueryParameters as L, type DeclaredParameters as M, type Parameterizable as P, type QueryConfig as Q, type RolesAsList as R, type SchemaConfig as S, type ViewsAsList as V, type WhereCondition as W, type SchemaDefinition as a, type SchemaContentTypeNames as b, type SchemaSingletonNames as c, defineSchema as d, type SchemaQueryNames as e, type SchemaLocaleCodes as f, type SchemaSettingsGroupNames as g, type SchemaAssetTypeNames as h, type SchemaEntry as i, type SchemaEntryOf as j, defineQuery as k, type QueryDefinition as l, type QueryType as m, type FetchBlock as n, type SearchBlock as o, type WhereValue as p, type WhereOperator as q, type QueryScalar as r, type SortCondition as s, type SortDirection as t, type IncludeRelationship as u, type SelectMapping as v, type FilterDefinition as w, type CachePolicyObject as x, type IncludeSubQuery as y, type IncludeSubQueries as z };