@formspec/core 0.1.0-alpha.10 → 0.1.0-alpha.12

package/dist/core.d.ts

@@ -5,15 +5,32 @@
  * - Form element types (fields, groups, conditionals)
  * - Field and form state types
  * - Data source registry for dynamic enums
+ * - Canonical IR types (FormIR, FieldNode, TypeNode, ConstraintNode, AnnotationNode, etc.)
  *
  * @packageDocumentation
  */
 
+/**
+ * Discriminated union of all annotation types.
+ * Annotations are value-influencing: they describe or present a field
+ * but do not affect which values are valid.
+ */
+export declare type AnnotationNode = DisplayNameAnnotationNode | DescriptionAnnotationNode | PlaceholderAnnotationNode | DefaultValueAnnotationNode | DeprecatedAnnotationNode | FormatHintAnnotationNode | CustomAnnotationNode;
+
 /**
  * Union of all field types.
  */
 export declare type AnyField = TextField<string> | NumberField<string> | BooleanField<string> | StaticEnumField<string, readonly EnumOptionValue[]> | DynamicEnumField<string, string> | DynamicSchemaField<string> | ArrayField<string, readonly FormElement[]> | ObjectField<string, readonly FormElement[]>;
 
+/** Array uniqueness constraint. */
+export declare interface ArrayCardinalityConstraintNode {
+    readonly kind: "constraint";
+    readonly constraintKind: "uniqueItems";
+    readonly value: true;
+    readonly path?: PathTarget;
+    readonly provenance: Provenance;
+}
+
 /**
  * An array field containing repeating items.
  *
@@ -41,6 +58,12 @@ export declare interface ArrayField<N extends string, Items extends readonly For
     readonly maxItems?: number;
 }
 
+/** Array type with a single items type. */
+export declare interface ArrayTypeNode {
+    readonly kind: "array";
+    readonly items: TypeNode;
+}
+
 /**
  * A boolean checkbox field.
  *
@@ -59,6 +82,25 @@ export declare interface BooleanField<N extends string> {
     readonly required?: boolean;
 }
 
+/**
+ * Built-in constraint names mapped to their expected value type for parsing.
+ * Constraints are surface-agnostic — they manifest as both TSDoc tags
+ * (e.g., `@Minimum 0`) and chain DSL options (e.g., `{ minimum: 0 }`).
+ */
+export declare const BUILTIN_CONSTRAINT_DEFINITIONS: {
+    readonly Minimum: "number";
+    readonly Maximum: "number";
+    readonly ExclusiveMinimum: "number";
+    readonly ExclusiveMaximum: "number";
+    readonly MinLength: "number";
+    readonly MaxLength: "number";
+    readonly Pattern: "string";
+    readonly EnumOptions: "json";
+};
+
+/** Type of a built-in constraint name. */
+export declare type BuiltinConstraintName = keyof typeof BUILTIN_CONSTRAINT_DEFINITIONS;
+
 /**
  * A conditional wrapper that shows/hides elements based on another field's value.
  *
@@ -77,27 +119,23 @@ export declare interface Conditional<FieldName extends string, Value, Elements e
     readonly elements: Elements;
 }
 
+/** Conditional visibility based on another field's value. */
+export declare interface ConditionalLayoutNode {
+    readonly kind: "conditional";
+    /** The field whose value triggers visibility. */
+    readonly fieldName: string;
+    /** The value that makes the condition true (SHOW). */
+    readonly value: JsonValue;
+    /** Elements shown when the condition is met. */
+    readonly elements: readonly FormIRElement[];
+    readonly provenance: Provenance;
+}
+
 /**
- * Constraint decorator names that are valid as TSDoc tags, mapped to
- * their expected value type for parsing.
- *
- * Both `@formspec/build` (schema generation) and `@formspec/eslint-plugin`
- * (lint-time validation) import this to determine which JSDoc tags to
- * recognize and how to parse their values.
+ * Discriminated union of all constraint types.
+ * Constraints are set-influencing: they narrow the set of valid values.
  */
