@relyio/sdk 0.12.0 → 0.14.0

package/dist/define-schema-mrEZbY1h.d.ts

@@ -1,1034 +0,0 @@
-import { a4 as ContentTypeDefinition, ab as SingletonContentTypeDefinition, ah as SettingsGroupDefinition, aU as WorkflowDefinition, am as AssetTypeDefinition, a6 as InferContentType } from './include-paths-CrJNTsMl.js';
-
-/**
- * Query definition matching @relyio/schema QueryDefinitionSchema
- *
- * Queries define predefined API endpoints with filtering, sorting, and caching.
- *
- * This is a hand-written mirror: `@relyio/sdk` is published standalone and does not depend on
- * `@relyio/schema`, so a field added there has to be added here too. When the two drifted, `limit`
- * was the casualty — the documentation writes `limit: '${limit?20}'` and this file said `number` —
- * and so were `fullText` and `type`, which a query pulled by `relyio generate-types` carried and
- * this refused. `@relyio/codegen-typescript`'s `src/__tests__/sdk-definition-config.types.ts` now
- * fails to compile when a key, whether it is required, or the values it accepts differs from the
- * schema's, block by block (REL-1457).
- */
-/** One value a query clause compares with. */
-type QueryScalar = string | number | boolean;
-/**
- * The operators `where` and `filters` compare a field with — `{ price: { gte: 10 } }`.
- *
- * 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.
- * `@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;
-    /** Not equal to */
-    ne?: QueryScalar;
-    /** Greater than */
-    gt?: QueryScalar;
-    /** Greater than or equal to */
-    gte?: QueryScalar;
-    /** Less than */
-    lt?: QueryScalar;
-    /** Less than or equal to */
-    lte?: QueryScalar;
-    /** One of the values given */
-    in?: QueryScalar[] | string;
-    /** None of the values given */
-    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;
-    /** 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;
-};
-/**
- * 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.
- */
-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;
-};
-type WhereValue = string | number | boolean | (string | number | boolean)[] | WhereOperator;
-type WhereCondition = Record<string, WhereValue>;
-type SortDirection = 'asc' | 'desc';
-type SortCondition = Record<string, SortDirection> | Record<string, SortDirection>[];
-/**
- * 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;
-    /**
-     * What the include answers instead of the entries it joins. `count` is the one modifier: `sum`,
-     * `avg`, `min` and `max` name no field to reduce — select one, like `products.price.sum` — and
-     * the service refuses them (REL-1479).
-     */
-    aggregate?: 'count';
-    /** The name the include answers under; the relationship's name when absent */
-    alias?: string;
-};
-/**
- * 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 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;
-type FilterDefinition = Record<string, string | FilterOperator>;
-/** A value that is either a literal or a `${param}` / `${param?default}` expression. */
-type Parameterizable<T> = T | string;
-type QueryParameterType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
-/**
- * A declared query parameter.
- *
- * Every `${...}` in a query and every `{name}` segment of its endpoint already declares one; this
- * block adds a type and constraints. Nothing is inferred from a parameter's name.
- */
-interface QueryParameter {
-    /** The parameter, as it appears in `${...}` or in an endpoint segment */
-    name: string;
-    /** Coerces the caller's value; a value that will not coerce is a 400 */
-    type?: QueryParameterType;
-    /** Overrides what the query's own expressions say */
-    required?: boolean;
-    /** Used when the caller supplies nothing */
-    default?: string | number | boolean | (string | number | boolean)[];
-    minimum?: number;
-    maximum?: number;
-    /** String characters, or array items */
-    minLength?: number;
-    maxLength?: number;
-    /** A regular expression, applied to strings */
-    pattern?: string;
-    enum?: (string | number | boolean)[];
-}
-/** Whether the query answers with one record or a list. Independent of how many rows match. */
-type QueryCardinality = 'one' | 'many';
-type CachePolicyObject = {
-    /** Defaults to `public` */
-    policy?: 'public' | 'private' | 'no-cache';
-    ttl?: number;
-    staleWhileRevalidate?: number;
-    tags?: string[];
-};
-type CachePolicy = string | CachePolicyObject;
-/** A text search over `fields` the query runs beside its operation block. */
-type FullTextSearch = {
-    /** The fields searched; at least one */
-    fields: string[];
-    /** The search text, usually a parameter expression such as `${q}` */
-    query: string;
-    highlight?: boolean;
-    ranking?: 'simple' | 'complex';
-};
-/**
- * Fetch block - retrieve content entries
- */
-interface FetchBlock {
-    /** Content type to fetch */
-    contentType?: string;
-    /** Singleton to fetch */
-    singleton?: string;
-    /** Filter conditions */
-    where?: WhereCondition;
-    /** Related content to include */
-    include?: IncludeDefinition;
-    /** Sort order */
-    sort?: SortCondition;
-    /** Maximum results */
-    limit?: Parameterizable<number>;
-    /** Results offset */
-    offset?: Parameterizable<number>;
-}
-/**
- * Aggregate block - perform aggregations
- */
-interface AggregateBlock {
-    /** Source content type (required when not used with fetch) */
-    source?: string;
-    /** Filter conditions */
-    where?: WhereCondition;
-    /** Group by field(s) */
-    by?: string | string[] | (string | {
-        expression: string;
-        as?: string;
-    })[];
-    /**
-     * What to compute per group, keyed by the name each answers under: `<field>.<fn>`, where `fn` is
-     * `count`, `sum`, `avg`, `min`, `max`, `first` or `last` — `{ total: 'amount.sum' }`. Deploy
-     * requires it. The one spelling: `aggregations`, which this type called the main one, was a
-     * second name deploy refused (REL-1470).
-     */
-    metrics?: Record<string, string>;
-    /** Having clause for filtering aggregations */
-    having?: Record<string, QueryScalar | HavingOperator>;
-    /** Sort order */
-    sort?: SortCondition;
-    /** Maximum results */
-    limit?: Parameterizable<number>;
-}
-/**
- * Search block - full-text and semantic search
- */
-interface SearchBlock {
-    /** Single content type */
-    contentType?: string;
-    /** Multiple content types or "*" for all */
-    contentTypes?: string | string[] | '*';
-    /** Search query string */
-    query: string;
-    /** Fields to search in */
-    searchFields?: string[];
-    /** Legacy search type */
-    searchType?: 'plainto' | 'phraseto' | 'websearch' | 'to_tsquery';
-    /** Filter conditions */
-    where?: WhereCondition;
-    /** Field mapping for results */
-    fields?: SelectMapping;
-    /** Include relevance score */
-    includeRank?: boolean;
-    /** Include score breakdown */
-    explain?: boolean;
-    /** Highlight matching terms */
-    highlight?: boolean | {
-        field?: string;
-        maxWords?: number;
-        minWords?: number;
-        shortWord?: number;
-    };
-    /** Sort order */
-    sort?: SortCondition;
-    /** Maximum results */
-    limit?: Parameterizable<number>;
-    /** Results offset */
-    offset?: Parameterizable<number>;
-}
-/**
- * Include sub-queries for additional data
- */
-interface IncludeSubQuery {
-    source: string;
-    where?: WhereCondition;
-    sort?: SortCondition;
-    limit?: Parameterizable<number>;
-    select?: SelectMapping;
-}
-type IncludeSubQueries = Record<string, IncludeSubQuery>;
-/**
- * Which operation block a query runs. Inferred from the block it declares when absent.
- *
- * `similar` is not one: deploy refused a query built on it alone and nothing ran it. Similar
- * content is `relyio.similar(uid)` (REL-1470).
- */
-type QueryType = 'fetch' | 'aggregate' | 'search';
-/**
- * Query definition configuration
- */
-interface QueryConfig {
-    /** Which operation block the query runs; inferred when absent */
-    type?: QueryType;
-    /** API endpoint path (required, e.g., /api/featured-products) */
-    endpoint: string;
-    /** Query description */
-    description?: string;
-    /** Fetch block for retrieving entries */
-    fetch?: FetchBlock;
-    /** Aggregate block for aggregations */
-    aggregate?: AggregateBlock;
-    /** Search block for full-text/semantic search */
-    search?: SearchBlock;
-    /** Include sub-queries */
-    include?: IncludeSubQueries;
-    /** Dynamic filter definitions */
-    filters?: FilterDefinition;
-    /** Full-text search over the fields it names */
-    fullText?: FullTextSearch;
-    /** Field selection/mapping */
-    select?: SelectMapping;
-    /** Cache policy */
-    cache?: CachePolicy;
-    /** Types and constraints for the parameters the query already declares by using them */
-    parameters?: QueryParameter[];
-    /** Whether the response is the record itself or a list. Defaults to `many` */
-    cardinality?: QueryCardinality;
-}
-/**
- * Query definition
- */
-interface QueryDefinition {
-    readonly _tag: 'query';
-    readonly name: string;
-    readonly type?: QueryType;
-    readonly endpoint: string;
-    readonly description?: string;
-    readonly fetch?: FetchBlock;
-    readonly aggregate?: AggregateBlock;
-    readonly search?: SearchBlock;
-    readonly include?: IncludeSubQueries;
-    readonly filters?: FilterDefinition;
-    readonly fullText?: FullTextSearch;
-    readonly select?: SelectMapping;
-    readonly cache?: CachePolicy;
-    readonly parameters?: QueryParameter[];
-    readonly cardinality?: QueryCardinality;
-}
-/**
- * Define a predefined query
- *
- * @example
- * const featuredProducts = defineQuery('featuredProducts', {
- *   endpoint: '/api/featured-products',
- *   description: 'Get featured products for homepage',
- *   fetch: {
- *     contentType: 'product',
- *     where: {
- *       status: 'active',
- *       featured: true,
- *     },
- *     include: ['brand', 'categories'],
- *     sort: { publishedAt: 'desc' },
- *     limit: 10,
- *   },
- *   cache: {
- *     policy: 'public',
- *     ttl: 300,
- *     staleWhileRevalidate: 60,
- *   }
- * })
- *
- * @example
- * const searchProducts = defineQuery('searchProducts', {
- *   endpoint: '/api/search',
- *   description: 'Search products with semantic understanding',
- *   search: {
- *     contentType: 'product',
- *     query: '${q}',
- *     where: { status: 'active' },
- *     highlight: true,
- *     limit: 20,
- *   },
- *   filters: {
- *     'price.base': { gte: '${minPrice?0}', lte: '${maxPrice?}' },
- *     category: '${categoryId?}',
- *   },
- *   cache: 'public 60s',
- * })
- *
- * @example
- * const productStats = defineQuery('productStats', {
- *   endpoint: '/api/products/stats',
- *   description: 'Get product statistics by category',
- *   aggregate: {
- *     source: 'product',
- *     where: { status: 'active' },
- *     by: ['category'],
- *     metrics: {
- *       totalProducts: 'id.count',
- *       avgPrice: 'price.base.avg',
- *       minPrice: 'price.base.min',
- *       maxPrice: 'price.base.max',
- *     },
- *     sort: { totalProducts: 'desc' },
- *   },
- *   cache: 'public 300s',
- * })
- */
-declare function defineQuery(name: string, config: QueryConfig): QueryDefinition;
-/**
- * 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;
-}
-/**
- * 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[];
-
-/**
- * View definitions for SDK schema
- *
- * Views define pre-configured entry list configurations with filters,
- * columns, and metadata display settings.
- */
-/**
- * View scope defines which content types a view applies to.
- *
- * When using `contentTypes` (plural) or `all`, the view displays entries
- * from multiple content types. In this case:
- *
- * - Columns/fields may only exist on some content types
- * - For entries where a field doesn't exist, the UI displays "—"
- * - System fields (id, status, createdAt, updatedAt) exist on all entries
- * - Filters on non-existent fields are skipped for that entry type
- *
- * Example display:
- * | Content Type | title | author | productCode |
- * |--------------|-------|--------|-------------|
- * | post         | ✓     | ✓      | —           |
- * | product      | ✓     | —      | ✓           |
- */
-/**
- * Scope for a single content type
- */
-interface ContentTypeScopeConfig {
-    type: 'contentType';
-    contentType: string;
-}
-/**
- * Scope for multiple content types
- *
- * Fields not present on all content types will show "—" in the UI
- */
-interface ContentTypesScopeConfig {
-    type: 'contentTypes';
-    contentTypes: string[];
-}
-/**
- * Scope for an entry type (content, singleton, settings, asset)
- */
-interface EntryTypeScopeConfig {
-    type: 'entryType';
-    entryType: 'content' | 'singleton' | 'settings' | 'asset';
-}
-/**
- * Scope for all content
- *
- * Fields not present on all content types will show "—" in the UI
- */
-interface AllScopeConfig {
-    type: 'all';
-}
-/**
- * View scope options
- */
-type ViewScopeConfig = ContentTypeScopeConfig | ContentTypesScopeConfig | EntryTypeScopeConfig | AllScopeConfig;
-/**
- * The operators a view filter may name: the schema's `FILTER_OPERATORS`, which deploy parses a view
- * with and the read core compiles every one of.
- *
- * This list used to be its own: ten of its names — `doesNotContain`, `isNotEmpty`, `isOnOrBefore`,
- * `isOnOrAfter`, `tomorrow`, `lastWeek`, `lastMonth`, `includesAll`, `includesAny`, `excludes` —
- * are none the schema declares, so a view naming one was refused at deploy, and six the schema does
- * declare — `notContains`, `notIncludes`, `isOn`, `isBetween`, `thisYear`, `hasValue` — could not be
- * written here, so a view pulled by `relyio generate-types` that named one did not compile.
- * `@relyio/codegen-typescript`'s `src/__tests__/sdk-definition-config.types.ts` holds the two to each
- * other (REL-1457).
- */
-type ViewFilterOperator = 'is' | 'isNot' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'isAnyOf' | 'isNoneOf' | 'includes' | 'notIncludes' | 'isTrue' | 'isFalse' | 'equals' | 'notEquals' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual' | 'between' | 'isOn' | 'isBefore' | 'isAfter' | 'isBetween' | 'inTheLast' | 'inTheNext' | 'today' | 'yesterday' | 'thisWeek' | 'thisMonth' | 'thisYear' | 'isEmpty' | 'hasValue';
-/** A span of time back or forward from now, for `inTheLast` and `inTheNext`. */
-interface ViewFilterRelativeDate {
-    amount: number;
-    unit: 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
-}
-/** What a filter compares against: the schema's `FilterValueSchema`. */
-type ViewFilterValue = string | number | boolean | null | (string | number)[] | {
-    from: string | number | Date;
-    to: string | number | Date;
-} | ViewFilterRelativeDate | Date;
-/**
- * One filter of a view: a field, an operator and the value it compares with.
- */
-interface ViewFilterCondition {
-    /**
-     * The Property to filter on, as the Studio's entry list names it: `fields.<id>` for a field your
-     * schema declares (`fields.seo.title` for a field of an object's value), `_metadata.<id>` for a system
-     * field — `_metadata.status`, `_metadata.createdAt`, `_metadata.updatedAt`. So a field called
-     * `status` (`fields.status`) and the entry's own lifecycle (`_metadata.status`) are both
-     * filterable.
-     */
-    field: string;
-    /**
-     * Filter operator
-     */
-    operator: ViewFilterOperator;
-    /**
-     * Filter value (optional for some operators like isEmpty)
-     */
-    value?: ViewFilterValue;
-}
-/**
- * A view's filter. A view's filters are a flat list joined by AND — the Filters the Studio's entry
- * list takes, each drawn as a Chip — so there is no filter group: an OR within one field is
- * `isAnyOf`. RelyIO refuses a group by name when you deploy.
- */
-type ViewFilter = ViewFilterCondition;
-/**
- * View definition configuration
- */
-interface ViewConfig {
-    /**
-     * Display name for the view
-     */
-    name: string;
-    /**
-     * URL-friendly slug for the view, used in Studio URLs like /studio/views/:slug. Absent, the
-     * platform derives one from the id when it reads the schema.
-     */
-    slug?: string;
-    /**
-     * Optional description for the view
-     */
-    description?: string;
-    /**
-     * Icon (emoji or icon name) for the view
-     */
-    icon?: string;
-    /**
-     * Color for the view in the sidebar
-     */
-    color?: string;
-    /**
-     * View scope - what content types this view applies to
-     */
-    scope: ViewScopeConfig;
-    /**
-     * Filter conditions (optional), combined with AND. A flat list: an OR within one field is
-     * `isAnyOf`, and there is no filter group.
-     *
-     * Deploy judges each against the entries the view lists: the field must be one they can be
-     * narrowed by, and it must offer the operator — a boolean field takes `is` with `true` or
-     * `false`, for example, not `isTrue`.
-     */
-    filters?: ViewFilter[];
-    /**
-     * Column field IDs to display (optional)
-     * If not specified, uses default columns
-     */
-    columns?: string[];
-    /**
-     * Metadata field IDs to show under title (max 3)
-     */
-    metadataFields?: string[];
-    /**
-     * Default sort (optional). `field` names the Property to sort by, as a filter names one —
-     * `fields.<id>` or `_metadata.<id>` — and deploy refuses one the view's entries cannot be sorted
-     * by. `columns` and `metadataFields` are display settings and name field IDs as written.
-     */
-    sort?: {
-        field: string;
-        direction: 'asc' | 'desc';
-    };
-    /**
-     * Sort order in the sidebar (lower = higher priority)
-     */
-    sortOrder?: number;
-}
-/**
- * Complete view definition with ID
- */
-interface ViewDefinition extends ViewConfig {
-    /**
-     * Internal tag for type discrimination
-     */
-    readonly _tag: 'view';
-    /**
-     * Unique view ID (must start with a letter)
-     */
-    readonly id: string;
-}
-/**
- * Define a schema view
- *
- * Views are pre-configured entry list displays with filters,
- * columns, and metadata settings.
- *
- * @example
- * const featuredPosts = defineView('featuredPosts', {
- *   name: 'Featured Posts',
- *   description: 'Blog posts marked as featured',
- *   icon: '📝',
- *   scope: { type: 'contentType', contentType: 'post' },
- *   filters: [
- *     { field: 'fields.featured', operator: 'is', value: true }
- *   ],
- *   columns: ['title', 'author', 'publishedAt'],
- *   metadataFields: ['category', 'views'],
- *   sort: { field: '_metadata.publishedAt', direction: 'desc' }
- * })
- *
- * @example
- * const archivedContent = defineView('archivedContent', {
- *   name: 'Archived',
- *   scope: { type: 'all' },
- *   filters: [
- *     { field: '_metadata.status', operator: 'is', value: 'archived' }
- *   ]
- * })
- *
- * @param id - Unique view ID (must start with a letter)
- * @param config - View configuration
- * @returns View definition object
- */
-declare function defineView(id: string, config: ViewConfig): ViewDefinition;
-
-/**
- * Schema definition matching @relyio/schema SchemaDefinitionSchema
- *
- * Note: `version` is NOT user-defined - it's auto-generated by the backend.
- */
-
-/**
- * Schema configuration
- *
- * Matches the SchemaDefinitionSchema from @relyio/schema:
- * - locales: Optional array of locale definitions for multi-language support
- * - contentTypes: Required record of content type definitions
- * - 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
- * - workflow: Optional workflow configuration with approval stages
- *
- * Note: `version` is auto-generated by the backend, not user-defined!
- */
-interface SchemaConfig {
-    /** Locale definitions for multi-language support (optional) */
-    locales?: LocaleDefinition[];
-    /** Content type definitions (required) */
-    contentTypes: Record<string, ContentTypeDefinition>;
-    /** Singleton content type definitions (required, can be empty) */
-    singletonContentTypes?: Record<string, SingletonContentTypeDefinition>;
-    /** Predefined query definitions (required, can be empty) */
-    queries?: Record<string, QueryDefinition>;
-    /** Settings group definitions (optional) */
-    settingsGroups?: Record<string, SettingsGroupDefinition>;
-    /** Asset type definitions (optional) */
-    assetTypes?: Record<string, AssetTypeDefinition>;
-    /** Custom role definitions for fine-grained access control (optional) */
-    roles?: RoleDefinition[];
-    /** Global workflow configuration with approval stages (optional) */
-    workflow?: WorkflowDefinition;
-    /** View definitions for pre-configured entry list views (optional) */
-    views?: ViewDefinition[];
-}
-/**
- * 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>> {
-    readonly _tag: 'schema';
-    readonly locales?: TLocales;
-    readonly contentTypes: TContentTypes;
-    readonly singletonContentTypes: TSingletons;
-    readonly queries: TQueries;
-    readonly settingsGroups?: TSettings;
-    readonly assetTypes?: TAssets;
-    readonly roles?: TRoles;
-    readonly workflow?: TWorkflow;
-    readonly views?: TViews;
-}
-/**
- * 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>> {
-    locales?: TLocales;
-    contentTypes: TContentTypes;
-    singletonContentTypes?: TSingletons;
-    queries?: TQueries;
-    settingsGroups?: TSettings;
-    assetTypes?: TAssets;
-    roles?: TRoles;
-    workflow?: TWorkflow;
-    views?: TViews;
-}
-/**
- * Define a complete schema
- *
- * This creates a schema definition that can be:
- * 1. Deployed via the CLI
- * 2. Used for type inference in the SDK client
- *
- * @example
- * 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 product = defineContentType('product', {
- *   displayName: 'Product',
- *   fields: [
- *     fields.shortText('title', { config: { required: true }, localization: true }),
- *     fields.decimal('price', { config: { 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 } }),
- *           ],
- *         },
- *       },
- *     }),
- *   ]
- * })
- *
- * export const schema = defineSchema({
- *   locales: [enUS, esES],
- *   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>;
-/**
- * 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>;
-/**
- * Get content type names from a schema
- */
-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 resolved against `T` (`INV-SS-TYPES-INFERRED`).
- */
-type SchemaEntry<T extends AnySchemaDefinition, K extends SchemaContentTypeNames<T>> = InferContentType<T['contentTypes'][K], T>;
-/**
- * An entry of any one of the content types `K` names — every content type by default — as a search
- * across them returns it: a union, so `_metadata.type` tells a caller which it holds.
- */
-type SchemaEntryOf<T extends AnySchemaDefinition, K extends SchemaContentTypeNames<T> = SchemaContentTypeNames<T>> = {
-    [N in K]: SchemaEntry<T, N>;
-}[K];
-/**
- * Get singleton names from a schema
- */
-type SchemaSingletonNames<T extends AnySchemaDefinition> = keyof T['singletonContentTypes'] & string;
-/**
- * Get query names from a schema
- */
-type SchemaQueryNames<T extends AnySchemaDefinition> = keyof T['queries'] & string;
-/**
- * Get settings group names from a schema.
- *
- * `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`.
- */
-type SchemaSettingsGroupNames<T extends AnySchemaDefinition> = NonNullable<T['settingsGroups']> extends Record<string, SettingsGroupDefinition> ? keyof NonNullable<T['settingsGroups']> & string : never;
-/**
- * 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 locale codes from a schema
- */
-type SchemaLocaleCodes<T extends AnySchemaDefinition> = NonNullable<T['locales']> extends readonly LocaleDefinition[] ? NonNullable<T['locales']>[number]['code'] : never;
-
-export { type SearchBlock as $, type RoleDefinition as A, BUILT_IN_ROLES as B, defineView as C, type ContentTypeScopeConfig as D, type ContentTypesScopeConfig as E, type FieldVisibility as F, type EntryTypeScopeConfig as G, type AllScopeConfig as H, type ViewFilterOperator as I, type ViewFilterValue as J, type ViewFilterRelativeDate as K, type LocaleOptions as L, type ViewFilterCondition as M, type ViewFilter as N, type ViewConfig as O, type ViewDefinition as P, defineQuery as Q, ROLE_ACTIONS as R, type SchemaConfig as S, type TextDirection as T, type QueryConfig as U, type ViewScopeConfig as V, type QueryDefinition as W, type QueryType as X, type FullTextSearch as Y, type FetchBlock as Z, type AggregateBlock as _, type SchemaDefinition as a, type WhereCondition as a0, type WhereValue as a1, type WhereOperator as a2, type HavingOperator as a3, type QueryScalar as a4, type SortCondition as a5, type SortDirection as a6, type IncludeDefinition as a7, type IncludeRelationship as a8, type SelectMapping as a9, type FilterDefinition as aa, type CachePolicy as ab, type CachePolicyObject as ac, type IncludeSubQuery as ad, type IncludeSubQueries as ae, type Parameterizable as af, type QueryParameter as ag, type QueryParameterType as ah, type QueryCardinality as ai, type InferQueryResponse as aj, type InferQueryParams as ak, type FilterOperator as al, 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 };