@relyio/sdk 0.11.0 → 0.13.0

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

@@ -1,183 +1,4 @@
-import { A as AnyFieldDefinition, c as FieldDefinition, k as AIConfig, v as FieldSchemaContext, x as FieldValues, y as DeclaredFields, aK as components, P as ContentTypeDefinition, a0 as SingletonContentTypeDefinition, aH as WorkflowDefinition, a9 as AssetTypeDefinition, W as InferContentType } from './define-content-type-ENAod5Ve.cjs';
-
-/**
- * Component definition matching @relyio/schema ComponentSchema
- *
- * Components are reusable field groups that can be embedded in content types.
- */
-
-interface ComponentReusabilityMetadata {
-    /** Minimum number of usages to be considered reusable */
-    minUsageCount?: number;
-    /** Maximum complexity score */
-    maxComplexity?: number;
-    /** Recommended usage contexts */
-    recommendedUsage?: string[];
-}
-interface ComponentValidationMetadata {
-    /** Whether nesting of components is allowed */
-    allowNesting?: boolean;
-    /** Maximum nesting depth */
-    maxNestingDepth?: number;
-    /** How to resolve field ID conflicts */
-    conflictResolution?: 'error' | 'component-wins' | 'field-wins' | 'prefix';
-}
-interface ComponentMetadata {
-    reusability?: ComponentReusabilityMetadata;
-    validation?: ComponentValidationMetadata;
-}
-/**
- * Component configuration. Generic over its fields, as a content type's is, so a component field
- * reads as an object typed by them (`INV-SS-TYPES-INFERRED`).
- */
-interface ComponentConfig<TFields extends readonly AnyFieldDefinition[] = FieldDefinition[]> {
-    /** Display name shown in the UI */
-    displayName?: string;
-    /** Description of the component */
-    description?: string;
-    /** AI configuration for content generation and review */
-    ai?: AIConfig;
-    /** Whether this component is deprecated */
-    deprecated?: boolean;
-    /** Component fields */
-    fields: TFields;
-    /** Component metadata for validation and reusability */
-    metadata?: ComponentMetadata;
-}
-/**
- * Component definition - preserves field types for inference
- */
-interface ComponentDefinition<TFields extends readonly AnyFieldDefinition[] = FieldDefinition[]> {
-    readonly _tag: 'component';
-    readonly name: string;
-    readonly displayName?: string;
-    readonly description?: string;
-    /** AI configuration for content generation and review */
-    readonly ai?: AIConfig;
-    readonly deprecated?: boolean;
-    readonly fields: TFields;
-    readonly metadata?: ComponentMetadata;
-}
-/**
- * Define a reusable component (field group)
- *
- * @example
- * const seoComponent = defineComponent('seoMetadata', {
- *   displayName: 'SEO Metadata',
- *   description: 'Common SEO fields for all content types',
- *   fields: [
- *     fields.shortText('metaTitle', {
- *       config: { maxLength: 60 },
- *       ui: { displayName: 'Meta Title' }
- *     }),
- *     fields.longText('metaDescription', {
- *       config: { maxLength: 160 },
- *       ui: { displayName: 'Meta Description' }
- *     }),
- *     // An image is an entry of an asset type, which a reference points at
- *     fields.reference('ogImage', {
- *       config: { to: 'productPhoto' },
- *       ui: { displayName: 'Open Graph Image' }
- *     }),
- *   ]
- * })
- *
- * // Use in a content type:
- * const product = defineContentType('product', {
- *   displayName: 'Product',
- *   fields: [
- *     fields.shortText('title', { config: { required: true } }),
- *     fields.component('seo', 'seoMetadata'),  // Reference the component
- *   ]
- * })
- */
-declare function defineComponent<TFields extends readonly AnyFieldDefinition[]>(name: string, config: ComponentConfig<TFields>): ComponentDefinition<TFields>;
-
-/**
- * Settings group definition matching @relyio/schema SettingsGroupSchema
- *
- * Settings groups are for project-level configuration that doesn't fit
- * into content types (e.g., API keys, feature flags, integrations).
- *
- * Uses advanced TypeScript generics to preserve literal field IDs through
- * the type system, enabling full autocomplete in SDK methods.
- */
-
-/**
- * Settings group configuration - generic to preserve field types
- */
-interface SettingsGroupConfig<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
-    /** Display name shown in the UI */
-    displayName: string;
-    /** Description of the settings group */
-    description?: string;
-    /** AI configuration for content generation and review */
-    ai?: AIConfig;
-    /** Access tags for role-based access control */
-    accessTags?: string[];
-    /** Settings fields - preserves literal types */
-    fields: TFields;
-}
-/**
- * Settings group definition - preserves field types for inference
- */
-interface SettingsGroupDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
-    readonly _tag: 'settingsGroup';
-    readonly name: string;
-    readonly displayName: string;
-    readonly description?: string;
-    /** AI configuration for content generation and review */
-    readonly ai?: AIConfig;
-    readonly accessTags?: string[];
-    readonly fields: TFields;
-}
-/**
- * Define a settings group
- *
- * The generic type parameter preserves the literal field IDs through the type
- * system, enabling autocomplete in SDK methods.
- *
- * @example
- * const integrations = defineSettingsGroup('integrations', {
- *   displayName: 'Integrations',
- *   description: 'Third-party service integrations',
- *   fields: [
- *     fields.shortText('stripeApiKey', {
- *       config: { required: true },
- *       ui: { displayName: 'Stripe API Key' }
- *     }),
- *     fields.shortText('sendgridApiKey', {
- *       ui: { displayName: 'SendGrid API Key' }
- *     }),
- *     fields.boolean('enableAnalytics', {
- *       config: { defaultValue: true },
- *       ui: { displayName: 'Enable Analytics' }
- *     }),
- *   ]
- * })
- */
-declare function defineSettingsGroup<TFields extends readonly AnyFieldDefinition[]>(name: string, config: SettingsGroupConfig<TFields>): SettingsGroupDefinition<TFields>;
-/**
- * Type alias for any settings group definition.
- */
-type AnySettingsGroupDefinition = SettingsGroupDefinition<any>;
-/**
- * What a read reports about a settings group beside its fields: the committed document's
- * `SettingsGroupMetadata`, read through `http/api-schema.ts` rather than declared again here.
- *
- * It names the group by `id` and `groupId`, carries the per-locale facts and the version history
- * of `locale`, and says when the group was last written — there is no `createdAt`. The hand-written
- * type this replaces declared a `key`, a `groupType` and a `createdAt` the wire does not carry, and
- * `Date` timestamps where it sends ISO 8601 strings.
- */
-type SettingsGroupMetadata = components['schemas']['SettingsGroupMetadata'];
-/**
- * Infer the TypeScript type from a settings group definition: every field typed as a read returns it
- * (`schema/infer-fields.ts`), plus `_metadata`. `S` is the schema, as for `InferContentType`.
- */
-type InferSettingsGroup<T extends AnySettingsGroupDefinition, S extends FieldSchemaContext | undefined = undefined> = FieldValues<DeclaredFields<T>, S> & {
-    _metadata: SettingsGroupMetadata;
-};
+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';
 
 /**
  * Query definition matching @relyio/schema QueryDefinitionSchema
@@ -255,7 +76,12 @@ type WhereValue = string | number | boolean | (string | number | boolean)[] | Wh
 type WhereCondition = Record<string, WhereValue>;
 type SortDirection = 'asc' | 'desc';
 type SortCondition = Record<string, SortDirection> | Record<string, SortDirection>[];
-/** `products(status=active).count as productCount`: a relationship, filtered and counted. */
+/**
+ * A relationship joined by name — a reference the fetched type declares, or a reverse one another
+ * type declares to it (`reviews`) — optionally filtered, counted and aliased:
+ * `{ relationship: 'products', where: { status: 'active' }, aggregate: 'count', alias: 'productCount' }`.
+ * `relationship` is a name, with no parentheses. A `select` reads what it joins.
+ */
 type IncludeRelationship = {
     relationship: string;
     where?: WhereCondition;
@@ -269,23 +95,14 @@ type IncludeRelationship = {
     alias?: string;
 };
 /**
- * A path, the fields to return from it, the references to expand beneath it and which entries to
- * join — `{ path: 'items.product', fields: ['title'], include: ['brand'] }`. The one object form of a
- * path: `IncludePath`, `{ path, include: string[], where }`, described a subset of this one and is
- * gone. One level beneath, as the schema declares it: a deeper `include` inside a nested path is
- * refused at deploy.
+ * What a fetch includes (REL-2035). A string is an **include path**, the grammar `?include=` and the
+ * SDK's `include()` read: field ids joined by `.`, crossing lists, page builders, objects and
+ * references, each hop written out, with the fields to return in parentheses —
+ * `'sections.customers.logo'`, `'sections.features(name,slug)'`. The query returns what
+ * `GET …?include=` returns for the same paths. A path's entries are expanded after the read, so a
+ * `select` cannot read them: join a relationship for that ({@link IncludeRelationship}).
  */
-type IncludeSelection = {
-    path: string;
-    fields?: string[];
-    include?: (string | {
-        path: string;
-        fields?: string[];
-        where?: WhereCondition;
-    })[];
-    where?: WhereCondition;
-};
-type IncludeDefinition = string | string[] | (string | IncludeRelationship | IncludeSelection)[];
+type IncludeDefinition = string | (string | IncludeRelationship)[];
 type SelectMapping = Record<string, string>;
 /** `filters` are `where` conditions bound at call time: the same operators, written the same way. */
 type FilterOperator = WhereOperator;
@@ -842,223 +659,6 @@ declare function isBuiltInRole(roleId: string): roleId is BuiltInRole;
  */
 declare function getBuiltInRoleActions(roleId: BuiltInRole): readonly RoleAction[];
 
-/**
- * View definitions for SDK schema
- *
- * Views define pre-configured entry list configurations with filters,
- * columns, and metadata display settings.
- */
-/**
- * View scope defines which content types a view applies to.
- *
- * When using `contentTypes` (plural) or `all`, the view displays entries
- * from multiple content types. In this case:
- *
- * - Columns/fields may only exist on some content types
- * - For entries where a field doesn't exist, the UI displays "—"
- * - System fields (id, status, createdAt, updatedAt) exist on all entries
- * - Filters on non-existent fields are skipped for that entry type
- *
- * Example display:
- * | Content Type | title | author | productCode |
- * |--------------|-------|--------|-------------|
- * | post         | ✓     | ✓      | —           |
- * | product      | ✓     | —      | ✓           |
- */
-/**
- * Scope for a single content type
- */
-interface ContentTypeScopeConfig {
-    type: 'contentType';
-    contentType: string;
-}
-/**
- * Scope for multiple content types
- *
- * Fields not present on all content types will show "—" in the UI
- */
-interface ContentTypesScopeConfig {
-    type: 'contentTypes';
-    contentTypes: string[];
-}
-/**
- * Scope for an entry type (content, singleton, settings, asset)
- */
-interface EntryTypeScopeConfig {
-    type: 'entryType';
-    entryType: 'content' | 'singleton' | 'settings' | 'asset';
-}
-/**
- * Scope for all content
- *
- * Fields not present on all content types will show "—" in the UI
- */
-interface AllScopeConfig {
-    type: 'all';
-}
-/**
- * View scope options
- */
-type ViewScopeConfig = ContentTypeScopeConfig | ContentTypesScopeConfig | EntryTypeScopeConfig | AllScopeConfig;
-/**
- * The operators a view filter may name: the schema's `FILTER_OPERATORS`, which deploy parses a view
- * with and the read core compiles every one of.
- *
- * This list used to be its own: ten of its names — `doesNotContain`, `isNotEmpty`, `isOnOrBefore`,
- * `isOnOrAfter`, `tomorrow`, `lastWeek`, `lastMonth`, `includesAll`, `includesAny`, `excludes` —
- * are none the schema declares, so a view naming one was refused at deploy, and six the schema does
- * declare — `notContains`, `notIncludes`, `isOn`, `isBetween`, `thisYear`, `hasValue` — could not be
- * written here, so a view pulled by `relyio generate-types` that named one did not compile.
- * `@relyio/codegen-typescript`'s `src/__tests__/sdk-definition-config.types.ts` holds the two to each
- * other (REL-1457).
- */
-type ViewFilterOperator = 'is' | 'isNot' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'isAnyOf' | 'isNoneOf' | 'includes' | 'notIncludes' | 'isTrue' | 'isFalse' | 'equals' | 'notEquals' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual' | 'between' | 'isOn' | 'isBefore' | 'isAfter' | 'isBetween' | 'inTheLast' | 'inTheNext' | 'today' | 'yesterday' | 'thisWeek' | 'thisMonth' | 'thisYear' | 'isEmpty' | 'hasValue';
-/** A span of time back or forward from now, for `inTheLast` and `inTheNext`. */
-interface ViewFilterRelativeDate {
-    amount: number;
-    unit: 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
-}
-/** What a filter compares against: the schema's `FilterValueSchema`. */
-type ViewFilterValue = string | number | boolean | null | (string | number)[] | {
-    from: string | number | Date;
-    to: string | number | Date;
-} | ViewFilterRelativeDate | Date;
-/**
- * One filter of a view: a field, an operator and the value it compares with.
- */
-interface ViewFilterCondition {
-    /**
-     * The Property to filter on, as the Studio's entry list names it: `fields.<id>` for a field your
-     * schema declares (`fields.seo.title` for a component's sub-field), `_metadata.<id>` for a system
-     * field — `_metadata.status`, `_metadata.createdAt`, `_metadata.updatedAt`. So a field called
-     * `status` (`fields.status`) and the entry's own lifecycle (`_metadata.status`) are both
-     * filterable.
-     */
-    field: string;
-    /**
-     * Filter operator
-     */
-    operator: ViewFilterOperator;
-    /**
-     * Filter value (optional for some operators like isEmpty)
-     */
-    value?: ViewFilterValue;
-}
-/**
- * A view's filter. A view's filters are a flat list joined by AND — the Filters the Studio's entry
- * list takes, each drawn as a Chip — so there is no filter group: an OR within one field is
- * `isAnyOf`. RelyIO refuses a group by name when you deploy.
- */
-type ViewFilter = ViewFilterCondition;
-/**
- * View definition configuration
- */
-interface ViewConfig {
-    /**
-     * Display name for the view
-     */
-    name: string;
-    /**
-     * URL-friendly slug for the view, used in Studio URLs like /studio/views/:slug. Absent, the
-     * platform derives one from the id when it reads the schema.
-     */
-    slug?: string;
-    /**
-     * Optional description for the view
-     */
-    description?: string;
-    /**
-     * Icon (emoji or icon name) for the view
-     */
-    icon?: string;
-    /**
-     * Color for the view in the sidebar
-     */
-    color?: string;
-    /**
-     * View scope - what content types this view applies to
-     */
-    scope: ViewScopeConfig;
-    /**
-     * Filter conditions (optional), combined with AND. A flat list: an OR within one field is
-     * `isAnyOf`, and there is no filter group.
-     *
-     * Deploy judges each against the entries the view lists: the field must be one they can be
-     * narrowed by, and it must offer the operator — a boolean field takes `is` with `true` or
-     * `false`, for example, not `isTrue`.
-     */
-    filters?: ViewFilter[];
-    /**
-     * Column field IDs to display (optional)
-     * If not specified, uses default columns
-     */
-    columns?: string[];
-    /**
-     * Metadata field IDs to show under title (max 3)
-     */
-    metadataFields?: string[];
-    /**
-     * Default sort (optional). `field` names the Property to sort by, as a filter names one —
-     * `fields.<id>` or `_metadata.<id>` — and deploy refuses one the view's entries cannot be sorted
-     * by. `columns` and `metadataFields` are display settings and name field IDs as written.
-     */
-    sort?: {
-        field: string;
-        direction: 'asc' | 'desc';
-    };
-    /**
-     * Sort order in the sidebar (lower = higher priority)
-     */
-    sortOrder?: number;
-}
-/**
- * Complete view definition with ID
- */
-interface ViewDefinition extends ViewConfig {
-    /**
-     * Internal tag for type discrimination
-     */
-    readonly _tag: 'view';
-    /**
-     * Unique view ID (must start with a letter)
-     */
-    readonly id: string;
-}
-/**
- * Define a schema view
- *
- * Views are pre-configured entry list displays with filters,
- * columns, and metadata settings.
- *
- * @example
- * const featuredPosts = defineView('featuredPosts', {
- *   name: 'Featured Posts',
- *   description: 'Blog posts marked as featured',
- *   icon: '📝',
- *   scope: { type: 'contentType', contentType: 'post' },
- *   filters: [
- *     { field: 'fields.featured', operator: 'is', value: true }
- *   ],
- *   columns: ['title', 'author', 'publishedAt'],
- *   metadataFields: ['category', 'views'],
- *   sort: { field: '_metadata.publishedAt', direction: 'desc' }
- * })
- *
- * @example
- * const archivedContent = defineView('archivedContent', {
- *   name: 'Archived',
- *   scope: { type: 'all' },
- *   filters: [
- *     { field: '_metadata.status', operator: 'is', value: 'archived' }
- *   ]
- * })
- *
- * @param id - Unique view ID (must start with a letter)
- * @param config - View configuration
- * @returns View definition object
- */
-declare function defineView(id: string, config: ViewConfig): ViewDefinition;
-
 /**
  * Schema definition matching @relyio/schema SchemaDefinitionSchema
  *
@@ -1071,7 +671,6 @@ declare function defineView(id: string, config: ViewConfig): ViewDefinition;
  * Matches the SchemaDefinitionSchema from @relyio/schema:
  * - locales: Optional array of locale definitions for multi-language support
  * - contentTypes: Required record of content type definitions
- * - components: Required record of component definitions (can be empty {})
  * - singletonContentTypes: Required record of singleton definitions (can be empty {})
  * - queries: Required record of query definitions (can be empty {})
  * - settingsGroups: Optional record of settings groups
@@ -1085,8 +684,6 @@ interface SchemaConfig {
     locales?: LocaleDefinition[];
     /** Content type definitions (required) */
     contentTypes: Record<string, ContentTypeDefinition>;
-    /** Reusable component definitions (required, can be empty) */
-    components?: Record<string, ComponentDefinition>;
     /** Singleton content type definitions (required, can be empty) */
     singletonContentTypes?: Record<string, SingletonContentTypeDefinition>;
     /** Predefined query definitions (required, can be empty) */
@@ -1105,11 +702,10 @@ interface SchemaConfig {
 /**
  * Complete schema definition - Generic version for type inference
  */
-interface SchemaDefinition<TContentTypes extends Record<string, ContentTypeDefinition> = Record<string, ContentTypeDefinition>, TComponents extends Record<string, ComponentDefinition> = Record<string, ComponentDefinition>, 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>> {
     readonly _tag: 'schema';
     readonly locales?: TLocales;
     readonly contentTypes: TContentTypes;
-    readonly components: TComponents;
     readonly singletonContentTypes: TSingletons;
     readonly queries: TQueries;
     readonly settingsGroups?: TSettings;
@@ -1121,10 +717,9 @@ interface SchemaDefinition<TContentTypes extends Record<string, ContentTypeDefin
 /**
  * Typed schema config for type inference
  */
-interface TypedSchemaConfig<TContentTypes extends Record<string, ContentTypeDefinition>, TComponents extends Record<string, ComponentDefinition>, 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 readonly RoleDefinition[] = readonly RoleDefinition[], TWorkflow extends WorkflowDefinition | undefined = WorkflowDefinition | undefined, TViews extends readonly ViewDefinition[] = readonly ViewDefinition[], TAssets extends Record<string, AssetTypeDefinition> = Record<string, AssetTypeDefinition>> {
     locales?: TLocales;
     contentTypes: TContentTypes;
-    components?: TComponents;
     singletonContentTypes?: TSingletons;
     queries?: TQueries;
     settingsGroups?: TSettings;
@@ -1141,35 +736,38 @@ interface TypedSchemaConfig<TContentTypes extends Record<string, ContentTypeDefi
  * 2. Used for type inference in the SDK client
  *
  * @example
- * import { defineSchema, defineContentType, defineComponent, defineLocale, fields } from '@relyio/sdk/schema'
+ * import { defineSchema, defineContentType, defineLocale, fields } 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 seoComponent = defineComponent('seo', {
- *   displayName: 'SEO Metadata',
- *   fields: [
- *     fields.shortText('metaTitle', { config: { maxLength: 60 } }),
- *     fields.longText('metaDescription', { config: { maxLength: 160 } }),
- *   ]
- * })
- *
  * const product = defineContentType('product', {
  *   displayName: 'Product',
  *   fields: [
  *     fields.shortText('title', { config: { required: true }, localization: true }),
  *     fields.decimal('price', { config: { min: 0, decimalPlaces: 2 } }),
- *     fields.component('seo', 'seo'),
+ *     // 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 } }),
+ *           ],
+ *         },
+ *       },
+ *     }),
  *   ]
  * })
  *
  * export const schema = defineSchema({
  *   locales: [enUS, esES],
  *   contentTypes: { product },
- *   components: { seo: seoComponent },
  * })
  */