-export declare const CONSTRAINT_TAG_DEFINITIONS: {
-    readonly Minimum: "number";
-    readonly Maximum: "number";
-    readonly ExclusiveMinimum: "number";
-    readonly ExclusiveMaximum: "number";
-    readonly MinLength: "number";
-    readonly MaxLength: "number";
-    readonly Pattern: "string";
-    readonly EnumOptions: "json";
-};
-
-/** Type of a constraint tag name. */
-export declare type ConstraintTagName = keyof typeof CONSTRAINT_TAG_DEFINITIONS;
+export declare type ConstraintNode = NumericConstraintNode | LengthConstraintNode | PatternConstraintNode | ArrayCardinalityConstraintNode | EnumMemberConstraintNode | CustomConstraintNode;
 
 /**
  * Creates initial field state with default values.
@@ -108,6 +146,110 @@ export declare type ConstraintTagName = keyof typeof CONSTRAINT_TAG_DEFINITIONS;
  */
 export declare function createInitialFieldState<T>(value: T): FieldState<T>;
 
+/** Extension-registered custom annotation. */
+export declare interface CustomAnnotationNode {
+    readonly kind: "annotation";
+    readonly annotationKind: "custom";
+    /** Extension-qualified ID: `"<vendor-prefix>/<extension-name>/<annotation-name>"` */
+    readonly annotationId: string;
+    readonly value: JsonValue;
+    readonly provenance: Provenance;
+}
+
+/**
+ * Registration for a custom annotation that may produce JSON Schema keywords.
+ *
+ * Custom annotations are referenced via {@link CustomAnnotationNode} in the IR.
+ * They describe or present a field but do not affect which values are valid.
+ */
+export declare interface CustomAnnotationRegistration {
+    /** The annotation name, unique within the extension. */
+    readonly annotationName: string;
+    /**
+     * Optionally converts the annotation value into JSON Schema keywords.
+     * If omitted, the annotation has no JSON Schema representation (UI-only).
+     */
+    readonly toJsonSchema?: (value: JsonValue, vendorPrefix: string) => Record<string, unknown>;
+}
+
+/** Extension-registered custom constraint. */
+export declare interface CustomConstraintNode {
+    readonly kind: "constraint";
+    readonly constraintKind: "custom";
+    /** Extension-qualified ID: `"<vendor-prefix>/<extension-name>/<constraint-name>"` */
+    readonly constraintId: string;
+    /** JSON-serializable payload defined by the extension. */
+    readonly payload: JsonValue;
+    /** How this constraint composes with others of the same `constraintId`. */
+    readonly compositionRule: "intersect" | "override";
+    readonly path?: PathTarget;
+    readonly provenance: Provenance;
+}
+
+/**
+ * Registration for a custom constraint that maps to JSON Schema keywords.
+ *
+ * Custom constraints are referenced via {@link CustomConstraintNode} in the IR.
+ */
+export declare interface CustomConstraintRegistration {
+    /** The constraint name, unique within the extension. */
+    readonly constraintName: string;
+    /**
+     * How this constraint composes with other constraints of the same kind.
+     * - "intersect": combine with logical AND (both must hold)
+     * - "override": last writer wins
+     */
+    readonly compositionRule: "intersect" | "override";
+    /**
+     * TypeNode kinds this constraint is applicable to, or `null` for any type.
+     * Used by the validator to emit TYPE_MISMATCH diagnostics.
+     */
+    readonly applicableTypes: readonly TypeNode["kind"][] | null;
+    /**
+     * Converts the custom constraint's payload into JSON Schema keywords.
+     *
+     * @param payload - The opaque JSON payload from the {@link CustomConstraintNode}.
+     * @param vendorPrefix - The vendor prefix for extension keywords.
+     * @returns A JSON Schema fragment with the constraint keywords.
+     */
+    readonly toJsonSchema: (payload: JsonValue, vendorPrefix: string) => Record<string, unknown>;
+}
+
+/** Custom type registered by an extension. */
+export declare interface CustomTypeNode {
+    readonly kind: "custom";
+    /**
+     * The extension-qualified type identifier.
+     * Format: `"<vendor-prefix>/<extension-name>/<type-name>"`
+     * e.g., `"x-stripe/monetary/MonetaryAmount"`
+     */
+    readonly typeId: string;
+    /**
+     * Opaque payload serialized by the extension that registered this type.
+     * Must be JSON-serializable.
+     */
+    readonly payload: JsonValue;
+}
+
+/**
+ * Registration for a custom type that maps to a JSON Schema representation.
+ *
+ * Custom types are referenced via {@link CustomTypeNode} in the IR and
+ * resolved to JSON Schema via `toJsonSchema` during generation.
+ */
+export declare interface CustomTypeRegistration {
+    /** The type name, unique within the extension. */
+    readonly typeName: string;
+    /**
+     * Converts the custom type's payload into a JSON Schema fragment.
+     *
+     * @param payload - The opaque JSON payload from the {@link CustomTypeNode}.
+     * @param vendorPrefix - The vendor prefix for extension keywords (e.g., "x-stripe").
+     * @returns A JSON Schema fragment representing this type.
+     */
+    readonly toJsonSchema: (payload: JsonValue, vendorPrefix: string) => Record<string, unknown>;
+}
+
 /**
  * A single option returned by a data source resolver.
  *
@@ -150,6 +292,72 @@ export declare type DataSourceValueType<Source extends string> = Source extends
     id: infer ID;
 } ? ID : string : string;
 
+export declare interface DefaultValueAnnotationNode {
+    readonly kind: "annotation";
+    readonly annotationKind: "defaultValue";
+    /** Must be JSON-serializable and type-compatible (verified during Validate phase). */
+    readonly value: JsonValue;
+    readonly provenance: Provenance;
+}
+
+/**
+ * Defines a custom annotation registration. Currently an identity function
+ * that provides type-checking and IDE autocompletion.
+ *
+ * @param reg - The custom annotation registration.
+ * @returns The same registration, validated at the type level.
+ */
+export declare function defineAnnotation(reg: CustomAnnotationRegistration): CustomAnnotationRegistration;
+
+/**
+ * Defines a custom constraint registration. Currently an identity function
+ * that provides type-checking and IDE autocompletion.
+ *
+ * @param reg - The custom constraint registration.
+ * @returns The same registration, validated at the type level.
+ */
+export declare function defineConstraint(reg: CustomConstraintRegistration): CustomConstraintRegistration;
+
+/**
+ * Defines a custom type registration. Currently an identity function that
+ * provides type-checking and IDE autocompletion.
+ *
+ * @param reg - The custom type registration.
+ * @returns The same registration, validated at the type level.
+ */
+export declare function defineCustomType(reg: CustomTypeRegistration): CustomTypeRegistration;
+
+/**
+ * Defines a complete extension. Currently an identity function that provides
+ * type-checking and IDE autocompletion for the definition shape.
+ *
+ * @param def - The extension definition.
+ * @returns The same definition, validated at the type level.
+ */
+export declare function defineExtension(def: ExtensionDefinition): ExtensionDefinition;
+
+export declare interface DeprecatedAnnotationNode {
+    readonly kind: "annotation";
+    readonly annotationKind: "deprecated";
+    /** Optional deprecation message. */
+    readonly message?: string;
+    readonly provenance: Provenance;
+}
+
+export declare interface DescriptionAnnotationNode {
+    readonly kind: "annotation";
+    readonly annotationKind: "description";
+    readonly value: string;
+    readonly provenance: Provenance;
+}
+
+export declare interface DisplayNameAnnotationNode {
+    readonly kind: "annotation";
+    readonly annotationKind: "displayName";
+    readonly value: string;
+    readonly provenance: Provenance;
+}
+
 /**
  * A field with dynamic enum options (fetched from a data source at runtime).
  *
@@ -193,6 +401,36 @@ export declare interface DynamicSchemaField<N extends string> {
     readonly required?: boolean;
 }
 
+/** Dynamic type — schema resolved at runtime from a named data source. */
+export declare interface DynamicTypeNode {
+    readonly kind: "dynamic";
+    readonly dynamicKind: "enum" | "schema";
+    /** Key identifying the runtime data source or schema provider. */
+    readonly sourceKey: string;
+    /**
+     * For dynamic enums: field names whose current values are passed as
+     * parameters to the data source resolver.
+     */
+    readonly parameterFields: readonly string[];
+}
+
+/** A member of a static enum type. */
+export declare interface EnumMember {
+    /** The serialized value stored in data. */
+    readonly value: string | number;
+    /** Optional per-member display name. */
+    readonly displayName?: string;
+}
+
+/** Enum member subset constraint (refinement — only narrows). */
+export declare interface EnumMemberConstraintNode {
+    readonly kind: "constraint";
+    readonly constraintKind: "allowedMembers";
+    readonly members: readonly (string | number)[];
+    readonly path?: PathTarget;
+    readonly provenance: Provenance;
+}
+
 /**
  * An enum option with a separate ID and display label.
  *
@@ -208,6 +446,12 @@ export declare interface EnumOption {
  */
 export declare type EnumOptionValue = string | EnumOption;
 
