@relyio/sdk 0.4.0 → 0.6.0

package/dist/define-content-type-CDB3kyeA.d.cts

@@ -0,0 +1,1173 @@
+/**
+ * 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;
+}
+/**
+ * `TValue` is the union of the option values and `TMulti` whether the field holds a list of them.
+ * `fields.enum()` infers both from the declaration, so a read of the field is typed by its options
+ * (`INV-SS-TYPES-INFERRED`); the defaults describe any enum field.
+ */
+interface EnumConfig<TValue extends string = string, TMulti extends boolean = boolean> extends BaseFieldConfig {
+    options: Array<{
+        value: TValue;
+        label?: string;
+    }>;
+    multi?: TMulti;
+}
+interface DateConfig extends BaseFieldConfig {
+    minDate?: string;
+    maxDate?: string;
+    format?: string;
+}
+interface DateTimeConfig extends BaseFieldConfig {
+    minDateTime?: string;
+    maxDateTime?: string;
+    format?: string;
+    timezone?: boolean;
+}
+/**
+ * `TTo` is the union of the target type ids and `TMulti` whether the field holds a list.
+ * `fields.reference()` infers both, so a read of the field is typed by what it points at
+ * (`INV-SS-TYPES-INFERRED`); the defaults describe any reference field.
+ */
+interface ReferenceConfig<TTo extends string = string, TMulti extends boolean = boolean> 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: TTo | TTo[];
+    /** Allow multiple references (the field value is a list). */
+    multi?: TMulti;
+    /** 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;
+}
+/**
+ * `TSubfields` is the declared subfields, which `fields.list()` infers so a read types each item by
+ * them (`INV-SS-TYPES-INFERRED`); the default describes any list field.
+ */
+interface ListConfig<TSubfields extends readonly AnyFieldDefinition[] = FieldDefinition[]> extends BaseFieldConfig {
+    dragAndDrop?: boolean;
+    minItems?: number;
+    maxItems?: number;
+    /** Subfields for list items */
+    subfields?: TSubfields;
+}
+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;
+
+/**
+ * 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$2 = Fieldset<any>;
+/**
+ * Singleton content type definition - preserves field types for inference
+ */
+interface SingletonContentTypeDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset$2[] = readonly AnyFieldset$2[]> {
+    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.
+ *
+ * The per-locale publication half is inherited from `LocalePublicationFields` rather than absent.
+ * `apps/services/api` reports `localeStatus` / `localeHasDraft` / `draftLocales` on singleton reads
+ * exactly as it does on entry reads (`INV-LM-PUBLICATION-IS-REPORTED-PER-LOCALE`); this type simply
+ * never said so, which told a customer that a singleton has no publication state to read.
+ */
+interface SingletonMetadata extends LocalePublicationFields {
+    /** 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>;
+/**
+ * Infer the TypeScript type from a singleton definition: every field typed as a read returns it
+ * (`schema/infer-fields.ts`), plus `_metadata`. `S` is the schema, as for `InferContentType`.
+ */
+type InferSingletonContentType<T extends AnySingletonContentTypeDefinition, S extends FieldSchemaContext | undefined = undefined> = FieldValues<DeclaredFields<T>, S> & {
+    _metadata: SingletonMetadata;
+};
+type InferSingleton<T extends AnySingletonContentTypeDefinition, S extends FieldSchemaContext | undefined = undefined> = InferSingletonContentType<T, S>;
+
+/**
+ * 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$1 = 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$1[] = readonly AnyFieldset$1[]> 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$1[] = readonly AnyFieldset$1[]> = AssetTypeConfigWithFields<TFields> | AssetTypeConfigWithFieldsets<TFieldsets>;
+/** Asset type definition - preserves field types for inference. */
+interface AssetTypeDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset$1[] = readonly AnyFieldset$1[]> {
+    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>;
+/**
+ * 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, S extends FieldSchemaContext | undefined = undefined> = FieldValues<DeclaredFields<T>, S> & {
+    _metadata: EntryMetadata;
+};
+
+/**
+ * What a read returns for each field, derived from the field's declaration (`INV-SS-TYPES-INFERRED`).
+ *
+ * Every `Infer*` in this package — content types, singletons, asset types, settings groups — types
+ * its fields here and nowhere else, so an entry, a referenced entry, a component and a list item are
+ * typed by one table. The types describe **what a read returns**, which is not always what a write
+ * accepts:
+ *
+ * - `richText` is the stored HTML string; `date` is `YYYY-MM-DD` and `dateTime` an ISO 8601 string —
+ *   the client does not revive dates.
+ * - A `reference` is the target's id until `include` names it, and then the target entry itself.
+ *   The type cannot see `include`, so it is both: `string | <entry>`. A single reference whose target
+ *   was deleted with `onTargetDelete: 'nullify'` is `null`.
+ * - A localized field is the value for the one locale the read composed, like any other field; the
+ *   other locales of a `locales=` read sit under `_metadata.localizations`, not here.
+ * - Every field is optional. The wire omits a field with no value — a draft, a `fields` projection, a
+ *   locale with nothing to fall back to, an entry older than a field — so `required` does not make
+ *   one present.
+ */
+
+/**
+ * The parts of a schema a field's value type reads: the types a reference may expand to and the
+ * components a component field names. Structural, so every `defineSchema()` result fits.
+ *
+ * Without one in view — `InferContentType<typeof post>` with no second argument — a reference
+ * expands to an {@link UnresolvedEntry} and a component to an {@link UnresolvedComponent}: the field
+ * is still typed, but what it names is not.
+ */
+interface FieldSchemaContext {
+    readonly contentTypes: object;
+    readonly components: object;
+    readonly singletonContentTypes: object;
+    readonly assetTypes?: object;
+}
+/** A schema in view, or `undefined` when none is. */
+type Context = FieldSchemaContext | undefined;
+/** An expanded reference whose target type is not in view: an entry, with fields nothing declared. */
+interface UnresolvedEntry {
+    _metadata: EntryMetadata;
+    [field: string]: unknown;
+}
+/** A component whose definition is not in view: an object, with fields nothing declared. */
+type UnresolvedComponent = Record<string, unknown>;
+/**
+ * One row per field type the schema declares. `OverEveryFieldType` makes the table exhaustive by
+ * construction: a field type added to `FieldType` without a row here fails to compile, rather than
+ * reading as `unknown`.
+ */
+type OverEveryFieldType<T extends {
+    [K in FieldType]: unknown;
+}> = T;
+type FieldValueByType<C, S extends Context> = OverEveryFieldType<{
+    shortText: string;
+    longText: string;
+    /** The stored HTML. */
+    richText: string;
+    email: string;
+    url: string;
+    slug: string;
+    integer: number;
+    decimal: number;
+    boolean: boolean;
+    enum: EnumValue<C>;
+    /** `YYYY-MM-DD`. */
+    date: string;
+    /** ISO 8601. */
+    dateTime: string;
+    reference: ReferenceValue<C, S>;
+    tags: string[];
+    list: ListValue<C, S>;
+}>;
+/**
+ * The value a read returns for field `F`.
+ *
+ * The last arm is the one `unknown` in this module, and it is deliberate: a field whose `type` is not
+ * a declared literal — a definition built from a plain `string` rather than through `fields.*` — has
+ * no row to read.
+ */
+type FieldValue<F extends AnyFieldDefinition, S extends Context = undefined> = F['type'] extends `component(${infer Id})` ? ComponentValue<Id, S> : F['type'] extends FieldType ? FieldValueByType<NonNullable<F['config']>, S>[F['type']] : unknown;
+/** The fields `F` (a union of field definitions) as an object, each optional — see the module note. */
+type FieldValues<F extends AnyFieldDefinition, S extends Context = undefined> = {
+    [K in F['id']]?: FieldValue<Extract<F, {
+        readonly id: K;
+    }>, S>;
+};
+/**
+ * Every field a definition declares, directly or through its fieldsets, as one union — the one walk
+ * over `fields` / `fieldsets` every `Infer*` shares.
+ */
+type DeclaredFields<T extends {
+    readonly fields?: unknown;
+    readonly fieldsets?: unknown;
+}> = Extract<(NonNullable<T['fields']> extends readonly (infer F)[] ? F : never) | (NonNullable<T['fieldsets']> extends readonly (infer FS)[] ? FS extends {
+    readonly fields: readonly (infer F)[];
+} ? F : never : never), AnyFieldDefinition>;
+/** `multi` as declared: `true`, `false`, or `boolean` when the declaration does not say. */
+type Multiplicity<C> = C extends {
+    readonly multi?: infer M;
+} ? M : false;
+/** One `V`, a list of them, or — when `multi` is not a literal — either. */
+type OneOrMany<C, V> = [Multiplicity<C>] extends [true] ? V[] : [Multiplicity<C>] extends [false | undefined] ? V : V | V[];
+type EnumValue<C> = OneOrMany<C, C extends {
+    readonly options: ReadonlyArray<{
+        readonly value: infer V;
+    }>;
+} ? V : string>;
+type ReferenceTarget<C> = C extends {
+    readonly to: infer T;
+} ? T extends readonly (infer E)[] ? E : T : string;
+/** `R[K]` where `R` declares `K`. A `Record<string, never>` default declares nothing. */
+type Declared<R, K> = K extends keyof R ? R[K] : never;
+type ContentEntryOf<D, S extends Context> = D extends ContentTypeDefinition ? InferContentType<D, S> : never;
+type SingletonEntryOf<D, S extends Context> = D extends SingletonContentTypeDefinition ? InferSingletonContentType<D, S> : never;
+type AssetEntryOf<D, S extends Context> = D extends AssetTypeDefinition ? InferAssetType<D, S> : never;
+type OrUnresolved<T> = [T] extends [never] ? UnresolvedEntry : T;
+/** What `include` expands a reference to `Target` into: that type's entry, typed by the schema. */
+type ExpandedEntry<Target, S extends Context> = S extends FieldSchemaContext ? OrUnresolved<ContentEntryOf<Declared<S['contentTypes'], Target>, S> | SingletonEntryOf<Declared<S['singletonContentTypes'], Target>, S> | AssetEntryOf<Declared<NonNullable<S['assetTypes']>, Target>, S>> : UnresolvedEntry;
+type ReferenceValue<C, S extends Context> = [Multiplicity<C>] extends [true] ? Array<string | ExpandedEntry<ReferenceTarget<C>, S>> : [Multiplicity<C>] extends [false | undefined] ? string | null | ExpandedEntry<ReferenceTarget<C>, S> : string | null | Array<string | ExpandedEntry<ReferenceTarget<C>, S>> | ExpandedEntry<ReferenceTarget<C>, S>;
+type ComponentFields<D, S extends Context> = [D] extends [never] ? UnresolvedComponent : D extends {
+    readonly fields: readonly (infer F)[];
+} ? FieldValues<Extract<F, AnyFieldDefinition>, S> : UnresolvedComponent;
+type ComponentValue<Id extends string, S extends Context> = S extends FieldSchemaContext ? ComponentFields<Declared<S['components'], Id>, S> : UnresolvedComponent;
+/**
+ * A list with subfields is a list of objects typed by them; a list without is a list of strings,
+ * which is what the validation document enforces for it.
+ */
+type ListValue<C, S extends Context> = C extends {
+    readonly subfields?: infer Sub;
+} ? Sub extends readonly (infer F)[] ? [F] extends [never] ? string[] : Array<FieldValues<Extract<F, AnyFieldDefinition>, S>> : string[] : string[];
+
+/**
+ * Content type definition matching @relyio/schema ContentTypeSchema
+ *
+ * Uses advanced TypeScript generics to preserve each field's declaration through the type system,
+ * so `InferContentType` types every field by what a read returns and `where()` autocompletes.
+ */
+
+/**
+ * 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 = 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[] = readonly AnyFieldset[]> {
+    /** 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[] = readonly AnyFieldset[]> = ContentTypeConfigWithFields<TFields> | ContentTypeConfigWithFieldsets<TFieldsets>;
+/**
+ * Content type definition - preserves field types for inference
+ */
+interface ContentTypeDefinition<TFields extends readonly AnyFieldDefinition[] = readonly AnyFieldDefinition[], TFieldsets extends readonly AnyFieldset[] = readonly AnyFieldset[]> {
+    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>;
+/**
+ * The per-locale publication half of an entry's metadata, declared once for this package.
+ *
+ * This is a **mirror** of `LocalePublicationFacts` in `@relyio/content-db`, the return type of the
+ * one derivation that produces these values server-side
+ * (`INV-LM-PUBLICATION-IS-REPORTED-PER-LOCALE`). It is declared again here rather than imported
+ * because this package is published to npm with exactly one runtime dependency and is built for
+ * browsers; taking a dependency on the content database's document layer to reach three field names
+ * is not a trade this SDK can make.
+ *
+ * Every field is **optional**, and that is deliberate rather than lax: a published client is always
+ * older than the service it talks to, so it must read a body that predates a field it knows about.
+ * Server-side the same three fields are required — `EntryMetadataResponse` in `apps/services/api`
+ * declares them so and `implements LocalePublicationFacts` proves it.
+ */
+interface LocalePublicationFields {
+    /** 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[];
+}
+/**
+ * Entry metadata that's present on all content entries.
+ *
+ * The per-locale publication half is inherited from `LocalePublicationFields` rather than restated,
+ * so this package holds one copy of it and not one per file.
+ */
+interface EntryMetadata extends LocalePublicationFields {
+    /** 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;
+    /** 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 of an entry from a content type definition: every field it declares,
+ * directly or through fieldsets, typed as a read returns it (`INV-SS-TYPES-INFERRED`), plus
+ * `_metadata`. Each field is optional — `schema/infer-fields.ts` says why, and what each field type
+ * reads as.
+ *
+ * `S` is the schema the type belongs to. With it, a reference expanded by `include` is typed as the
+ * entry it points at and a component field by the component's fields; without it, those two are
+ * typed as an entry or an object whose fields are not known. A client typed by a schema passes it.
+ *
+ * @example
+ * const product = defineContentType('product', {
+ *   displayName: 'Product',
+ *   fields: [
+ *     fields.shortText('title'),
+ *     fields.decimal('price'),
+ *     fields.enum('status', { config: { options: [{ value: 'draft' }, { value: 'live' }] } }),
+ *   ]
+ * })
+ *
+ * type Product = InferContentType<typeof product>
+ * // { title?: string; price?: number; status?: 'draft' | 'live'; _metadata: EntryMetadata }
+ */
+type InferContentType<T extends AnyContentTypeDefinition, S extends FieldSchemaContext | undefined = undefined> = FieldValues<DeclaredFields<T>, S> & {
+    _metadata: EntryMetadata;
+};
+
+export { type InferSingletonContentType as $, type AnyFieldDefinition as A, type BooleanConfig as B, type ComponentFieldType as C, type DecimalConfig as D, type EmailConfig as E, type FieldUIConfig as F, defineContentType as G, fieldset as H, type IntegerConfig as I, type Fieldset as J, type ContentTypeConfig as K, type LocalizationConfig as L, type ContentTypeConfigWithFields as M, type ContentTypeConfigWithFieldsets as N, type ContentTypeDefinition as O, type EntryMetadata as P, type InferContentType as Q, type RichTextConfig as R, type ShortTextConfig as S, type TagsConfig as T, type UrlConfig as U, type ValidationRule as V, type LocalePublicationFields as W, defineSingletonContentType as X, defineSingleton as Y, type SingletonContentTypeDefinition as Z, type SingletonMetadata as _, type FieldAIConfig as a, type InferSingleton as a0, defineAssetType as a1, type AssetTypeConfig as a2, type AssetTypeConfigWithFields as a3, type AssetTypeConfigWithFieldsets as a4, type AssetTypeDefinition as a5, type InferAssetType as a6, type ImageKindConfig as a7, type VideoKindConfig as a8, type FileKindConfig as a9, type WorkflowStageConfig as aA, type WorkflowStageDefinition as aB, type WorkflowConfig as aC, type WorkflowDefinition as aD, type ContentTypeWorkflowConfig as aE, type ImageTransform as aa, type ImageFitMode as ab, type ImageOutputFormat as ac, type ImageUploadConfig as ad, type ImageSourceConfig as ae, type ImageExifConfig as af, type VariantDefinition as ag, type VideoUploadConfig as ah, type VideoPosterConfig as ai, type VideoCaptionsConfig as aj, type VideoDownloadConfig as ak, type VideoWatermarkConfig as al, type FileUploadConfig as am, type FileScanConfig as an, defineWorkflow as ao, defineWorkflowStage as ap, defineContentTypeWorkflow as aq, isWorkflowDefinition as ar, isWorkflowStageDefinition as as, getWorkflowStageIds as at, findWorkflowStage as au, getNextWorkflowStage as av, getFirstWorkflowStage as aw, isFinalWorkflowStage as ax, type WorkflowEscalation as ay, type WorkflowAutoAssign as az, type FieldRule as b, 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 AIConfig as k, type AllFieldTypes 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, type FieldSchemaContext as u, type FieldValue as v, type FieldValues as w, type DeclaredFields as x, type UnresolvedEntry as y, type UnresolvedComponent as z };