-declare function defineSchema<TContentTypes extends Record<string, ContentTypeDefinition>, TComponents extends Record<string, ComponentDefinition> = Record<string, never>, 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, TComponents, TSingletons, TQueries, TSettings, TLocales, TRoles, TWorkflow, TViews, TAssets>): SchemaDefinition<TContentTypes, TComponents, 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 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>;
 /**
  * Type alias for any schema definition.
  * Uses `any` intentionally for type inference utilities that need to accept any schema.
@@ -1181,7 +779,7 @@ type AnySchemaDefinition = SchemaDefinition<any, any, any, any, any, any, any, a
 type SchemaContentTypeNames<T extends AnySchemaDefinition> = keyof T['contentTypes'] & string;
 /**
  * An entry of content type `K`, typed by schema `T` as a read returns it — what `content(K)` reads,
- * with references and components resolved against `T` (`INV-SS-TYPES-INFERRED`).
+ * with references resolved against `T` (`INV-SS-TYPES-INFERRED`).
  */
 type SchemaEntry<T extends AnySchemaDefinition, K extends SchemaContentTypeNames<T>> = InferContentType<T['contentTypes'][K], T>;
 /**
@@ -1216,4 +814,4 @@ type SchemaAssetTypeNames<T extends AnySchemaDefinition> = NonNullable<T['assetT
  */
 type SchemaLocaleCodes<T extends AnySchemaDefinition> = NonNullable<T['locales']> extends readonly LocaleDefinition[] ? NonNullable<T['locales']>[number]['code'] : never;
 