+/** Static enum type — members known at build time. */
+export declare interface EnumTypeNode {
+    readonly kind: "enum";
+    readonly members: readonly EnumMember[];
+}
+
 /**
  * Predicate types for conditional logic.
  *
@@ -228,6 +472,39 @@ export declare interface EqualsPredicate<K extends string, V> {
     readonly value: V;
 }
 
+/**
+ * A complete extension definition bundling types, constraints, annotations,
+ * and vocabulary keywords.
+ *
+ * @example
+ * ```typescript
+ * const monetaryExtension = defineExtension({
+ *   extensionId: "x-stripe/monetary",
+ *   types: [
+ *     defineCustomType({
+ *       typeName: "Decimal",
+ *       toJsonSchema: (_payload, prefix) => ({
+ *         type: "string",
+ *         [`${prefix}-decimal`]: true,
+ *       }),
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare interface ExtensionDefinition {
+    /** Globally unique extension identifier, e.g., "x-stripe/monetary". */
+    readonly extensionId: string;
+    /** Custom type registrations provided by this extension. */
+    readonly types?: readonly CustomTypeRegistration[];
+    /** Custom constraint registrations provided by this extension. */
+    readonly constraints?: readonly CustomConstraintRegistration[];
+    /** Custom annotation registrations provided by this extension. */
+    readonly annotations?: readonly CustomAnnotationRegistration[];
+    /** Vocabulary keyword registrations provided by this extension. */
+    readonly vocabularyKeywords?: readonly VocabularyKeywordRegistration[];
+}
+
 /**
  * Response from a data source resolver function.
  *
@@ -242,6 +519,31 @@ export declare interface FetchOptionsResponse<T = unknown> {
     readonly message?: string;
 }
 
+/** A single form field after canonicalization. */
+export declare interface FieldNode {
+    readonly kind: "field";
+    /** The field's key in the data schema. */
+    readonly name: string;
+    /** The resolved type of this field. */
+    readonly type: TypeNode;
+    /** Whether this field is required in the data schema. */
+    readonly required: boolean;
+    /** Set-influencing constraints, after merging. */
+    readonly constraints: readonly ConstraintNode[];
+    /** Value-influencing annotations, after merging. */
+    readonly annotations: readonly AnnotationNode[];
+    /** Where this field was declared. */
+    readonly provenance: Provenance;
+    /**
+     * Debug only — ordered list of constraint/annotation nodes that participated
+     * in merging, including dominated ones.
+     */
+    readonly mergeHistory?: readonly {
+        readonly node: ConstraintNode | AnnotationNode;
+        readonly dominated: boolean;
+    }[];
+}
+
 /**
  * Represents the runtime state of a single form field.
  *
@@ -260,11 +562,49 @@ export declare interface FieldState<T> {
     readonly errors: readonly string[];
 }
 
+/** UI rendering hint — does not affect schema validation. */
+export declare interface FormatHintAnnotationNode {
+    readonly kind: "annotation";
+    readonly annotationKind: "formatHint";
+    /** Renderer-specific format identifier: "textarea", "radio", "date", "color", etc. */
+    readonly format: string;
+    readonly provenance: Provenance;
+}
+
 /**
  * Union of all form element types (fields and structural elements).
  */
 export declare type FormElement = AnyField | Group<readonly FormElement[]> | Conditional<string, unknown, readonly FormElement[]>;
 
