@relyio/sdk 0.2.0

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

@@ -0,0 +1,2101 @@
+/**
+ * Field type definitions matching @relyio/schema package
+ */
+/**
+ * AI configuration. A single prompt — `instructions` — describes what the
+ * element is and how AI should produce its value. Attaches to fields, content
+ * types, components, fieldsets, and (extended) asset types.
+ *
+ * @example
+ * ```typescript
+ * fields.richText('body', {
+ *   ai: {
+ *     instructions: `
+ *       Write in a conversational tone.
+ *       Use short paragraphs (2-3 sentences).
+ *       Target grade 8 reading level.
+ *     `
+ *   }
+ * })
+ * ```
+ */
+interface AIConfig {
+    /**
+     * AI brief for this element: what it should contain and how to produce it.
+     *
+     * Used by the Studio authoring agent and — on asset types with
+     * `ai.autoGenerate` — by the automatic post-upload run.
+     *
+     * The fallback chain for AI guidance is:
+     * 1. ai.instructions (most specific)
+     * 2. ui.description (general field description)
+     * 3. Field displayName + type (inferred from semantics)
+     */
+    instructions?: string;
+}
+/**
+ * Field-level AI config. `inputs` names the fields this instruction reads.
+ * Unknown ids and cycles are refused when the schema is parsed.
+ */
+interface FieldAIConfig extends AIConfig {
+    /** Field ids this instruction reads. Never inferred from instruction text. */
+    inputs?: string[];
+}
+/**
+ * Asset-type AI configuration. Extends {@link AIConfig} with `autoGenerate`,
+ * the single switch that turns on automatic field generation after upload.
+ */
+interface AssetAIConfig extends AIConfig {
+    /**
+     * Master switch for automatic, post-upload field generation. When `true`, the
+     * derived analysis agent fills every field that declares `ai.instructions`,
+     * applied as a review proposal. Only meaningful for image asset types in v1.
+     */
+    autoGenerate?: boolean;
+}
+interface BaseFieldConfig {
+    /** Whether the field is required */
+    required?: boolean;
+    /** Whether the field value must be unique */
+    unique?: boolean;
+    /** Default value for the field */
+    defaultValue?: unknown;
+}
+interface FieldUIConfig {
+    /** Display name shown in the UI */
+    displayName: string;
+    /** Field description/help text */
+    description?: string;
+    /** Widget-specific options */
+    options?: Record<string, unknown>;
+}
+interface RuleCondition {
+    field: string;
+    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'greater_than' | 'less_than' | 'is_empty' | 'is_not_empty';
+    value?: unknown;
+}
+interface RuleConditions {
+    mode: 'all' | 'any' | 'none';
+    conditions: RuleCondition[];
+}
+interface VisibilityRule {
+    type: 'visibility';
+    action: 'show' | 'hide';
+    conditions: RuleConditions;
+}
+interface RequirementRule {
+    type: 'requirement';
+    action: 'require' | 'optional';
+    conditions: RuleConditions;
+}
+interface ValidationRule {
+    type: 'validation';
+    action: 'validate' | 'skip';
+    message?: string;
+    conditions: RuleConditions;
+}
+interface ReadOnlyRule {
+    type: 'readOnly';
+    action: 'enable' | 'disable';
+    conditions: RuleConditions;
+}
+type FieldRule = VisibilityRule | RequirementRule | ValidationRule | ReadOnlyRule;
+type LocalizationConfig = boolean | string[] | {
+    enabled: boolean;
+    requiredLocales?: string[];
+    fallback?: boolean;
+};
+interface FieldDefinition<TId extends string = string, TType extends string = string, TConfig = unknown> {
+    /** Unique field identifier - preserves literal type for type inference */
+    readonly id: TId;
+    /** Field type */
+    readonly type: TType;
+    /** Type-specific configuration */
+    config?: TConfig;
+    /** UI display configuration */
+    ui?: FieldUIConfig;
+    /** AI configuration: generation/review guidance for this field */
+    ai?: FieldAIConfig;
+    /** Dynamic field rules */
+    rules?: FieldRule[];
+    /** Localization settings */
+    localization?: LocalizationConfig;
+    /** Fallback value when field is empty */
+    fallback?: unknown;
+    /** Whether this field is deprecated */
+    deprecated?: boolean;
+}
+/**
+ * Any field definition - used in arrays where we need to preserve specific field types
+ */
+type AnyFieldDefinition = FieldDefinition<string, string, unknown>;
+interface ShortTextConfig extends BaseFieldConfig {
+    /** Maximum character length */
+    maxLength?: number;
+    /** Regex pattern for validation */
+    pattern?: string;
+}
+interface LongTextConfig extends BaseFieldConfig {
+    minLength?: number;
+    maxLength?: number;
+}
+interface RichTextConfig extends BaseFieldConfig {
+    /** Maximum character length for the rich text content */
+    maxLength?: number;
+    /** Allowed formatting options (e.g., bold, italic, underline) */
+    allowedFormats?: string[];
+    /** Allowed embed types (e.g., image, video, code) */
+    embedTypes?: string[];
+}
+interface SlugConfig extends BaseFieldConfig {
+    /** Source field to generate slug from */
+    sourceField?: string;
+    /** Maximum character length */
+    maxLength?: number;
+}
+interface UrlConfig extends BaseFieldConfig {
+    /** Allowed URL protocols */
+    allowedProtocols?: ('http' | 'https' | 'ftp' | 'ftps')[];
+    /** Maximum character length */
+    maxLength?: number;
+}
+interface EmailConfig extends BaseFieldConfig {
+    /** Maximum character length */
+    maxLength?: number;
+    /** Whitelist of allowed email domains */
+    domainWhitelist?: string[];
+}
+interface IntegerConfig extends BaseFieldConfig {
+    min?: number;
+    max?: number;
+}
+interface DecimalConfig extends BaseFieldConfig {
+    min?: number;
+    max?: number;
+    decimalPlaces?: number;
+    roundingMode?: 'HALF_UP' | 'FLOOR' | 'CEILING' | 'ROUND' | 'TRUNCATE';
+}
+interface BooleanConfig extends BaseFieldConfig {
+    trueLabel?: string;
+    falseLabel?: string;
+}
+interface EnumConfig extends BaseFieldConfig {
+    options: Array<{
+        value: string;
+        label?: string;
+    }>;
+    multi?: boolean;
+}
+interface DateConfig extends BaseFieldConfig {
+    minDate?: string;
+    maxDate?: string;
+    format?: string;
+}
+interface DateTimeConfig extends BaseFieldConfig {
+    minDateTime?: string;
+    maxDateTime?: string;
+    format?: string;
+    timezone?: boolean;
+}
+interface ReferenceConfig extends BaseFieldConfig {
+    /**
+     * Target entry type id(s) — content type or asset type ids. Pass a single id
+     * for one target or an array for several. All ids must belong to the same
+     * family (all content types or all asset types).
+     */
+    to: string | string[];
+    /** Allow multiple references (the field value is a list). */
+    multi?: boolean;
+    /** Reference strength for publish/unpublish behavior. */
+    referenceStrength?: 'strong' | 'weak';
+    /** Behavior when a referenced entry is deleted. */
+    onTargetDelete?: 'block' | 'nullify';
+}
+interface TagsConfig extends BaseFieldConfig {
+    allowCustom?: boolean;
+    predefinedTags?: string[];
+    maxTags?: number;
+}
+interface ListConfig extends BaseFieldConfig {
+    dragAndDrop?: boolean;
+    minItems?: number;
+    maxItems?: number;
+    /** Subfields for list items */
+    subfields?: FieldDefinition[];
+}
+type FieldType = 'shortText' | 'longText' | 'richText' | 'slug' | 'url' | 'email' | 'integer' | 'decimal' | 'boolean' | 'enum' | 'date' | 'dateTime' | 'reference' | 'tags' | 'list';
+type ComponentFieldType = `component(${string})`;
+type AllFieldTypes = FieldType | ComponentFieldType;
+
+/**
+ * Workflow definition for content approval pipelines
+ *
+ * Workflows define approval stages that content must pass through before
+ * publication. They can be configured globally and per content type.
+ *
+ * @example
+ * // Simple workflow with one approval stage
+ * const workflow = defineWorkflow({
+ *   enabled: true,
+ *   stages: [
+ *     defineWorkflowStage('review', {
+ *       displayName: 'Editorial Review',
+ *       allowedRoles: ['editor', 'admin']
+ *     })
+ *   ]
+ * })
+ *
+ * @example
+ * // Multi-stage workflow
+ * const workflow = defineWorkflow({
+ *   enabled: true,
+ *   stages: [
+ *     defineWorkflowStage('editorial-review', {
+ *       displayName: 'Editorial Review',
+ *       allowedRoles: ['editor']
+ *     }),
+ *     defineWorkflowStage('legal-approval', {
+ *       displayName: 'Legal Approval',
+ *       requiredApprovals: 1,
+ *       allowedRoles: ['legal-reviewer']
+ *     }),
+ *     defineWorkflowStage('final-approval', {
+ *       displayName: 'Final Approval',
+ *       requiredApprovals: 2,
+ *       allowedRoles: ['publisher', 'admin']
+ *     })
+ *   ]
+ * })
+ */
+/**
+ * Escalation configuration when a workflow stage times out
+ */
+interface WorkflowEscalation {
+    /** Roles to notify when stage times out */
+    notifyRoles?: string[];
+    /** Roles to escalate to if still pending after another timeout period */
+    escalateToRoles?: string[];
+}
+/**
+ * Auto-assignment configuration for workflow stages
+ */
+interface WorkflowAutoAssign {
+    /** Roles whose users should be notified when content enters this stage */
+    roles: string[];
+}
+/**
+ * Workflow stage configuration
+ */
+interface WorkflowStageConfig {
+    /** Human-readable name shown in Studio */
+    displayName: string;
+    /** Optional description for reviewers */
+    description?: string;
+    /** Number of approvals needed to pass this stage (default: 1) */
+    requiredApprovals?: number;
+    /** Roles that can approve this stage */
+    allowedRoles?: string[];
+    /** Auto-assignment configuration */
+    autoAssign?: WorkflowAutoAssign;
+    /** Days before escalation triggers (optional) */
+    timeoutDays?: number;
+    /** Escalation configuration when stage times out */
+    escalation?: WorkflowEscalation;
+}
+/**
+ * Complete workflow stage definition
+ */
+interface WorkflowStageDefinition {
+    readonly _tag: 'workflowStage';
+    readonly id: string;
+    readonly displayName: string;
+    readonly description?: string;
+    readonly requiredApprovals: number;
+    readonly allowedRoles?: string[];
+    readonly autoAssign?: WorkflowAutoAssign;
+    readonly timeoutDays?: number;
+    readonly escalation?: WorkflowEscalation;
+}
+/**
+ * Workflow configuration
+ */
+interface WorkflowConfig {
+    /** Enable/disable workflow for the branch (default: false) */
+    enabled?: boolean;
+    /** Array of approval stage definitions */
+    stages?: WorkflowStageDefinition[];
+}
+/**
+ * Complete workflow definition
+ */
+interface WorkflowDefinition {
+    readonly _tag: 'workflow';
+    readonly enabled: boolean;
+    readonly stages: WorkflowStageDefinition[];
+}
+/**
+ * Per-content-type workflow configuration
+ */
+interface ContentTypeWorkflowConfig {
+    /** Enable workflow for this content type (inherits from global if not set) */
+    enabled?: boolean;
+    /** Which global stages apply to this content type (subset of global stages) */
+    stages?: string[];
+    /** Publish automatically after all stages are approved */
+    autoPublish?: boolean;
+    /** Require all locales to be approved before publishing */
+    requireAllLocales?: boolean;
+}
+/**
+ * Define a workflow stage
+ *
+ * @param id - Unique identifier for the stage (kebab-case or camelCase)
+ * @param config - Stage configuration
+ *
+ * @example
+ * const editorialReview = defineWorkflowStage('editorial-review', {
+ *   displayName: 'Editorial Review',
+ *   description: 'Content quality and style check',
+ *   requiredApprovals: 1,
+ *   allowedRoles: ['editor', 'senior-editor']
+ * })
+ *
+ * @example
+ * // Stage with auto-assignment and timeout
+ * const legalApproval = defineWorkflowStage('legal-approval', {
+ *   displayName: 'Legal Approval',
+ *   allowedRoles: ['legal-reviewer'],
+ *   autoAssign: { roles: ['legal-reviewer'] },
+ *   timeoutDays: 3,
+ *   escalation: {
+ *     notifyRoles: ['legal-reviewer'],
+ *     escalateToRoles: ['admin']
+ *   }
+ * })
+ */
+declare function defineWorkflowStage(id: string, config: WorkflowStageConfig): WorkflowStageDefinition;
+/**
+ * Define a workflow configuration
+ *
+ * @param config - Workflow configuration with enabled flag and stages
+ *
+ * @example
+ * // Simple workflow
+ * const workflow = defineWorkflow({
+ *   enabled: true,
+ *   stages: [
+ *     defineWorkflowStage('review', {
+ *       displayName: 'Review',
+ *       allowedRoles: ['editor']
+ *     })
+ *   ]
+ * })
+ *
+ * @example
+ * // Disabled workflow (direct publish)
+ * const workflow = defineWorkflow({
+ *   enabled: false
+ * })
+ */
+declare function defineWorkflow(config: WorkflowConfig): WorkflowDefinition;
+/**
+ * Define content-type specific workflow configuration
+ *
+ * @param config - Content type workflow configuration
+ *
+ * @example
+ * // Use specific stages from global workflow
+ * const blogPostWorkflow = defineContentTypeWorkflow({
+ *   enabled: true,
+ *   stages: ['editorial-review', 'final-approval'], // Skip legal
+ *   autoPublish: false
+ * })
+ *
+ * @example
+ * // Disable workflow for this content type
+ * const quickUpdateWorkflow = defineContentTypeWorkflow({
+ *   enabled: false
+ * })
+ *
+ * @example
+ * // Require all locales to be approved
+ * const marketingPageWorkflow = defineContentTypeWorkflow({
+ *   enabled: true,
+ *   stages: ['translation-review', 'regional-approval'],
+ *   requireAllLocales: true
+ * })
+ */
+declare function defineContentTypeWorkflow(config: ContentTypeWorkflowConfig): ContentTypeWorkflowConfig;
+/**
+ * Check if a value is a workflow stage definition
+ */
+declare function isWorkflowStageDefinition(value: unknown): value is WorkflowStageDefinition;
+/**
+ * Check if a value is a workflow definition
+ */
+declare function isWorkflowDefinition(value: unknown): value is WorkflowDefinition;
+/**
+ * Get all stage IDs from a workflow definition
+ */
+declare function getWorkflowStageIds(workflow: WorkflowDefinition): string[];
+/**
+ * Find a stage by ID in a workflow definition
+ */
+declare function findWorkflowStage(workflow: WorkflowDefinition, stageId: string): WorkflowStageDefinition | undefined;
+/**
+ * Get the next stage after a given stage ID (null if last stage)
+ */
+declare function getNextWorkflowStage(workflow: WorkflowDefinition, currentStageId: string): WorkflowStageDefinition | null;
+/**
+ * Get the first stage in the workflow (null if no stages)
+ */
+declare function getFirstWorkflowStage(workflow: WorkflowDefinition): WorkflowStageDefinition | null;
+/**
+ * Check if a stage is the final stage in the workflow
+ */
+declare function isFinalWorkflowStage(workflow: WorkflowDefinition, stageId: string): boolean;
+/**
+ * Convert a workflow definition to JSON-safe format (strips _tag)
+ */
+declare function workflowToJSON(workflow: WorkflowDefinition): {
+    enabled: boolean;
+    stages?: Array<Omit<WorkflowStageDefinition, '_tag'>>;
+};
+
+/**
+ * Content type definition matching @relyio/schema ContentTypeSchema
+ *
+ * Uses advanced TypeScript generics to preserve literal field IDs through
+ * the type system, enabling full autocomplete in SDK methods like where().
+ */
+
+/**
+ * Fieldset for organizing related fields
+ * Generic over fields to preserve literal field IDs
+ */
+interface Fieldset<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
+    /** Unique fieldset identifier */
+    readonly id: string;
+    /** Display name shown in the UI */
+    readonly displayName: string;
+    /** Optional description */
+    readonly description?: string;
+    /** AI configuration for content generation and review */
+    readonly ai?: AIConfig;
+    /** Fields within this fieldset - preserves literal types */
+    readonly fields: TFields;
+}
+/**
+ * Type alias for a fieldset with any fields.
+ * Used in generic constraints where we need to accept any fieldset type.
+ */
+type AnyFieldset$2 = Fieldset<any>;
+/**
+ * Create a fieldset for organizing fields
+ * Generic to preserve the specific field types for type inference
+ *
+ * @example
+ * const seoFieldset = fieldset('seo', {
+ *   displayName: 'SEO Settings',
+ *   fields: [
+ *     fields.shortText('metaTitle', { config: { maxLength: 60 } }),
+ *     fields.longText('metaDescription', { config: { maxLength: 160 } }),
+ *   ]
+ * })
+ */
+declare function fieldset<TFields extends readonly AnyFieldDefinition[]>(id: string, config: {
+    displayName: string;
+    description?: string;
+    ai?: AIConfig;
+    fields: TFields;
+}): Fieldset<TFields>;
+/**
+ * Content type configuration using direct fields
+ * Generic to preserve literal field IDs for type inference
+ */
+interface ContentTypeConfigWithFields<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
+    /** Display name shown in the UI */
+    displayName: string;
+    /** Plural display name shown in the UI (e.g., "Products" for "Product") */
+    displayNamePlural?: string;
+    /** Description of the content type */
+    description?: string;
+    /** AI configuration: generation/review guidance */
+    ai?: AIConfig;
+    /**
+     * Field ID to use as entry display title in lists, references, and editor header.
+     * If not set, falls back to: title → name → slug → first shortText field → entryUid
+     */
+    displayField?: string;
+    /** Whether this content type supports hierarchical (parent-child) relationships */
+    hierarchical?: boolean;
+    /** Access tags for role-based access control */
+    accessTags?: string[];
+    /** Workflow configuration for this content type */
+    workflow?: ContentTypeWorkflowConfig;
+    /** Direct field definitions - preserves literal types */
+    fields: TFields;
+    /** Cannot have fieldsets when using fields */
+    fieldsets?: never;
+}
+/**
+ * Content type configuration using fieldsets
+ * Generic to preserve fieldset field types
+ */
+interface ContentTypeConfigWithFieldsets<TFieldsets extends readonly AnyFieldset$2[] = readonly AnyFieldset$2[]> {
+    /** Display name shown in the UI */
+    displayName: string;
+    /** Plural display name shown in the UI (e.g., "Products" for "Product") */
+    displayNamePlural?: string;
+    /** Description of the content type */
+    description?: string;
+    /** AI configuration: generation/review guidance */
+    ai?: AIConfig;
+    /**
+     * Field ID to use as entry display title in lists, references, and editor header.
+     * If not set, falls back to: title → name → slug → first shortText field → entryUid
+     */
+    displayField?: string;
+    /** Access tags for role-based access control */
+    accessTags?: string[];
+    /** Whether this content type supports hierarchical (parent-child) relationships */
+    hierarchical?: boolean;
+    /** Workflow configuration for this content type */
+    workflow?: ContentTypeWorkflowConfig;
+    /** Field organization via fieldsets - preserves literal types */
+    fieldsets: TFieldsets;
+    /** Cannot have direct fields when using fieldsets */
+    fields?: never;
+}
+/**
+ * Content type configuration (either fields OR fieldsets, not both)
+ */
+type ContentTypeConfig<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset$2[] = readonly AnyFieldset$2[]> = ContentTypeConfigWithFields<TFields> | ContentTypeConfigWithFieldsets<TFieldsets>;
+/**
+ * Content type definition - preserves field types for inference
+ */
+interface ContentTypeDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset$2[] = readonly AnyFieldset$2[]> {
+    readonly _tag: 'contentType';
+    readonly name: string;
+    readonly displayName: string;
+    readonly displayNamePlural?: string;
+    readonly description?: string;
+    /** AI configuration: generation/review guidance */
+    readonly ai?: AIConfig;
+    /** Field ID to use as entry display title */
+    readonly displayField?: string;
+    readonly hierarchical: boolean;
+    readonly accessTags?: string[];
+    readonly workflow?: ContentTypeWorkflowConfig;
+    readonly fields?: TFields;
+    readonly fieldsets?: TFieldsets;
+}
+/**
+ * Define a content type with type-safe fields
+ *
+ * The generic type parameters preserve the literal field IDs through the type
+ * system, enabling autocomplete in SDK methods like where(), select(), etc.
+ *
+ * @example
+ * // Using direct fields
+ * const product = defineContentType('product', {
+ *   displayName: 'Product',
+ *   fields: [
+ *     fields.shortText('title', { config: { required: true } }),
+ *     fields.currency('price', { config: { currencyCode: 'USD' } }),
+ *   ]
+ * })
+ *
+ * @example
+ * // Using fieldsets for organization
+ * const product = defineContentType('product', {
+ *   displayName: 'Product',
+ *   fieldsets: [
+ *     fieldset('basic', {
+ *       displayName: 'Basic Info',
+ *       fields: [
+ *         fields.shortText('title', { config: { required: true } }),
+ *       ]
+ *     }),
+ *     fieldset('pricing', {
+ *       displayName: 'Pricing',
+ *       fields: [
+ *         fields.currency('price', { config: { currencyCode: 'USD' } }),
+ *       ]
+ *     }),
+ *   ]
+ * })
+ */
+declare function defineContentType<TFields extends readonly AnyFieldDefinition[], _TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: ContentTypeConfigWithFields<TFields>): ContentTypeDefinition<TFields, readonly []>;
+declare function defineContentType<_TFields extends readonly AnyFieldDefinition[], TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: ContentTypeConfigWithFieldsets<TFieldsets>): ContentTypeDefinition<readonly [], TFieldsets>;
+/**
+ * Type alias for any content type definition.
+ */
+type AnyContentTypeDefinition = ContentTypeDefinition<any, any>;
+/**
+ * Extract field IDs from a content type definition
+ * Works with both direct fields and fieldsets
+ */
+type ExtractFieldIds<T extends AnyContentTypeDefinition> = NonNullable<T['fields']> extends (infer F)[] ? F extends AnyFieldDefinition ? F['id'] : ExtractFromFieldsets<T> : ExtractFromFieldsets<T>;
+type ExtractFromFieldsets<T extends AnyContentTypeDefinition> = NonNullable<T['fieldsets']> extends (infer FS)[] ? FS extends Fieldset<infer Fields> ? Fields extends AnyFieldDefinition[] ? Fields[number]['id'] : never : never : never;
+/**
+ * Entry metadata that's present on all content entries
+ */
+interface EntryMetadata {
+    /** Unique entry identifier */
+    id: string;
+    /** Content type id (API field name is `type`) */
+    type: string;
+    /** Entry type (content, asset, singleton, settings) */
+    entryType: string;
+    /**
+     * Container lifecycle only (`active` | `archived` | `proposed`).
+     * Publication is `localeStatus` (`INV-LM-STATUS-IS-TWO-FIELDS`).
+     */
+    status: 'active' | 'archived' | 'proposed';
+    /** Per-locale version number */
+    version: number;
+    /** Parent ID for hierarchical content */
+    parentId?: string | null;
+    /** Content locale this payload is reported in */
+    locale: string;
+    /** Publication state of `locale`; absent when that locale has no content of its own. */
+    localeStatus?: 'draft' | 'published' | 'archived';
+    /** Whether `locale` has unpublished changes of its own. */
+    localeHasDraft?: boolean;
+    /** Every locale with unpublished changes, including shared-field drafts. */
+    draftLocales?: string[];
+    /** Whether the shared (non-localized) fields have an unpublished overlay. */
+    hasDraft?: boolean;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Last update timestamp */
+    updatedAt: Date;
+}
+/**
+ * Infer the TypeScript type from a content type definition
+ *
+ * This extracts all field IDs from the definition and creates a type
+ * with those fields as optional properties. Field names will autocomplete
+ * in SDK methods like where(), select(), etc.
+ *
+ * Note: Field values are typed as `unknown`. For full value type inference,
+ * use the codegen tool to generate proper types.
+ *
+ * @example
+ * const product = defineContentType('product', {
+ *   displayName: 'Product',
+ *   fields: [
+ *     fields.shortText('title'),
+ *     fields.currency('price'),
+ *   ]
+ * })
+ *
+ * type Product = InferContentType<typeof product>
+ * // { title?: unknown; price?: unknown; _metadata: EntryMetadata }
+ */
+type InferContentType<T extends AnyContentTypeDefinition> = {
+    [K in ExtractFieldIds<T> & string]?: unknown;
+} & {
+    _metadata: EntryMetadata;
+};
+
+/**
+ * Singleton content type definition matching @relyio/schema
+ *
+ * In RelyIO, singletons are just content types with a special flag.
+ * They share the same structure as regular content types.
+ *
+ * Uses advanced TypeScript generics to preserve literal field IDs through
+ * the type system, enabling full autocomplete in SDK methods.
+ */
+
+/**
+ * Type alias for a fieldset with any fields.
+ */
+type AnyFieldset$1 = Fieldset<any>;
+/**
+ * Singleton content type definition - preserves field types for inference
+ */
+interface SingletonContentTypeDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset$1[] = readonly AnyFieldset$1[]> {
+    readonly _tag: 'singletonContentType';
+    readonly name: string;
+    readonly displayName: string;
+    readonly displayNamePlural?: string;
+    readonly description?: string;
+    /** AI configuration: generation guidance + entry intelligence */
+    readonly ai?: AIConfig;
+    /** Field ID to use as entry display title */
+    readonly displayField?: string;
+    readonly hierarchical: false;
+    readonly accessTags?: string[];
+    readonly fields?: TFields;
+    readonly fieldsets?: TFieldsets;
+}
+/**
+ * Define a singleton content type
+ *
+ * Singletons are single-instance content types like homepage, site settings, etc.
+ * They use the same field structure as regular content types.
+ *
+ * The generic type parameters preserve the literal field IDs through the type
+ * system, enabling autocomplete in SDK methods.
+ *
+ * @example
+ * const homepage = defineSingletonContentType('homepage', {
+ *   displayName: 'Homepage',
+ *   fields: [
+ *     fields.shortText('heroTitle', { config: { required: true } }),
+ *     fields.image('heroImage'),
+ *   ]
+ * })
+ */
+declare function defineSingletonContentType<TFields extends readonly AnyFieldDefinition[], _TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: ContentTypeConfigWithFields<TFields>): SingletonContentTypeDefinition<TFields, readonly []>;
+declare function defineSingletonContentType<_TFields extends readonly AnyFieldDefinition[], TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: ContentTypeConfigWithFieldsets<TFieldsets>): SingletonContentTypeDefinition<readonly [], TFieldsets>;
+declare const defineSingleton: typeof defineSingletonContentType;
+/**
+ * Singleton metadata
+ */
+interface SingletonMetadata {
+    /** Singleton key identifier */
+    key: string;
+    /** Singleton type identifier */
+    singletonType: string;
+    /** Content version */
+    version: number;
+    /** Content locale */
+    locale: string;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Last update timestamp */
+    updatedAt: Date;
+}
+/**
+ * Type alias for any singleton content type definition.
+ */
+type AnySingletonContentTypeDefinition = SingletonContentTypeDefinition<any, any>;
+/**
+ * Extract field IDs from a singleton content type definition
+ */
+type ExtractSingletonFieldIds<T extends AnySingletonContentTypeDefinition> = NonNullable<T['fields']> extends (infer F)[] ? F extends AnyFieldDefinition ? F['id'] : ExtractFromSingletonFieldsets<T> : ExtractFromSingletonFieldsets<T>;
+type ExtractFromSingletonFieldsets<T extends AnySingletonContentTypeDefinition> = NonNullable<T['fieldsets']> extends (infer FS)[] ? FS extends Fieldset<infer Fields> ? Fields extends AnyFieldDefinition[] ? Fields[number]['id'] : never : never : never;
+/**
+ * Infer the TypeScript type from a singleton definition
+ */
+type InferSingletonContentType<T extends AnySingletonContentTypeDefinition> = {
+    [K in ExtractSingletonFieldIds<T> & string]?: unknown;
+} & {
+    _metadata: SingletonMetadata;
+};
+type InferSingleton<T extends AnySingletonContentTypeDefinition> = InferSingletonContentType<T>;
+
+/**
+ * Component definition matching @relyio/schema ComponentSchema
+ *
+ * Components are reusable field groups that can be embedded in content types.
+ */
+
+interface ComponentReusabilityMetadata {
+    /** Minimum number of usages to be considered reusable */
+    minUsageCount?: number;
+    /** Maximum complexity score */
+    maxComplexity?: number;
+    /** Recommended usage contexts */
+    recommendedUsage?: string[];
+}
+interface ComponentValidationMetadata {
+    /** Whether nesting of components is allowed */
+    allowNesting?: boolean;
+    /** Maximum nesting depth */
+    maxNestingDepth?: number;
+    /** How to resolve field ID conflicts */
+    conflictResolution?: 'error' | 'component-wins' | 'field-wins' | 'prefix';
+}
+interface ComponentMetadata {
+    reusability?: ComponentReusabilityMetadata;
+    validation?: ComponentValidationMetadata;
+}
+/**
+ * Component configuration
+ */
+interface ComponentConfig {
+    /** Display name shown in the UI */
+    displayName?: string;
+    /** Description of the component */
+    description?: string;
+    /** AI configuration for content generation and review */
+    ai?: AIConfig;
+    /** Whether this component is deprecated */
+    deprecated?: boolean;
+    /** Component fields */
+    fields: FieldDefinition[];
+    /** Component metadata for validation and reusability */
+    metadata?: ComponentMetadata;
+}
+/**
+ * Component definition
+ */
+interface ComponentDefinition {
+    readonly _tag: 'component';
+    readonly name: string;
+    readonly displayName?: string;
+    readonly description?: string;
+    /** AI configuration for content generation and review */
+    readonly ai?: AIConfig;
+    readonly deprecated: boolean;
+    readonly fields: FieldDefinition[];
+    readonly metadata?: ComponentMetadata;
+}
+/**
+ * Define a reusable component (field group)
+ *
+ * @example
+ * const seoComponent = defineComponent('seoMetadata', {
+ *   displayName: 'SEO Metadata',
+ *   description: 'Common SEO fields for all content types',
+ *   fields: [
+ *     fields.shortText('metaTitle', {
+ *       config: { maxLength: 60 },
+ *       ui: { displayName: 'Meta Title' }
+ *     }),
+ *     fields.longText('metaDescription', {
+ *       config: { maxLength: 160 },
+ *       ui: { displayName: 'Meta Description' }
+ *     }),
+ *     fields.image('ogImage', {
+ *       ui: { displayName: 'Open Graph Image' }
+ *     }),
+ *   ]
+ * })
+ *
+ * // Use in a content type:
+ * const product = defineContentType('product', {
+ *   displayName: 'Product',
+ *   fields: [
+ *     fields.shortText('title', { config: { required: true } }),
+ *     fields.component('seo', 'seoMetadata'),  // Reference the component
+ *   ]
+ * })
+ */
+declare function defineComponent(name: string, config: ComponentConfig): ComponentDefinition;
+
+/**
+ * Settings group definition matching @relyio/schema SettingsGroupSchema
+ *
+ * Settings groups are for project-level configuration that doesn't fit
+ * into content types (e.g., API keys, feature flags, integrations).
+ *
+ * Uses advanced TypeScript generics to preserve literal field IDs through
+ * the type system, enabling full autocomplete in SDK methods.
+ */
+
+/**
+ * Settings group configuration - generic to preserve field types
+ */
+interface SettingsGroupConfig<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
+    /** Display name shown in the UI */
+    displayName: string;
+    /** Description of the settings group */
+    description?: string;
+    /** AI configuration for content generation and review */
+    ai?: AIConfig;
+    /** Access tags for role-based access control */
+    accessTags?: string[];
+    /** Settings fields - preserves literal types */
+    fields: TFields;
+}
+/**
+ * Settings group definition - preserves field types for inference
+ */
+interface SettingsGroupDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> {
+    readonly _tag: 'settingsGroup';
+    readonly name: string;
+    readonly displayName: string;
+    readonly description?: string;
+    /** AI configuration for content generation and review */
+    readonly ai?: AIConfig;
+    readonly accessTags?: string[];
+    readonly fields: TFields;
+}
+/**
+ * Define a settings group
+ *
+ * The generic type parameter preserves the literal field IDs through the type
+ * system, enabling autocomplete in SDK methods.
+ *
+ * @example
+ * const integrations = defineSettingsGroup('integrations', {
+ *   displayName: 'Integrations',
+ *   description: 'Third-party service integrations',
+ *   fields: [
+ *     fields.shortText('stripeApiKey', {
+ *       config: { required: true },
+ *       ui: { displayName: 'Stripe API Key' }
+ *     }),
+ *     fields.shortText('sendgridApiKey', {
+ *       ui: { displayName: 'SendGrid API Key' }
+ *     }),
+ *     fields.boolean('enableAnalytics', {
+ *       config: { defaultValue: true },
+ *       ui: { displayName: 'Enable Analytics' }
+ *     }),
+ *   ]
+ * })
+ */
+declare function defineSettingsGroup<TFields extends readonly AnyFieldDefinition[]>(name: string, config: SettingsGroupConfig<TFields>): SettingsGroupDefinition<TFields>;
+/**
+ * Type alias for any settings group definition.
+ */
+type AnySettingsGroupDefinition = SettingsGroupDefinition<any>;
+/**
+ * Extract field IDs from a settings group definition
+ */
+type ExtractSettingsFieldIds<T extends AnySettingsGroupDefinition> = T['fields'] extends readonly AnyFieldDefinition[] ? T['fields'][number]['id'] : never;
+/**
+ * Settings group metadata
+ */
+interface SettingsGroupMetadata {
+    /** Settings group key identifier */
+    key: string;
+    /** Settings group type identifier */
+    groupType: string;
+    /** Content version */
+    version: number;
+    /** Creation timestamp */
+    createdAt: Date;
+    /** Last update timestamp */
+    updatedAt: Date;
+}
+/**
+ * Infer the TypeScript type from a settings group definition
+ */
+type InferSettingsGroup<T extends AnySettingsGroupDefinition> = {
+    [K in ExtractSettingsFieldIds<T> & string]?: unknown;
+} & {
+    _metadata: SettingsGroupMetadata;
+};
+
+/**
+ * Asset type definition matching @relyio/schema AssetTypeSchema
+ *
+ * Asset types are first-class entries (entryType: 'asset') that pair a binary
+ * pipeline family (declared via exactly one kind key: `image`, `video`, or
+ * `file`) with user-defined metadata fields that reuse the standard field
+ * system — including fieldsets, workflow, access tags, and AI config.
+ *
+ * The kind config blocks are strongly typed below (mirroring the zod-inferred
+ * `@relyio/schema` types), so authoring asset types in TypeScript gets full
+ * autocomplete. The authoritative validation still lives in @relyio/schema's
+ * `AssetTypesValidator` and runs on deploy.
+ */
+
+/** Resize fit modes supported by the Cloudflare Images binding. */
+type ImageFitMode = 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
+/** Output formats the Cloudflare Images binding can produce (`heic` is input-only). */
+type ImageOutputFormat = 'avif' | 'webp' | 'jpeg' | 'png';
+/** Shared image transform props (CF Images vocabulary). */
+interface ImageTransform {
+    width?: number;
+    height?: number;
+    fit?: ImageFitMode;
+    format?: ImageOutputFormat;
+    quality?: number;
+}
+/** Upload gate for the `image` kind (rejects bad files at the door). */
+interface ImageUploadConfig {
+    allowedMimeTypes?: string[];
+    maxFileSize?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    /** `width:height`, e.g. `16:9`. */
+    aspectRatio?: string;
+}
+/** Upload gate for the `video` kind. */
+interface VideoUploadConfig {
+    allowedMimeTypes?: string[];
+    maxFileSize?: number;
+    maxDuration?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+}
+/** Upload gate for the `file` kind (MIME + size only in v1). */
+interface FileUploadConfig {
+    allowedMimeTypes?: string[];
+    maxFileSize?: number;
+}
+/** Delivery rendition preset (max 20 per asset type), applied on the fly by the gateway. */
+interface VariantDefinition extends ImageTransform {
+    /** Variant id; must start with a letter (codegen emits the `*Variant` union from these). */
+    id: string;
+}
+/**
+ * Ingest normalization of the canonical stored original (image v1 only).
+ * `true` expands to the platform default on deploy.
+ */
+type ImageSourceConfig = boolean | (ImageTransform & {
+    stripMetadata?: boolean;
+});
+/** EXIF retention policy for the `image` kind (plan 15). */
+interface ImageExifConfig {
+    /** Retain GPS in `extracted.exif` (default strips it for privacy). */
+    keepGps?: boolean;
+}
+/** Image kind config (`upload`, `source`, `variants`, `localization`, `exif`). */
+interface ImageKindConfig {
+    upload?: ImageUploadConfig;
+    source?: ImageSourceConfig;
+    /** Max 20 variants per asset type. */
+    variants?: VariantDefinition[];
+    localization?: LocalizationConfig;
+    exif?: ImageExifConfig;
+}
+/** Poster/thumbnail strategy for the `video` kind. */
+interface VideoPosterConfig {
+    /** 0.0–1.0 → Stream thumbnailTimestampPct. */
+    defaultTimestampPct?: number;
+    /** Enable an animated preview (gif/webp). */
+    animated?: boolean;
+}
+/** Subtitle track strategy for the `video` kind. */
+interface VideoCaptionsConfig {
+    enabled?: boolean;
+    requiredLocales?: string[];
+    /** Stream AI transcription when no track is uploaded. */
+    autoGenerate?: boolean;
+}
+/** Downloadable-MP4 toggle for the `video` kind. */
+interface VideoDownloadConfig {
+    enabled?: boolean;
+}
+/** Stream watermark profile for the `video` kind. */
+interface VideoWatermarkConfig {
+    enabled?: boolean;
+    /** Account-level Stream watermark profile uid. */
+    profileId?: string;
+}
+/**
+ * Video kind config (`upload`, `poster`, `captions`, `download`, `watermark`,
+ * `localization`). Stream auto-generates the ABR ladder — there is intentionally
+ * NO `variants` and NO `encoding` block.
+ */
+interface VideoKindConfig {
+    upload?: VideoUploadConfig;
+    poster?: VideoPosterConfig;
+    captions?: VideoCaptionsConfig;
+    download?: VideoDownloadConfig;
+    watermark?: VideoWatermarkConfig;
+    localization?: LocalizationConfig;
+}
+/** Malware scan config for the `file` kind (plan 19). */
+interface FileScanConfig {
+    enabled?: boolean;
+    blockUntilClean?: boolean;
+}
+/** File kind config (`upload`, `localization`, `scan`, `extractText`). */
+interface FileKindConfig {
+    upload?: FileUploadConfig;
+    localization?: LocalizationConfig;
+    /** Malware scan (plan 19). */
+    scan?: FileScanConfig;
+    /** Extract searchable text + metadata for PDFs (plan 15). */
+    extractText?: boolean;
+}
+interface AssetTypeBaseConfig {
+    /** Display name shown in the UI */
+    displayName: string;
+    /** Plural display name (e.g., "Product Photos" for "Product Photo") */
+    displayNamePlural?: string;
+    /** Description of the asset type */
+    description?: string;
+    /**
+     * AI configuration. `ai.instructions` is an optional global brief; per-field
+     * `ai.instructions` describe individual fields. `ai.autoGenerate` (image
+     * kind, v1) is the master switch: when true, the derived analysis agent runs
+     * after upload and fills every field that declares `ai.instructions`, applied
+     * as a review proposal.
+     */
+    ai?: AssetAIConfig;
+    /** Field ID to use as the asset display title */
+    displayField?: string;
+    /** Access tags for role-based access control */
+    accessTags?: string[];
+    /** Workflow configuration for this asset type */
+    workflow?: ContentTypeWorkflowConfig;
+    /** Image pipeline config — mutually exclusive with `video`/`file` */
+    image?: ImageKindConfig;
+    /** Video pipeline config — mutually exclusive with `image`/`file` */
+    video?: VideoKindConfig;
+    /** File pipeline config — mutually exclusive with `image`/`video` */
+    file?: FileKindConfig;
+}
+/**
+ * Type alias for a fieldset with any fields.
+ */
+type AnyFieldset = Fieldset<any>;
+/** Asset type configuration using direct fields. */
+interface AssetTypeConfigWithFields<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[]> extends AssetTypeBaseConfig {
+    /** Direct field definitions - preserves literal types */
+    fields: TFields;
+    /** Cannot have fieldsets when using fields */
+    fieldsets?: never;
+}
+/** Asset type configuration using fieldsets. */
+interface AssetTypeConfigWithFieldsets<TFieldsets extends readonly AnyFieldset[] = readonly AnyFieldset[]> extends AssetTypeBaseConfig {
+    /** Field organization via fieldsets - preserves literal types */
+    fieldsets: TFieldsets;
+    /** Cannot have direct fields when using fieldsets */
+    fields?: never;
+}
+/** Asset type configuration (either fields OR fieldsets). */
+type AssetTypeConfig<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset[] = readonly AnyFieldset[]> = AssetTypeConfigWithFields<TFields> | AssetTypeConfigWithFieldsets<TFieldsets>;
+/** Asset type definition - preserves field types for inference. */
+interface AssetTypeDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset[] = readonly AnyFieldset[]> {
+    readonly _tag: 'assetType';
+    readonly name: string;
+    readonly displayName: string;
+    readonly displayNamePlural?: string;
+    readonly description?: string;
+    readonly ai?: AssetAIConfig;
+    readonly displayField?: string;
+    readonly accessTags?: string[];
+    readonly workflow?: ContentTypeWorkflowConfig;
+    readonly image?: ImageKindConfig;
+    readonly video?: VideoKindConfig;
+    readonly file?: FileKindConfig;
+    readonly fields?: TFields;
+    readonly fieldsets?: TFieldsets;
+}
+/**
+ * Define an asset type.
+ *
+ * Exactly one kind key (`image`, `video`, or `file`) must be supplied. The
+ * generic type parameters preserve literal field IDs for inference, mirroring
+ * `defineContentType`.
+ *
+ * @example
+ * const productPhoto = defineAssetType('productPhoto', {
+ *   displayName: 'Product Photo',
+ *   image: {
+ *     upload: { allowedMimeTypes: ['image/jpeg', 'image/png', 'image/webp'], maxFileSize: 10485760 },
+ *     variants: [{ id: 'thumb', width: 200, height: 200, fit: 'cover', format: 'webp' }],
+ *   },
+ *   fields: [
+ *     fields.shortText('altText', { ui: { displayName: 'Alt Text' } }),
+ *   ],
+ * })
+ */
+declare function defineAssetType<TFields extends readonly AnyFieldDefinition[], _TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: AssetTypeConfigWithFields<TFields>): AssetTypeDefinition<TFields, readonly []>;
+declare function defineAssetType<_TFields extends readonly AnyFieldDefinition[], TFieldsets extends readonly Fieldset<AnyFieldDefinition[]>[]>(name: string, config: AssetTypeConfigWithFieldsets<TFieldsets>): AssetTypeDefinition<readonly [], TFieldsets>;
+/**
+ * Type alias for any asset type definition.
+ */
+type AnyAssetTypeDefinition = AssetTypeDefinition<any, any>;
+type ExtractAssetFieldIds<T extends AnyAssetTypeDefinition> = NonNullable<T['fields']> extends (infer F)[] ? F extends AnyFieldDefinition ? F['id'] : ExtractFromAssetFieldsets<T> : ExtractFromAssetFieldsets<T>;
+type ExtractFromAssetFieldsets<T extends AnyAssetTypeDefinition> = NonNullable<T['fieldsets']> extends (infer FS)[] ? FS extends Fieldset<infer Fields> ? Fields extends AnyFieldDefinition[] ? Fields[number]['id'] : never : never : never;
+/**
+ * Infer the TypeScript type from an asset type definition.
+ *
+ * Mirrors {@link InferContentType}: produces the (optional) metadata field shape
+ * plus `_metadata`, so it is assignable to `BaseContent` and can parametrize
+ * `AssetClient<T>`. The runtime `file`/`urls` blocks are layered on by the
+ * client's `AssetEntryResponse<T>` return type, not here, to keep the schema
+ * layer free of any dependency on the client layer.
+ */
+type InferAssetType<T extends AnyAssetTypeDefinition> = {
+    [K in ExtractAssetFieldIds<T> & string]?: unknown;
+} & {
+    _metadata: EntryMetadata;
+};
+
+/**
+ * Query definition matching @relyio/schema QueryDefinitionSchema
+ *
+ * Queries define predefined API endpoints with filtering, sorting, and caching.
+ */
+type WhereOperator = {
+    gte?: string | number;
+    lte?: string | number;
+    gt?: string | number;
+    lt?: string | number;
+    ne?: string | number | boolean;
+    in?: (string | number | boolean)[];
+    nin?: (string | number | boolean)[];
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    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>[];
+type IncludeRelationship = {
+    relationship: string;
+    where?: WhereCondition;
+    aggregate?: 'count' | 'sum' | 'avg' | 'min' | 'max';
+    alias?: string;
+};
+type IncludePath = {
+    path: string;
+    fields?: string[];
+    include?: (string | IncludePath)[];
+    where?: WhereCondition;
+};
+type IncludeDefinition = string | string[] | (string | IncludeRelationship | IncludePath)[];
+type SelectMapping = Record<string, string>;
+type FilterOperator = {
+    gte?: string;
+    lte?: string;
+    gt?: string;
+    lt?: string;
+    in?: string;
+    nin?: string;
+};
+type FilterDefinition = Record<string, string | FilterOperator>;
+type CachePolicyObject = {
+    policy: 'public' | 'private' | 'no-cache';
+    ttl?: number;
+    staleWhileRevalidate?: number;
+    tags?: string[];
+};
+type CachePolicy = string | CachePolicyObject;
+/**
+ * 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?: number;
+    /** Results offset */
+    offset?: 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;
+    })[];
+    /** Aggregation operations */
+    aggregations?: Record<string, string>;
+    /** Legacy: same as aggregations */
+    metrics?: Record<string, string>;
+    /** Having clause for filtering aggregations */
+    having?: Record<string, string | number | boolean | WhereOperator>;
+    /** Sort order */
+    sort?: SortCondition;
+    /** Maximum results */
+    limit?: 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?: number;
+    /** Results offset */
+    offset?: number;
+}
+/**
+ * Similar block - find similar content via vector search
+ */
+interface SimilarBlock {
+    /** Single content type */
+    contentType?: string;
+    /** Multiple content types or "*" for all */
+    contentTypes?: string | string[] | '*';
+    /** Source entry UID to find similar content for */
+    source: string;
+    /** Filter conditions */
+    where?: WhereCondition;
+    /** Field mapping for results */
+    fields?: SelectMapping;
+    /** Maximum results */
+    limit?: number;
+}
+/**
+ * Include sub-queries for additional data
+ */
+interface IncludeSubQuery {
+    source: string;
+    where?: WhereCondition;
+    sort?: SortCondition;
+    limit?: number;
+    select?: SelectMapping;
+}
+type IncludeSubQueries = Record<string, IncludeSubQuery>;
+/**
+ * Query definition configuration
+ */
+interface QueryConfig {
+    /** 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;
+    /** Similar block for vector similarity search */
+    similar?: SimilarBlock;
+    /** Include sub-queries */
+    include?: IncludeSubQueries;
+    /** Dynamic filter definitions */
+    filters?: FilterDefinition;
+    /** Field selection/mapping */
+    select?: SelectMapping;
+    /** Cache policy */
+    cache?: CachePolicy;
+}
+/**
+ * Query definition
+ */
+interface QueryDefinition {
+    readonly _tag: 'query';
+    readonly name: string;
+    readonly endpoint: string;
+    readonly description?: string;
+    readonly fetch?: FetchBlock;
+    readonly aggregate?: AggregateBlock;
+    readonly search?: SearchBlock;
+    readonly similar?: SimilarBlock;
+    readonly include?: IncludeSubQueries;
+    readonly filters?: FilterDefinition;
+    readonly select?: SelectMapping;
+    readonly cache?: CachePolicy;
+}
+/**
+ * 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'],
+ *     aggregations: {
+ *       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;
+/**
+ * Filter operators supported in view filters.
+ *
+ * Reverse-reference operators (`linksTo` / `doesNotLinkTo` / `hasAnyLink` /
+ * `hasNoLinks`) are intentionally absent: they were advertised here without a
+ * compiler, and a runtime no-op that silently drops a filter is worse than
+ * refusing the type. `@relyio/entry-reads`' `declareOperatorNames` makes naming
+ * an operator with no catalog `compile` a build failure. Follow-up: reverse-
+ * reference operators with entry-reads P5/P6 expansion.
+ */
+type ViewFilterOperator = 'is' | 'isNot' | 'contains' | 'doesNotContain' | 'startsWith' | 'endsWith' | 'isEmpty' | 'isNotEmpty' | 'equals' | 'notEquals' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'between' | 'isBefore' | 'isAfter' | 'isOnOrBefore' | 'isOnOrAfter' | 'inTheLast' | 'inTheNext' | 'today' | 'yesterday' | 'tomorrow' | 'thisWeek' | 'lastWeek' | 'thisMonth' | 'lastMonth' | 'isTrue' | 'isFalse' | 'isAnyOf' | 'isNoneOf' | 'includes' | 'includesAll' | 'includesAny' | 'excludes';
+/**
+ * Simple filter condition
+ */
+interface ViewFilterCondition {
+    /**
+     * Field ID to filter on
+     */
+    field: string;
+    /**
+     * Filter operator
+     */
+    operator: ViewFilterOperator;
+    /**
+     * Filter value (optional for some operators like isEmpty)
+     */
+    value?: unknown;
+}
+/**
+ * Grouped filter conditions with AND/OR logic
+ */
+interface ViewFilterGroup {
+    /**
+     * Logical operator to combine conditions
+     */
+    operator: 'and' | 'or';
+    /**
+     * Array of conditions in this group
+     */
+    conditions: ViewFilterCondition[];
+}
+/**
+ * Filter configuration can be simple conditions or groups
+ */
+type ViewFilter = ViewFilterCondition | ViewFilterGroup;
+/**
+ * View definition configuration
+ */
+interface ViewConfig {
+    /**
+     * Display name for the view
+     */
+    name: string;
+    /**
+     * URL-friendly slug for the view (optional, auto-generated from id if not provided)
+     * Used in Studio URLs like /studio/views/:slug
+     */
+    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)
+     * Simple array of conditions will be combined with AND
+     */
+    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 configuration (optional)
+     */
+    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;
+    /**
+     * URL-friendly slug for the view
+     * Auto-generated from id if not provided in config
+     */
+    readonly slug: string;
+}
+declare function defineView(id: string, config: ViewConfig): ViewDefinition;
+/**
+ * Convert a view definition to JSON format for the schema
+ */
+declare function viewToJSON(view: ViewDefinition): object;
+
+/**
+ * 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
+ * - components: Required record of component definitions (can be empty {})
+ * - singletonContentTypes: Required record of singleton definitions (can be empty {})
+ * - queries: Required record of query definitions (can be empty {})
+ * - settingsGroups: Optional record of settings groups
+ * - 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>;
+    /** Reusable component definitions (required, can be empty) */
+    components?: Record<string, ComponentDefinition>;
+    /** Singleton content type definitions (required, can be empty) */
+    singletonContentTypes?: Record<string, SingletonContentTypeDefinition>;
+    /** Predefined query definitions (required, can be empty) */
+    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>, TComponents extends Record<string, ComponentDefinition> = Record<string, ComponentDefinition>, TSingletons extends Record<string, SingletonContentTypeDefinition> = Record<string, SingletonContentTypeDefinition>, TQueries extends Record<string, QueryDefinition> = Record<string, QueryDefinition>, TSettings extends Record<string, SettingsGroupDefinition> = Record<string, SettingsGroupDefinition>, TLocales extends readonly LocaleDefinition[] = readonly LocaleDefinition[], TRoles extends readonly RoleDefinition[] = readonly RoleDefinition[], TWorkflow extends WorkflowDefinition | undefined = WorkflowDefinition | undefined, TViews extends readonly ViewDefinition[] = readonly ViewDefinition[], TAssets extends Record<string, AssetTypeDefinition> = Record<string, AssetTypeDefinition>> {
+    readonly _tag: 'schema';
+    readonly locales?: TLocales;
+    readonly contentTypes: TContentTypes;
+    readonly components: TComponents;
+    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>, TComponents extends Record<string, ComponentDefinition>, TSingletons extends Record<string, SingletonContentTypeDefinition>, TQueries extends Record<string, QueryDefinition>, TSettings extends Record<string, SettingsGroupDefinition>, TLocales extends readonly LocaleDefinition[] = readonly LocaleDefinition[], TRoles extends readonly RoleDefinition[] = readonly RoleDefinition[], TWorkflow extends WorkflowDefinition | undefined = WorkflowDefinition | undefined, TViews extends readonly ViewDefinition[] = readonly ViewDefinition[], TAssets extends Record<string, AssetTypeDefinition> = Record<string, AssetTypeDefinition>> {
+    locales?: TLocales;
+    contentTypes: TContentTypes;
+    components?: TComponents;
+    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, defineComponent, defineLocale, fields } from '@relyio/sdk/schema'
+ *
+ * const enUS = defineLocale('en-US', { displayName: 'English (US)', default: true })
+ * const esES = defineLocale('es-ES', { displayName: 'Spanish', fallback: ['en-US'] })
+ *
+ * const seoComponent = defineComponent('seo', {
+ *   displayName: 'SEO Metadata',
+ *   fields: [
+ *     fields.shortText('metaTitle', { config: { maxLength: 60 } }),
+ *     fields.longText('metaDescription', { config: { maxLength: 160 } }),
+ *   ]
+ * })
+ *
+ * const product = defineContentType('product', {
+ *   displayName: 'Product',
+ *   fields: [
+ *     fields.shortText('title', { config: { required: true }, localization: true }),
+ *     fields.currency('price', { config: { currencyCode: 'USD' } }),
+ *     fields.component('seo', 'seo'),
+ *   ]
+ * })
+ *
+ * export const schema = defineSchema({
+ *   locales: [enUS, esES],
+ *   contentTypes: { product },
+ *   components: { seo: seoComponent },
+ * })
+ */
+declare function defineSchema<TContentTypes extends Record<string, ContentTypeDefinition>, TComponents extends Record<string, ComponentDefinition> = Record<string, never>, TSingletons extends Record<string, SingletonContentTypeDefinition> = Record<string, never>, TQueries extends Record<string, QueryDefinition> = Record<string, never>, TSettings extends Record<string, SettingsGroupDefinition> = Record<string, never>, TLocales extends readonly LocaleDefinition[] = readonly LocaleDefinition[], TRoles extends readonly RoleDefinition[] = readonly RoleDefinition[], TWorkflow extends WorkflowDefinition | undefined = WorkflowDefinition | undefined, TViews extends readonly ViewDefinition[] = readonly ViewDefinition[], TAssets extends Record<string, AssetTypeDefinition> = Record<string, never>>(config: TypedSchemaConfig<TContentTypes, TComponents, TSingletons, TQueries, TSettings, TLocales, TRoles, TWorkflow, TViews, TAssets>): SchemaDefinition<TContentTypes, TComponents, TSingletons, TQueries, TSettings, TLocales, TRoles, TWorkflow, TViews, TAssets>;
+/**
+ * Convert a schema definition to JSON format for the CLI
+ *
+ * This strips out the _tag properties and converts to the format
+ * expected by the RelyIO backend.
+ */
+declare function schemaToJSON(schema: SchemaDefinition): object;
+/**
+ * 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;
+/**
+ * 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
+ */
+type SchemaSettingsGroupNames<T extends AnySchemaDefinition> = T['settingsGroups'] extends Record<string, SettingsGroupDefinition> ? keyof T['settingsGroups'] & string : never;
+/**
+ * Get asset type names from a schema
+ */
+type SchemaAssetTypeNames<T extends AnySchemaDefinition> = T['assetTypes'] extends Record<string, AssetTypeDefinition> ? keyof T['assetTypes'] & string : never;
+/**
+ * Get locale codes from a schema
+ */
+type SchemaLocaleCodes<T extends AnySchemaDefinition> = T['locales'] extends readonly LocaleDefinition[] ? T['locales'][number]['code'] : never;
+
+export { fieldset as $, type AIConfig as A, type BooleanConfig as B, type ComponentFieldType as C, type DecimalConfig as D, type EmailConfig as E, type FieldUIConfig as F, type SchemaQueryNames as G, type SchemaLocaleCodes as H, type IntegerConfig as I, type SchemaSettingsGroupNames as J, type SchemaAssetTypeNames as K, type LocalizationConfig as L, defineLocale as M, isLocaleDefinition as N, getLocaleCodes as O, findDefaultLocale as P, getActiveLocales as Q, type RichTextConfig as R, type ShortTextConfig as S, type TagsConfig as T, type UrlConfig as U, type ValidationRule as V, buildFallbackChain as W, type TextDirection as X, type LocaleOptions as Y, type LocaleDefinition as Z, defineContentType as _, type FieldAIConfig as a, isWorkflowDefinition as a$, type Fieldset as a0, type ContentTypeConfig as a1, type ContentTypeConfigWithFields as a2, type ContentTypeConfigWithFieldsets as a3, type ContentTypeDefinition as a4, type EntryMetadata as a5, type InferContentType as a6, defineSingletonContentType as a7, defineSingleton as a8, type SingletonContentTypeDefinition as a9, type ImageUploadConfig as aA, type ImageSourceConfig as aB, type ImageExifConfig as aC, type VariantDefinition as aD, type VideoUploadConfig as aE, type VideoPosterConfig as aF, type VideoCaptionsConfig as aG, type VideoDownloadConfig as aH, type VideoWatermarkConfig as aI, type FileUploadConfig as aJ, type FileScanConfig as aK, defineRole as aL, isRoleDefinition as aM, isBuiltInRole as aN, getBuiltInRoleActions as aO, BUILT_IN_ROLES as aP, ROLE_ACTIONS as aQ, BUILT_IN_ROLE_ACTIONS as aR, type BuiltInRole as aS, type RoleAction as aT, type ResourcePermission as aU, type FieldVisibility as aV, type RoleConfig as aW, type RoleDefinition as aX, defineWorkflow as aY, defineWorkflowStage as aZ, defineContentTypeWorkflow as a_, type SingletonMetadata as aa, type InferSingletonContentType as ab, type InferSingleton as ac, defineComponent as ad, type ComponentConfig as ae, type ComponentDefinition as af, type ComponentMetadata as ag, type ComponentReusabilityMetadata as ah, type ComponentValidationMetadata as ai, defineSettingsGroup as aj, type SettingsGroupConfig as ak, type SettingsGroupDefinition as al, type SettingsGroupMetadata as am, type InferSettingsGroup as an, defineAssetType as ao, type AssetTypeConfig as ap, type AssetTypeConfigWithFields as aq, type AssetTypeConfigWithFieldsets as ar, type AssetTypeDefinition as as, type InferAssetType as at, type ImageKindConfig as au, type VideoKindConfig as av, type FileKindConfig as aw, type ImageTransform as ax, type ImageFitMode as ay, type ImageOutputFormat as az, type FieldRule as b, isWorkflowStageDefinition as b0, getWorkflowStageIds as b1, findWorkflowStage as b2, getNextWorkflowStage as b3, getFirstWorkflowStage as b4, isFinalWorkflowStage as b5, workflowToJSON as b6, type WorkflowEscalation as b7, type WorkflowAutoAssign as b8, type WorkflowStageConfig as b9, type WhereOperator as bA, type SortCondition as bB, type SortDirection as bC, type IncludeDefinition as bD, type SelectMapping as bE, type FilterDefinition as bF, type CachePolicy as bG, type CachePolicyObject as bH, type IncludeSubQuery as bI, type IncludeSubQueries as bJ, type InferQueryResponse as bK, type InferQueryParams as bL, type WorkflowStageDefinition as ba, type WorkflowConfig as bb, type WorkflowDefinition as bc, type ContentTypeWorkflowConfig as bd, defineView as be, viewToJSON as bf, type ViewScopeConfig as bg, type ContentTypeScopeConfig as bh, type ContentTypesScopeConfig as bi, type EntryTypeScopeConfig as bj, type AllScopeConfig as bk, type ViewFilterOperator as bl, type ViewFilterCondition as bm, type ViewFilterGroup as bn, type ViewFilter as bo, type ViewConfig as bp, type ViewDefinition as bq, defineQuery as br, type QueryConfig as bs, type QueryDefinition as bt, type FetchBlock as bu, type AggregateBlock as bv, type SearchBlock as bw, type SimilarBlock as bx, type WhereCondition as by, type WhereValue as bz, type FieldDefinition as c, type LongTextConfig as d, type SlugConfig as e, type EnumConfig as f, type DateConfig as g, type DateTimeConfig as h, type ReferenceConfig as i, type ListConfig as j, type AllFieldTypes as k, type AnyFieldDefinition as l, type AssetAIConfig as m, type BaseFieldConfig as n, type FieldType as o, type ReadOnlyRule as p, type RequirementRule as q, type RuleCondition as r, type RuleConditions as s, type VisibilityRule as t, defineSchema as u, schemaToJSON as v, type SchemaConfig as w, type SchemaDefinition as x, type SchemaContentTypeNames as y, type SchemaSingletonNames as z };