@relyio/sdk 0.17.0 → 0.19.0

package/dist/{define-schema-DgCX9YB7.d.ts → define-schema-BPlZl4a2.d.cts}

@@ -1,4 +1,240 @@
-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-BGoQxqLf.js';
+import { cK as ConditionTree, aS as FieldMember, A as AIConfig, an as FieldValues, ao as DeclaredFields, cR as components, cy as RecordFile, cx as FileUpload, r as KeyedMembers, cS as DisplayFieldOf, s as KeyedMembersOf, aV as ContentTypeDefinition, a$ as SingletonContentTypeDefinition, b4 as SettingsGroupDefinition, aL as LocaleDefinition, bP as RoleDefinition, c6 as WorkflowDefinition, co as ViewDefinition, b9 as AssetTypeDefinition, aX as InferContentType, bS as KeyedRoles, cr as KeyedViews, cT as CheckedLocales, cU as CheckedRoles, cV as CheckedWorkflow, cW as CheckedSection, cX as KeysDeclared, cY as ContributedRecordType, cZ as LocaleCodesOf, c_ as StagesDeclared, bT as KeyedRolesAsList, cs as KeyedViewsAsList } from './define-content-type-BZ6X8GvL.cjs';
+
+/**
+ * A Record type's End-user Policies (spec 4, REL-3883, ADR 0027): what the End users of a
+ * customer's app — and anonymous visitors — may do with the type's Records, action by action.
+ *
+ * A rule is one of three names or a condition:
+ *
+ * - `'owner'` — the End user the Record's Owner field names, and no one else. The type must declare
+ *   an Owner field (`fields.owner()`), and a visitor with no token is never one.
+ * - `'signedIn'` — any End user, whoever owns the Record; never a visitor.
+ * - `'anyone'` — every End user and every visitor.
+ * - a condition tree (`@relyio/schema/lists`) over three roots: `record.*` — the Record's own
+ *   fields, compiled against the stored Records — and the two the asker supplies, `owner` (the End
+ *   user's subject, absent for a visitor, so `owner.exists()` is "signed in") and `claims.*` (what
+ *   their token claims). A condition holds of anyone it admits, a visitor included.
+ *
+ * An action with no rule gives End users and visitors nothing of the type: a type that declares no
+ * `endUsers` is closed to them, so adding a Record type never exposes it by accident. A write
+ * (`create`, `update`, `delete`) is a rule too, or for `create` and `update` `{ when, fields }`:
+ * who may, and which fields they may set (REL-3885 declares the shape and its deploy refusals,
+ * {@link endUserPolicyFaults}; REL-3884 enforces it). Every backend reads the declaration through the
+ * `endUserPolicies` projection, never from here.
+ */
+
+/** The rules a Policy may name rather than spell as a condition. */
+declare const NAMED_POLICY_RULES: readonly ['owner', 'signedIn', 'anyone'];
+type NamedPolicyRule = (typeof NAMED_POLICY_RULES)[number];
+/** One action's rule: a name, or a condition over the Record and the asker. */
+type PolicyRule = NamedPolicyRule | ConditionTree;
+/** A write rule naming the fields an End user may set: who may (`when`), and which (`fields`). */
+interface FieldsWriteRule {
+    readonly when: PolicyRule;
+    readonly fields: readonly string[];
+}
+/**
+ * A `create` or `update` rule: a rule alone — the End users it admits set any field an End user may
+ * set — or `{ when, fields }`, naming the fields.
+ */
+type WriteRule = PolicyRule | FieldsWriteRule;
+/**
+ * What a Record type does with an End user's Records when the identity source reports them deleted
+ * (spec 4): `keep` them, or `delete` them through the pipeline. Only a type with an owner field.
+ */
+declare const OWNER_DELETED_ACTIONS: readonly ['keep', 'delete'];
+type OwnerDeletedAction = (typeof OWNER_DELETED_ACTIONS)[number];
+
+/**
+ * Record type definition matching @relyio/schema RecordTypeSchema (spec 1, ADR 0023)
+ *
+ * A Record is the data an app writes while it runs — an order, a stock level, a review, a cart —
+ * declared in the schema beside the content types and deployed with them. It is live the moment it
+ * is written: no drafts, no publication, no locales, no version history. So a Record type is a
+ * content type's shape without the editorial half: no `workflow`, no `hierarchical`, and its fields
+ * take every kind but `slug` and are never `localized` (deploy refuses both:
+ * `RECORD_TYPE_SLUG_FIELD`, `RECORD_TYPE_LOCALIZED_FIELD`).
+ *
+ * A Record type's references point outward: at content types, asset types and other Record types.
+ * An entry never references a Record — a content type whose reference names a Record type fails to
+ * compile under `defineSchema`, and deploy refuses it (`REFERENCE_TO_RECORD_TYPE`).
+ */
+
+/**
+ * A Record type's configuration in the keyed form (REL-1969), as a content type's: its key under
+ * `defineSchema({ recordTypes })` is its id — one namespace with every content, singleton, settings
+ * group and asset type id — and `fields` a record keyed by Field id. `displayName` is derived from
+ * the key when left out.
+ */
+interface KeyedRecordTypeConfig<R extends KeyedMembers = KeyedMembers> {
+    /** Display name shown in the UI. Derived from the type's key when left out: `orderLine` → "Order line" */
+    displayName?: string;
+    /** Plural display name shown in the UI (e.g., "Orders" for "Order"); not derived */
+    displayNamePlural?: string;
+    /** Description of the Record type */
+    description?: string;
+    /** AI configuration: guidance for agents reading these Records */
+    ai?: AIConfig;
+    /** Access tags for role-based access control */
+    accessTags?: string[];
+    /** The Field a Record's title is in lists and references: one of this type's own (REL-2416) */
+    displayField?: DisplayFieldOf<R>;
+    /**
+     * Sets of this type's own Fields no two Records hold the same values of in one Dataset (REL-3782):
+     * `[['product', 'author']]` keeps one review per product per author. One Field alone says it with
+     * `unique: true` in its own config. A Record writing values another holds is refused, naming the
+     * set and the Record holding them.
+     */
+    unique?: ReadonlyArray<ReadonlyArray<DisplayFieldOf<R>>>;
+    /**
+     * How long each Record lives after its last write, in whole hours or days — `'36h'`, `'7d'`
+     * (REL-3775). Every write moves the deadline on, so an active Record never expires; past it, the
+     * Record is deleted as a delete would delete it. Left out, a Record lives until it is deleted.
+     */
+    expireAfter?: RecordExpiry;
+    /**
+     * What the End users of your app — and anonymous visitors with your publishable key — may do with
+     * this type's Records (spec 4, REL-3883). Left out, they read nothing of it: your server reads
+     * every Record with a secret key, as it always did.
+     *
+     * @example
+     * endUsers: { read: 'owner' } // each End user lists and gets only the Records they own
+     * endUsers: { read: conditionRoot('record').status.eq('visible') } // anyone, visible ones only
+     * endUsers: { update: { when: 'owner', fields: ['note'] } } // an owner changes the note alone
+     */
+    endUsers?: RecordTypeEndUsers<DisplayFieldOf<R>>;
+    /**
+     * What becomes of an End user's Records when your identity source reports them deleted — Clerk's
+     * `user.deleted` (spec 4): `'keep'` them, or `'delete'` them. Only a type with `fields.owner()`.
+     */
+    onOwnerDeleted?: OwnerDeletedAction;
+    /** Each Field under its id, in the order the form shows them */
+    fields: R;
+}
+/**
+ * A Record type's End-user Policies (spec 4, REL-3883), action by action. A rule is `'owner'` — the
+ * End user the type's `fields.owner()` names; `'signedIn'` — any End user; `'anyone'` — every End
+ * user and visitor; or a condition over `record.*` (the Record's fields), `owner` (the End user's
+ * subject, absent for a visitor) and `claims.*` (what their token claims), built with
+ * `conditionRoot`, `and`, `or` and `not`.
+ */
+interface RecordTypeEndUsers<F extends string = string> {
+    /** Who may list, count, facet and get the Records. Left out, End users and visitors may not. */
+    readonly read?: PolicyRule;
+    /**
+     * Who may create a Record — a rule, or `{ when, fields }` naming the fields they may set, each one
+     * of this type's own. Never `'anyone'`, and never an owner, sequence, counter or Private field in
+     * `fields`. Left out, End users create none. RelyIO sets the owner from the End user's token.
+     */
+    readonly create?: RecordWriteRule<F>;
+    /** Who may update a Record, asked of it as stored, as `create`. Left out, End users update none. */
+    readonly update?: RecordWriteRule<F>;
+    /** Who may delete a Record, asked of it as stored. Never `'anyone'`. Left out, none. */
+    readonly delete?: PolicyRule;
+    /**
+     * How many writes a minute one End user makes to the type (REL-3884): 60 when left out. Over it,
+     * a write is refused `RATE_LIMIT_EXCEEDED` with `Retry-After`, before anything is written.
+     */
+    readonly perUser?: {
+        readonly writesPerMinute: number;
+    };
+}
+/**
+ * A `create` or `update` rule whose `fields` name this type's own Fields (REL-3884): the schema's
+ * `WriteRule`, checked as you type.
+ */
+type RecordWriteRule<F extends string = string> = PolicyRule | {
+    readonly when: PolicyRule;
+    readonly fields: readonly F[];
+};
+/** A whole number of hours or days: `'36h'`, `'7d'`. Deploy refuses any other form. */
+type RecordExpiry = `${number}h` | `${number}d`;
+/**
+ * Record type definition - preserves field types for inference
+ */
+interface RecordTypeDefinition<TFields extends readonly FieldMember[] = readonly FieldMember[]> {
+    readonly _tag: 'recordType';
+    /** Absent until `defineSchema` writes the type's key here; deploy takes the key either way. */
+    readonly name?: string;
+    /** Absent in the keyed form until `defineSchema` derives it from the type's key */
+    readonly displayName?: string;
+    readonly displayNamePlural?: string;
+    readonly description?: string;
+    /** AI configuration: guidance for agents reading these Records */
+    readonly ai?: AIConfig;
+    /** Field ID to use as a Record's display title */
+    readonly displayField?: string;
+    readonly accessTags?: string[];
+    /** Sets of Fields no two Records hold the same values of in one Dataset (REL-3782) */
+    readonly unique?: string[][];
+    /** How long each Record lives after its last write (REL-3775) */
+    readonly expireAfter?: RecordExpiry;
+    /** What End users and visitors may do with the Records (REL-3883) */
+    readonly endUsers?: RecordTypeEndUsers;
+    /** What becomes of an End user's Records when they are deleted (spec 4) */
+    readonly onOwnerDeleted?: OwnerDeletedAction;
+    readonly fields: TFields;
+}
+/**
+ * Define a Record type: the shape of the data an app writes while it runs.
+ *
+ * @example
+ * export const inventory = defineRecordType({
+ *   fields: {
+ *     product: fields.reference({ required: true, to: 'product' }),
+ *     stock: fields.integer({ required: true, min: 0 }),
+ *   },
+ * })
+ * // Under its key in defineSchema: recordTypes: { inventory }
+ */
+declare function defineRecordType<R extends KeyedMembers>(config: KeyedRecordTypeConfig<R>): RecordTypeDefinition<readonly KeyedMembersOf<R>[]>;
+/**
+ * Type alias for any Record type definition.
+ */
+type AnyRecordTypeDefinition = RecordTypeDefinition<any>;
+/**
+ * A Record's values as its Record type declares them (REL-3771): a required field always present,
+ * every other one optional, each typed as a read returns it. What `records(type).create` takes.
+ */
+type RecordFieldsOf<T extends AnyRecordTypeDefinition> = FieldValues<DeclaredFields<T>>;
+/**
+ * A Record's values as a write takes them (REL-3781, REL-3824): {@link RecordFieldsOf} without its
+ * Sequences, which RelyIO numbers and a create or an update that sets one is refused — and a File
+ * as the upload holding its bytes (`FileUpload`), never the address only a read answers. What
+ * `records(type).create` and `update` take.
+ */
+type RecordWriteFieldsOf<T extends AnyRecordTypeDefinition> = {
+    [K in keyof Omit<RecordFieldsOf<T>, SequenceIdsOf<T>>]: WrittenAs<RecordFieldsOf<T>[K]>;
+};
+/**
+ * A Record's values as an update takes them (REL-3774, REL-3765): {@link RecordWriteFieldsOf}
+ * without its Counters — a create starts one, and after that it moves only by `increment` and
+ * `decrement`, applied in the write itself; a value an update set would overwrite a move made since
+ * the read, and the server refuses it (`COUNTER_USE_INCREMENT_OR_DECREMENT`). What
+ * `records(type).update` takes.
+ */
+type RecordUpdateFieldsOf<T extends AnyRecordTypeDefinition> = Omit<RecordWriteFieldsOf<T>, CounterIdsOf<T>>;
+/** The ids of a Record type's Counter fields. */
+type CounterIdsOf<T extends AnyRecordTypeDefinition> = Extract<DeclaredFields<T>, {
+    readonly type: 'counter';
+}>['id'];
+/** A value as a write sends it: a File as its upload, every other value as a read answers it. */
+type WrittenAs<V> = V extends RecordFile ? FileUpload : V;
+/** The ids of a Record type's Sequence fields. */
+type SequenceIdsOf<T extends AnyRecordTypeDefinition> = Extract<DeclaredFields<T>, {
+    readonly type: 'sequence';
+}>['id'];
+/**
+ * A Record as a read answers it: its fields, and `_metadata` — the document's `RecordMetadata`, no
+ * locale, publication or version (REL-3771).
+ *
+ * @example
+ * type Order = InferRecordType<typeof order>
+ * // { shopperEmail: string; total: number; …; _metadata: RecordMetadata }
+ */
+type InferRecordType<T extends AnyRecordTypeDefinition> = RecordFieldsOf<T> & {
+    _metadata: components['schemas']['RecordMetadata'];
+};
 
 /**
  * Query definition matching @relyio/schema QueryDefinitionSchema
@@ -544,6 +780,8 @@ interface SchemaConfig {
     settingsGroups?: Record<string, SettingsGroupDefinition>;
     /** Asset type definitions (optional) */
     assetTypes?: Record<string, AssetTypeDefinition>;