+/**
+ * The complete Canonical Intermediate Representation for a form.
+ *
+ * Output of the Canonicalize phase; input to Validate, Generate (JSON Schema),
+ * and Generate (UI Schema) phases.
+ *
+ * Serializable to JSON — no live compiler objects.
+ */
+export declare interface FormIR {
+    readonly kind: "form-ir";
+    /**
+     * Schema version for the IR format itself.
+     * Should equal `IR_VERSION`.
+     */
+    readonly irVersion: string;
+    /** Top-level elements of the form: fields and layout nodes. */
+    readonly elements: readonly FormIRElement[];
+    /**
+     * Registry of named types referenced by fields in this form.
+     * Keys are fully-qualified type names matching `ReferenceTypeNode.name`.
+     */
+    readonly typeRegistry: Readonly<Record<string, TypeDefinition>>;
+    /** Provenance of the form definition itself. */
+    readonly provenance: Provenance;
+}
+
+/** Union of all IR element types. */
+export declare type FormIRElement = FieldNode | LayoutNode;
+
 /**
  * A complete form specification.
  *
@@ -275,12 +615,6 @@ export declare interface FormSpec<Elements extends readonly FormElement[]> {
     readonly elements: Elements;
 }
 
-/** Names of all built-in FormSpec decorators. */
-export declare const FORMSPEC_DECORATOR_NAMES: readonly ["Field", "Group", "ShowWhen", "EnumOptions", "Minimum", "Maximum", "ExclusiveMinimum", "ExclusiveMaximum", "MinLength", "MaxLength", "Pattern"];
-
-/** Type of a FormSpec decorator name. */
-export declare type FormSpecDecoratorName = (typeof FORMSPEC_DECORATOR_NAMES)[number];
-
 /**
  * Represents the runtime state of an entire form.
  *
@@ -315,6 +649,49 @@ export declare interface Group<Elements extends readonly FormElement[]> {
     readonly elements: Elements;
 }
 
+/** A visual grouping of form elements. */
+export declare interface GroupLayoutNode {
+    readonly kind: "group";
+    readonly label: string;
+    /** Elements contained in this group — may be fields or nested groups. */
+    readonly elements: readonly FormIRElement[];
+    readonly provenance: Provenance;
+}
+
+/**
+ * The current IR format version. Centralized here so all canonicalizers
+ * and consumers reference a single source of truth.
+ */
+export declare const IR_VERSION: "0.1.0";
+
+/**
+ * A JSON-serializable value. All IR nodes must be representable as JSON.
+ */
+export declare type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+
+/** Union of layout node types. */
+export declare type LayoutNode = GroupLayoutNode | ConditionalLayoutNode;
+
+/**
+ * String length and array item count constraints.
+ *
+ * `minLength`/`maxLength` apply to strings; `minItems`/`maxItems` apply to
+ * arrays. They share the same node shape because the composition rules are
+ * identical.
+ *
+ * Type applicability: `minLength`/`maxLength` require `PrimitiveTypeNode("string")`;
+ * `minItems`/`maxItems` require `ArrayTypeNode`.
+ */
+export declare interface LengthConstraintNode {
+    readonly kind: "constraint";
+    readonly constraintKind: "minLength" | "maxLength" | "minItems" | "maxItems";
+    readonly value: number;
+    readonly path?: PathTarget;
+    readonly provenance: Provenance;
+}
+
 /**
  * A numeric input field.
  *
@@ -337,6 +714,25 @@ export declare interface NumberField<N extends string> {
     readonly required?: boolean;
 }
 
+/**
+ * Numeric constraints: bounds and multipleOf.
+ *
+ * `minimum` and `maximum` are inclusive; `exclusiveMinimum` and
+ * `exclusiveMaximum` are exclusive bounds (matching JSON Schema 2020-12
+ * semantics).
+ *
+ * Type applicability: may only attach to fields with `PrimitiveTypeNode("number")`
+ * or a `ReferenceTypeNode` that resolves to one.
+ */
+export declare interface NumericConstraintNode {
+    readonly kind: "constraint";
+    readonly constraintKind: "minimum" | "maximum" | "exclusiveMinimum" | "exclusiveMaximum" | "multipleOf";
+    readonly value: number;
+    /** If present, targets a nested sub-field rather than the field itself. */
+    readonly path?: PathTarget;
+    readonly provenance: Provenance;
+}
+
 /**
  * An object field containing nested properties.
  *
@@ -360,6 +756,75 @@ export declare interface ObjectField<N extends string, Properties extends readon
     readonly required?: boolean;
 }
 
+/** A named property within an object type. */
+export declare interface ObjectProperty {
+    readonly name: string;
+    readonly type: TypeNode;
+    readonly optional: boolean;
+    /**
+     * Use-site constraints on this property.
+     * Distinct from constraints on the property's type — these are
+     * use-site constraints (e.g., `@minimum :amount 0` targets the
+     * `amount` property of a `MonetaryAmount` field).
+     */
+    readonly constraints: readonly ConstraintNode[];
+    /** Use-site annotations on this property. */
+    readonly annotations: readonly AnnotationNode[];
+    readonly provenance: Provenance;
+}
+
+/** Object type with named properties. */
+export declare interface ObjectTypeNode {
+    readonly kind: "object";
+    /**
+     * Named properties of this object. Order is preserved from the source
+     * declaration for deterministic output.
+     */
+    readonly properties: readonly ObjectProperty[];
+    /**
+     * Whether additional properties beyond those listed are permitted.
+     * Defaults to false — object types in FormSpec are closed.
+     */
+    readonly additionalProperties: boolean;
+}
+
+/**
+ * A path targeting a sub-field within a complex type.
+ * Used by constraints and annotations to target nested properties.
+ */
+export declare interface PathTarget {
+    /**
+     * Sequence of property names forming a path from the annotated field's type
+     * to the target sub-field.
+     * e.g., `["value"]` or `["address", "zip"]`
+     */
+    readonly segments: readonly string[];
+}
+
+/**
+ * String pattern constraint (ECMA-262 regex without delimiters).
+ *
+ * Multiple `pattern` constraints on the same field compose via intersection:
+ * all patterns must match simultaneously.
+ *
+ * Type applicability: requires `PrimitiveTypeNode("string")`.
+ */
+export declare interface PatternConstraintNode {
+    readonly kind: "constraint";
+    readonly constraintKind: "pattern";
+    /** ECMA-262 regular expression, without delimiters. */
+    readonly pattern: string;
+    readonly path?: PathTarget;
+    readonly provenance: Provenance;
+}
+
+export declare interface PlaceholderAnnotationNode {
+    readonly kind: "annotation";
+    readonly annotationKind: "placeholder";
+    readonly value: string;
+    readonly provenance: Provenance;
+}
+
 /**
  * Union of all predicate types.
  *
@@ -370,6 +835,55 @@ export declare interface ObjectField<N extends string, Properties extends readon
  */
 export declare type Predicate<K extends string = string, V = unknown> = EqualsPredicate<K, V>;
 
