@relyio/sdk 0.19.0 → 0.21.0

package/dist/define-schema-BPlZl4a2.d.cts

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