-export { type ViewFilterCondition as $, defineRole as A, isRoleDefinition as B, type ComponentConfig as C, isBuiltInRole as D, getBuiltInRoleActions as E, BUILT_IN_ROLES as F, BUILT_IN_ROLE_ACTIONS as G, type BuiltInRole as H, type InferSettingsGroup as I, type RoleAction as J, type ResourcePermission as K, type LocaleOptions as L, type FieldVisibility as M, type RoleConfig as N, type RoleDefinition as O, defineView as P, type ContentTypeScopeConfig as Q, ROLE_ACTIONS as R, type SchemaConfig as S, type TextDirection as T, type ContentTypesScopeConfig as U, type ViewScopeConfig as V, type EntryTypeScopeConfig as W, type AllScopeConfig as X, type ViewFilterOperator as Y, type ViewFilterValue as Z, type ViewFilterRelativeDate as _, type SchemaDefinition as a, type ViewFilter as a0, type ViewConfig as a1, type ViewDefinition as a2, defineQuery as a3, type QueryConfig as a4, type QueryDefinition as a5, type QueryType as a6, type FullTextSearch as a7, type FetchBlock as a8, type AggregateBlock as a9, type SearchBlock as aa, type WhereCondition as ab, type WhereValue as ac, type WhereOperator as ad, type HavingOperator as ae, type QueryScalar as af, type SortCondition as ag, type SortDirection as ah, type IncludeDefinition as ai, type IncludeRelationship as aj, type IncludeSelection as ak, type SelectMapping as al, type FilterDefinition as am, type CachePolicy as an, type CachePolicyObject as ao, type IncludeSubQuery as ap, type IncludeSubQueries as aq, type Parameterizable as ar, type QueryParameter as as, type QueryParameterType as at, type QueryCardinality as au, type InferQueryResponse as av, type InferQueryParams as aw, type FilterOperator as ax, 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, defineComponent as r, type ComponentDefinition as s, type ComponentMetadata as t, type ComponentReusabilityMetadata as u, type ComponentValidationMetadata as v, defineSettingsGroup as w, type SettingsGroupConfig as x, type SettingsGroupDefinition as y, type SettingsGroupMetadata as z };
+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 };