+/**
+ * Primitive types mapping directly to JSON Schema primitives.
+ *
+ * Note: integer is NOT a primitive kind — integer semantics are expressed
+ * via a `multipleOf: 1` constraint on a number type.
+ */
+export declare interface PrimitiveTypeNode {
+    readonly kind: "primitive";
+    readonly primitiveKind: "string" | "number" | "boolean" | "null";
+}
+
+/**
+ * Describes the origin of an IR node.
+ * Enables diagnostics that point to the source of a contradiction or error.
+ */
+export declare interface Provenance {
+    /** The authoring surface that produced this node. */
+    readonly surface: "tsdoc" | "chain-dsl" | "extension" | "inferred";
+    /** Absolute path to the source file. */
+    readonly file: string;
+    /** 1-based line number in the source file. */
+    readonly line: number;
+    /** 0-based column number in the source file. */
+    readonly column: number;
+    /** Length of the source span in characters (for IDE underline ranges). */
+    readonly length?: number;
+    /**
+     * The specific tag, call, or construct that produced this node.
+     * Examples: `@minimum`, `field.number({ min: 0 })`, `optional`
+     */
+    readonly tagName?: string;
+}
+
+/** Named type reference — preserved as references for `$defs`/`$ref` emission. */
+export declare interface ReferenceTypeNode {
+    readonly kind: "reference";
+    /**
+     * The fully-qualified name of the referenced type.
+     * For TypeScript interfaces/type aliases: `"<module>#<TypeName>"`.
+     * For built-in types: the primitive kind string.
+     */
+    readonly name: string;
+    /**
+     * Type arguments if this is a generic instantiation.
+     * e.g., `Array<string>` → `{ name: "Array", typeArguments: [PrimitiveTypeNode("string")] }`
+     */
+    readonly typeArguments: readonly TypeNode[];
+}
+
 /**
  * A field with static enum options (known at compile time).
  *
@@ -419,6 +933,27 @@ export declare interface TextField<N extends string> {
     readonly required?: boolean;
 }
 
+/** A named type definition stored in the type registry. */
+export declare interface TypeDefinition {
+    /** The fully-qualified reference name (key in the registry). */
+    readonly name: string;
+    /** The resolved type node. */
+    readonly type: TypeNode;
+    /** Where this type was declared. */
+    readonly provenance: Provenance;
+}
+
+/**
+ * Discriminated union of all type representations in the IR.
+ */
+export declare type TypeNode = PrimitiveTypeNode | EnumTypeNode | ArrayTypeNode | ObjectTypeNode | UnionTypeNode | ReferenceTypeNode | DynamicTypeNode | CustomTypeNode;
+
+/** Union type for non-enum unions. Nullable types are `T | null` using this. */
+export declare interface UnionTypeNode {
+    readonly kind: "union";
+    readonly members: readonly TypeNode[];
+}
+
 /**
  * Represents the validity state of a field or form.
  *
@@ -428,4 +963,14 @@ export declare interface TextField<N extends string> {
  */
 export declare type Validity = "valid" | "invalid" | "unknown";
 
+/**
+ * Registration for a vocabulary keyword to include in a JSON Schema `$vocabulary` declaration.
+ */
+export declare interface VocabularyKeywordRegistration {
+    /** The keyword name (without vendor prefix). */
+    readonly keyword: string;
+    /** JSON Schema that describes the valid values for this keyword. */
+    readonly schema: JsonValue;
+}
+
 export { }