@relyio/sdk 0.2.0 → 0.3.0

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

@@ -0,0 +1,716 @@
+/**
+ * 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;
+
+/**
+ * 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 = 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>;
+/**
+ * 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;
+/**
+ * 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 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;
+};
+
+export { type WorkflowEscalation 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 ContentTypeDefinition as G, type EntryMetadata as H, type IntegerConfig as I, type InferContentType as J, type LocalePublicationFields as K, type LocalizationConfig as L, defineWorkflow as M, defineWorkflowStage as N, defineContentTypeWorkflow as O, isWorkflowDefinition as P, isWorkflowStageDefinition as Q, type RichTextConfig as R, type ShortTextConfig as S, type TagsConfig as T, type UrlConfig as U, type ValidationRule as V, getWorkflowStageIds as W, findWorkflowStage as X, getNextWorkflowStage as Y, getFirstWorkflowStage as Z, isFinalWorkflowStage as _, type FieldAIConfig as a, type WorkflowAutoAssign as a0, type WorkflowStageConfig as a1, type WorkflowStageDefinition as a2, type WorkflowConfig as a3, type WorkflowDefinition as a4, type ContentTypeWorkflowConfig as a5, 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 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, defineContentType as u, fieldset as v, type Fieldset as w, type ContentTypeConfig as x, type ContentTypeConfigWithFields as y, type ContentTypeConfigWithFieldsets as z };