+    /** Record type definitions: the data the app writes while it runs (optional, spec 1) */
+    recordTypes?: Record<string, RecordTypeDefinition>;
     /** Custom roles for fine-grained access control, each under its id (optional) */
     roles?: KeyedRoles;
     /** Global workflow configuration with approval stages (optional) */
@@ -554,7 +792,7 @@ interface SchemaConfig {
 /**
  * Complete schema definition - Generic version for type inference
  */
-interface SchemaDefinition<TContentTypes extends Record<string, ContentTypeDefinition> = Record<string, ContentTypeDefinition>, TSingletons extends Record<string, SingletonContentTypeDefinition> = Record<string, SingletonContentTypeDefinition>, TQueries extends Record<string, QueryDefinition> = Record<string, QueryDefinition>, TSettings extends Record<string, SettingsGroupDefinition> = 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 SchemaDefinition<TContentTypes extends Record<string, ContentTypeDefinition> = Record<string, ContentTypeDefinition>, TSingletons extends Record<string, SingletonContentTypeDefinition> = Record<string, SingletonContentTypeDefinition>, TQueries extends Record<string, QueryDefinition> = Record<string, QueryDefinition>, TSettings extends Record<string, SettingsGroupDefinition> = 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>, TRecords extends Record<string, RecordTypeDefinition> = Record<string, RecordTypeDefinition>> {
     readonly _tag: 'schema';
     readonly locales?: TLocales;
     readonly contentTypes: TContentTypes;
@@ -562,6 +800,7 @@ interface SchemaDefinition<TContentTypes extends Record<string, ContentTypeDefin
     readonly queries: TQueries;
     readonly settingsGroups?: TSettings;
     readonly assetTypes?: TAssets;
+    readonly recordTypes?: TRecords;
     readonly roles?: TRoles;
     readonly workflow?: TWorkflow;
     readonly views?: TViews;
@@ -569,13 +808,14 @@ 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 KeyedRoles = KeyedRoles, TWorkflow extends WorkflowDefinition | undefined = WorkflowDefinition | undefined, TViews extends KeyedViews = KeyedViews, 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>, TRecords extends Record<string, RecordTypeDefinition> = Record<string, RecordTypeDefinition>> {
     locales?: TLocales;
     contentTypes: TContentTypes;
     singletonContentTypes?: TSingletons;
     queries?: TQueries;
     settingsGroups?: TSettings;
     assetTypes?: TAssets;
+    recordTypes?: TRecords;
     roles?: TRoles;
     workflow?: TWorkflow;
     views?: TViews;
@@ -615,7 +855,7 @@ 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 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>;
+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>, TRecords extends Record<string, RecordTypeDefinition> = Record<string, never>>(config: TypedSchemaConfig<TContentTypes, TSingletons, TQueries, TSettings, TLocales, TRoles, TWorkflow, TViews, TAssets, TRecords> & NamesChecked<TContentTypes, TSingletons, TSettings, TAssets, TRecords, TLocales, TRoles, TWorkflow>): SchemaDefinition<TContentTypes, TSingletons, TQueries, TSettings, TLocales, RolesAsList<TRoles>, TWorkflow, ViewsAsList<TViews>, TAssets, TRecords>;
 /**
  * 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
@@ -625,7 +865,7 @@ declare function defineSchema<TContentTypes extends Record<string, ContentTypeDe
  * 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> = {
+type NamesChecked<TContentTypes, TSingletons, TSettings, TAssets, TRecords, TLocales, TRoles, TWorkflow> = {
     readonly locales?: CheckedLocales<TLocales>;
     readonly roles?: CheckedRoles<TRoles>;
     readonly workflow?: CheckedWorkflow<TWorkflow, TRoles>;
@@ -633,10 +873,14 @@ type NamesChecked<TContentTypes, TSingletons, TSettings, TAssets, TLocales, TRol
     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>>;
+    readonly recordTypes?: CheckedSection<TRecords, DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow, TRecords>>;
 };
-/** 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>;
+/**
+ * The names a schema declares, for its sections' names to be checked against. `TRecords` is the
+ * Record types a section's references may name: none for an entry type's.
+ */
+interface DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow, TRecords = never> {
+    readonly targets: KeysDeclared<TContentTypes> | KeysDeclared<TSingletons> | KeysDeclared<TAssets> | KeysDeclared<TRecords> | ([TRecords] extends [never] ? never : ContributedRecordType);
     readonly locales: LocaleCodesOf<TLocales>;
     readonly stages: StagesDeclared<TWorkflow>;
 }
@@ -651,7 +895,7 @@ 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.
  */
-type AnySchemaDefinition = SchemaDefinition<any, any, any, any, any, any, any, any, any>;
+type AnySchemaDefinition = SchemaDefinition<any, any, any, any, any, any, any, any, any, any>;
 /**
  * Get content type names from a schema
  */
@@ -688,6 +932,10 @@ type SchemaSettingsGroupNames<T extends AnySchemaDefinition> = NonNullable<T['se
  * Get asset type names from a schema
  */
 type SchemaAssetTypeNames<T extends AnySchemaDefinition> = NonNullable<T['assetTypes']> extends Record<string, AssetTypeDefinition> ? keyof NonNullable<T['assetTypes']> & string : never;
+/**
+ * Get Record type names from a schema (spec 1), read through `NonNullable` as asset types are
+ */
+type SchemaRecordTypeNames<T extends AnySchemaDefinition> = NonNullable<T['recordTypes']> extends Record<string, RecordTypeDefinition> ? keyof NonNullable<T['recordTypes']> & string : never;
 /**
  * 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
@@ -696,4 +944,4 @@ type SchemaAssetTypeNames<T extends AnySchemaDefinition> = NonNullable<T['assetT
  */
 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 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 };
+export { type Parameterizable as $, type AnyRecordTypeDefinition as A, type WhereCondition as B, type WhereValue as C, type WhereOperator as D, type QueryScalar as E, type FieldsWriteRule as F, type SortCondition as G, type HavingOperator as H, type InferRecordType as I, type SortDirection as J, type KeyedRecordTypeConfig as K, type IncludeDefinition as L, type IncludeRelationship as M, type NamedPolicyRule as N, type OwnerDeletedAction as O, type PolicyRule as P, type QueryConfig as Q, type RolesAsList as R, type SchemaConfig as S, type SelectMapping as T, type FilterDefinition as U, type ViewsAsList as V, type WriteRule as W, type CachePolicy as X, type CachePolicyObject as Y, type IncludeSubQuery as Z, type IncludeSubQueries as _, type SchemaDefinition as a, type QueryParameter as a0, type QueryParameterType as a1, type QueryCardinality as a2, type InferQueryResponse as a3, type InferQueryParams as a4, type QueryParameterValue as a5, type AnyQueryParameters as a6, type DeclaredParameters as a7, 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 SchemaRecordTypeNames as i, type SchemaEntry as j, type SchemaEntryOf as k, defineRecordType as l, type RecordTypeDefinition as m, type RecordExpiry as n, type RecordFieldsOf as o, type RecordTypeEndUsers as p, type RecordUpdateFieldsOf as q, type RecordWriteFieldsOf as r, type RecordWriteRule as s, defineQuery as t, type QueryDefinition as u, type QueryType as v, type FullTextSearch as w, type FetchBlock as x, type AggregateBlock as y, type SearchBlock as z };