@relyio/sdk 0.12.0 → 0.14.0

package/dist/define-schema-5aHmsA8j.d.ts

@@ -0,0 +1,699 @@
+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-DOrZb_a_.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;
+/**
+ * A window back or forward from the moment of the read — `{ amount: 7, unit: 'days' }` — which
+ * `$inTheLast` and `$inTheNext` take, as a list's `where` takes them.
+ */
+type QueryRelativeWindow = {
+    amount: number;
+    unit: 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
+};
+/**
+ * The operators `where` and `filters` compare a field with — `{ price: { $gte: 10 } }` — the
+ * `$`-prefixed operators a list's `where` takes, meaning what they mean there (REL-2439).
+ *
+ * The service's one vocabulary for `where`, `filters` and `having`, which deploy refuses any other
+ * key against (REL-1479). The bare form (`{ price: { gte: 10 } }`) is gone: deploy refuses it,
+ * saying what to write. A value may be a parameter expression: a list operator takes a list or a
+ * parameter that supplies one, a flag a boolean or a parameter. A parameter only ever fills a value;
+ * which operators a condition asks is written here, never supplied.
+ * `@relyio/codegen-typescript`'s `sdk-definition-config.types.ts` fails to compile when an operator,
+ * or what it takes, differs from the schema's.
+ */
+type WhereOperator = {
+    /** Equal to */
+    $eq?: QueryScalar;
+    /** 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, matching case */
+    $startsWith?: QueryScalar;
+    /** Ends with the text, matching case */
+    $endsWith?: QueryScalar;
+    /** The field holds a value (true) or does not (false) */
+    $exists?: boolean | string;
+    /** The value is empty (true) or not (false) */
+    $isNull?: boolean | string;
+    /** A date within the span back from the moment of the read */
+    $inTheLast?: QueryRelativeWindow;
+    /** A date within the span forward from the moment of the read */
+    $inTheNext?: QueryRelativeWindow;
+};
+/**
+ * The operators `having` compares a metric with: the same as `where`'s, each with a literal, since
+ * `having` reads the values the aggregate computed and substitutes no parameter. A metric holds no
+ * date of an entry's, so neither relative window is taken.
+ */
+type HavingOperator = {
+    $eq?: QueryScalar;
+    $ne?: QueryScalar;
+    $gt?: QueryScalar;
+    $gte?: QueryScalar;
+    $lt?: QueryScalar;
+    $lte?: QueryScalar;
+    $in?: QueryScalar[];
+    $nin?: QueryScalar[];
+    $contains?: QueryScalar;
+    $startsWith?: QueryScalar;
+    $endsWith?: QueryScalar;
+    $exists?: boolean;
+    $isNull?: boolean;
+    $inTheLast?: never;
+    $inTheNext?: never;
+};
+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;
+}
+/** A value a query parameter takes, as the query string carries it to the query. */
+type QueryParameterValue = QueryScalar | readonly QueryScalar[];
+/** What a query whose parameters no type states accepts: any name, any value. */
+type AnyQueryParameters = {
+    readonly [name: string]: QueryParameterValue | undefined;
+};
+/** Type only: where a keyed definition keeps the parameters it declares (`InferQueryParams`). */
+declare const parametersAs: unique symbol;
+/**
+ * Query definition
+ *
+ * `TParameters` is what the query accepts, read from the definition as written (REL-2421); a
+ * definition typed by nothing more than this interface accepts any.
+ */
+interface QueryDefinition<TParameters extends object = AnyQueryParameters> {
+    /** Type only: never present at runtime. */
+    readonly [parametersAs]?: TParameters;
+    readonly _tag: 'query';
+    /** Written from its key by `defineSchema` */
+    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 (REL-1969): it takes no name, because its key under `defineSchema`'s
+ * `queries` is its id. Its `where` is the one a list takes, its operators `$`-prefixed (REL-2439).
+ *
+ * @example
+ * defineSchema({
+ *   contentTypes: { product },
+ *   queries: {
+ *     featuredProducts: defineQuery({
+ *       endpoint: '/api/featured-products',
+ *       fetch: { contentType: 'product', where: { featured: true }, limit: 10 },
+ *     }),
+ *   },
+ * })
+ *
+ * @example
+ * // queries: { featuredProducts }
+ * const featuredProducts = defineQuery({
+ *   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
+ * // queries: { searchProducts }
+ * const searchProducts = defineQuery({
+ *   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
+ * // queries: { productStats }
+ * const productStats = defineQuery({
+ *   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<const TConfig extends QueryConfig>(config: TConfig): QueryDefinition<DeclaredParameters<TConfig>>;
+/**
+ * Infer basic response type from a query definition
+ * Note: For accurate types, use the codegen tool
+ */
+type InferQueryResponse<_T extends QueryDefinition> = unknown[];
+/**
+ * The parameters a query accepts, by name (REL-2421): what `client.query(name, { params })` takes.
+ *
+ * Read from the keyed definition as written, as the API's `declareQueryParameters` reads the
+ * deployed one: each `{name}` segment of the endpoint (required — the route cannot match without
+ * it), each `${name}` in the definition's values (required) or `${name?…}` (optional), and each
+ * entry of `parameters`, whose `type` types the value and whose `required` decides. A name the
+ * query does not declare is not a parameter, so it does not compile.
+ */
+type InferQueryParams<T extends QueryDefinition<object>> = T extends QueryDefinition<infer P> ? P : AnyQueryParameters;
+/** Every string value in `T`, at any depth — values only: a key is a field path, never a parameter. */
+type StringsIn<T> = T extends string ? T : T extends readonly (infer Item)[] ? StringsIn<Item> : T extends object ? {
+    [K in keyof T]-?: StringsIn<T[K]>;
+}[keyof T] : never;
+/** The `${…}` expressions in one string, each as its name and whether it is optional. */
+type ExpressionsIn<S extends string> = S extends `${string}\${${infer Body}}${infer Rest}` ? (Body extends `${infer Name}?${string}` ? {
+    readonly name: Name;
+    readonly optional: true;
+} : {
+    readonly name: Body;
+    readonly optional: false;
+}) | ExpressionsIn<Rest> : never;
+/** The `{name}` segments of an endpoint. */
+type EndpointNames<E> = E extends `${string}{${infer Name}}${infer Rest}` ? Name | EndpointNames<Rest> : never;
+/** The expressions of a definition: its values but `parameters` and `description`, as the API scans. */
+type Expressions<C> = ExpressionsIn<StringsIn<Omit<C, 'parameters' | 'description'>>>;
+/** The `parameters` entries a definition declares. */
+type Declared<C> = C extends {
+    readonly parameters: readonly (infer Entry)[];
+} ? Entry : never;
+/** What a declared `type` makes a value. */
+type ValueOfType<T> = T extends 'string' ? string : T extends 'number' | 'integer' ? number : T extends 'boolean' ? boolean : T extends 'array' ? readonly QueryScalar[] : T extends 'object' ? never : QueryParameterValue;
+/** What a definition declares, read once: its endpoint's segments, its expressions, its entries. */
+type Declaration<C> = {
+    readonly segments: EndpointNames<C extends {
+        readonly endpoint: infer E;
+    } ? E : never>;
+    readonly expressions: Expressions<C>;
+    readonly entries: Declared<C>;
+};
+/** What any declaration is. */
+interface AnyDeclaration {
+    readonly segments: string;
+    readonly expressions: {
+        readonly name: string;
+        readonly optional: boolean;
+    };
+    readonly entries: unknown;
+}
+/** Every name a declaration holds. */
+type NamesOf<D extends AnyDeclaration> = D['segments'] | NameOf<D['expressions']> | NameOf<D['entries']>;
+/**
+ * The names a union of expressions or entries holds. Distributive on purpose: none is `never`,
+ * which a bare `extends` would match and answer the constraint, `string`, for.
+ */
+type NameOf<E> = E extends {
+    readonly name: infer N extends string;
+} ? N : never;
+/** Whether `Name` is used bare (`${name}`) anywhere — which makes it required. */
+type UsedBare<D extends AnyDeclaration, Name> = [
+    Extract<D['expressions'], {
+        readonly name: Name;
+        readonly optional: false;
+    }>
+] extends [never] ? false : true;
+/** The `parameters` entry naming `Name`, or `never` where none does. */
+type EntryFor<D extends AnyDeclaration, Name> = Extract<D['entries'], {
+    readonly name: Name;
+}>;
+/**
+ * Whether `Name` is required: an endpoint segment always; else its entry's `required`; else an entry
+ * that says nothing about it is required unless some use says it is optional and none is bare; else
+ * any bare use. No entry is asked about first: `never` matches every shape.
+ */
+type IsRequired<D extends AnyDeclaration, Name> = [Name] extends [D['segments']] ? true : [EntryFor<D, Name>] extends [never] ? UsedBare<D, Name> : [EntryFor<D, Name>] extends [{
+    readonly required: infer R extends boolean;
+}] ? R : [Extract<D['expressions'], {
+    readonly name: Name;
+}>] extends [never] ? true : UsedBare<D, Name>;
+/** The value `Name` takes: its entry's declared `type`, else any value a parameter takes. */
+type ParameterValue<D extends AnyDeclaration, Name> = [EntryFor<D, Name>] extends [never] ? QueryParameterValue : [EntryFor<D, Name>] extends [{
+    readonly type: infer T;
+}] ? ValueOfType<T> : QueryParameterValue;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/** The parameters a keyed definition declares: required ones required, the rest optional. */
+type DeclaredParameters<C> = ParametersOf<Declaration<C>>;
+type ParametersOf<D extends AnyDeclaration> = Simplify<{
+    readonly [Name in NamesOf<D> as IsRequired<D, Name> extends true ? Name : never]: ParameterValue<D, Name>;
+} & {
+    readonly [Name in NamesOf<D> as IsRequired<D, Name> extends true ? never : Name]?: ParameterValue<D, Name>;
+}>;
+
+/**
+ * Schema definition matching @relyio/schema SchemaDefinitionSchema
+ *
+ * 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 record of custom roles, each keyed by its id
+ * - workflow: Optional workflow configuration with approval stages
+ *
+ * Note: `version` is auto-generated by the backend, not user-defined!
+ */
+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 roles for fine-grained access control, each under its id (optional) */
+    roles?: KeyedRoles;
+    /** Global workflow configuration with approval stages (optional) */
+    workflow?: WorkflowDefinition;
+    /** Pre-configured entry list views, each under its id (optional) */
+    views?: KeyedViews;
+}
+/**
+ * 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 KeyedRoles = KeyedRoles, TWorkflow extends WorkflowDefinition | undefined = WorkflowDefinition | undefined, TViews extends KeyedViews = KeyedViews, TAssets extends Record<string, AssetTypeDefinition> = Record<string, AssetTypeDefinition>> {
+    locales?: TLocales;
+    contentTypes: TContentTypes;
+    singletonContentTypes?: TSingletons;
+    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, fieldset } from '@relyio/sdk/schema'
+ *
+ * const enUS = defineLocale('en-US', { displayName: 'English (US)', default: true })
+ * const esES = defineLocale('es-ES', { displayName: 'Spanish', fallback: ['en-US'] })
+ *
+ * const product = defineContentType({
+ *   fields: {
+ *     title: fields.shortText({ required: true, localized: true }),
+ *     price: fields.decimal({ min: 0, decimalPlaces: 2 }),
+ *     // One value of a fieldset: `{ _type: 'seo', _key, metaTitle?, metaDescription? }`
+ *     seo: fields.object({
+ *       of: fieldset('seo', {
+ *         displayName: 'SEO metadata',
+ *         fields: {
+ *           metaTitle: fields.shortText({ maxLength: 60 }),
+ *           metaDescription: fields.longText({ 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 never[], TRoles extends KeyedRoles = Record<never, never>, TWorkflow extends WorkflowDefinition | undefined = undefined, TViews extends KeyedViews = Record<never, never>, TAssets extends Record<string, AssetTypeDefinition> = Record<string, never>>(config: TypedSchemaConfig<TContentTypes, TSingletons, TQueries, TSettings, TLocales, TRoles, TWorkflow, TViews, TAssets> & NamesChecked<TContentTypes, TSingletons, TSettings, TAssets, TLocales, TRoles, TWorkflow>): SchemaDefinition<TContentTypes, TSingletons, TQueries, TSettings, TLocales, RolesAsList<TRoles>, TWorkflow, ViewsAsList<TViews>, TAssets>;
+/**
+ * What `defineSchema` holds a schema's names to (REL-2416): each section of types against what the
+ * schema declares — a reference's `to` and rich text's `links.to` against its content, singleton and
+ * asset type keys (a reference may point at a singleton: `@relyio/schema`'s
+ * `ResolvedReferenceTarget`), and a Field's `requiredLocales` against its locale codes; its locales'
+ * `fallback` against their codes; the roles its workflow's stages name, and its roles' `includes`,
+ * against the built-in roles and its role keys; and a type's stages against its workflow's stage
+ * keys. Types only; `./checked-names.ts` says how.
+ */
+type NamesChecked<TContentTypes, TSingletons, TSettings, TAssets, TLocales, TRoles, TWorkflow> = {
+    readonly locales?: CheckedLocales<TLocales>;
+    readonly roles?: CheckedRoles<TRoles>;
+    readonly workflow?: CheckedWorkflow<TWorkflow, TRoles>;
+    readonly contentTypes: CheckedSection<TContentTypes, DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow>>;
+    readonly singletonContentTypes?: CheckedSection<TSingletons, DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow>>;
+    readonly settingsGroups?: CheckedSection<TSettings, DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow>>;
+    readonly assetTypes?: CheckedSection<TAssets, DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow>>;
+};
+/** The names a schema declares, for its sections' names to be checked against. */
+interface DeclaredBy<TContentTypes, TSingletons, TAssets, TLocales, TWorkflow> {
+    readonly targets: KeysDeclared<TContentTypes> | KeysDeclared<TSingletons> | KeysDeclared<TAssets>;
+    readonly locales: LocaleCodesOf<TLocales>;
+    readonly stages: StagesDeclared<TWorkflow>;
+}
+/**
+ * The roles `defineSchema` returns for the keyed record it was given: the list it compiles to, each
+ * role carrying its key as a literal `id` (REL-2414).
+ */
+type RolesAsList<R extends KeyedRoles> = KeyedRolesAsList<R>;
+/** The views `defineSchema` returns for the ones it was given, as {@link RolesAsList} says of roles. */
+type ViewsAsList<V extends KeyedViews> = KeyedViewsAsList<V>;
+/**
+ * Type alias for any schema definition.
+ * Uses `any` intentionally for type inference utilities that need to accept any schema.
+ */
+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 `with({ locale })` took `never`. The three read through `NonNullable`.
+ */
+type SchemaSettingsGroupNames<T extends AnySchemaDefinition> = NonNullable<T['settingsGroups']> extends Record<string, SettingsGroupDefinition> ? keyof NonNullable<T['settingsGroups']> & string : never;
+/**
+ * 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: the codes its locales declare, or `string` for a schema that
+ * declares none. `defineSchema` now types an absent `locales` as an empty list, so that a Field's
+ * `requiredLocales` is checked against no locale (REL-2416); a read's locale keeps what it took
+ * before — any code — until the read options check it (REL-2417).
+ */
+type SchemaLocaleCodes<T extends AnySchemaDefinition> = NonNullable<T['locales']> extends readonly LocaleDefinition[] ? [NonNullable<T['locales']>[number]] 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 };