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

package/dist/build.d.ts

@@ -2,7 +2,7 @@
  * `@formspec/build` - Build tools for FormSpec
  *
  * This package provides generators to compile FormSpec forms into:
- * - JSON Schema (for validation)
+ * - JSON Schema 2020-12 (for validation)
  * - JSON Forms UI Schema (for rendering)
  *
  * @example
@@ -25,6 +25,7 @@
 
 import type { FormElement } from '@formspec/core';
 import type { FormSpec } from '@formspec/core';
+import { z } from 'zod';
 
 /**
  * Builds both JSON Schema and UI Schema from a FormSpec.
@@ -59,105 +60,156 @@ export declare function buildFormSchemas<E extends readonly FormElement[]>(form:
  * Result of building form schemas.
  */
 export declare interface BuildResult {
-    /** JSON Schema for validation */
-    readonly jsonSchema: JSONSchema7;
+    /** JSON Schema 2020-12 for validation */
+    readonly jsonSchema: JsonSchema2020;
     /** JSON Forms UI Schema for rendering */
     readonly uiSchema: UISchema;
 }
 
 /**
- * Generated schemas for a class.
+ * A Categorization element (tab-based layout).
  */
-export declare interface ClassSchemas {
-    /** JSON Schema for validation */
-    jsonSchema: ExtendedJSONSchema7;
-    /** FormSpec/UI Schema for rendering */
-    uiSchema: {
-        elements: FormSpecField[];
-    };
+export declare interface Categorization {
+    type: "Categorization";
+    elements: Category[];
+    label?: string | undefined;
+    rule?: Rule | undefined;
+    options?: Record<string, unknown> | undefined;
+    [k: string]: unknown;
 }
 
+export declare const categorizationSchema: z.ZodType<Categorization>;
+
 /**
- * Options for code generation.
+ * A Category element, used inside a Categorization layout.
  */
-export declare interface CodegenOptions {
-    /** Source files to analyze (glob patterns supported) */
-    files: string[];
-    /** Output file path */
-    output: string;
-    /** Base directory for relative imports */
-    baseDir?: string;
+export declare interface Category {
+    type: "Category";
+    label: string;
+    elements: UISchemaElement[];
+    rule?: Rule | undefined;
+    options?: Record<string, unknown> | undefined;
+    [k: string]: unknown;
 }
 
+export declare const categorySchema: z.ZodType<Category>;
+
 /**
- * A Control element that binds to a JSON Schema property.
+ * Generated schemas for a class.
  */
-export declare interface ControlElement extends UISchemaElementBase {
-    type: "Control";
-    scope: string;
-    label?: string;
+export declare interface ClassSchemas {
+    /** JSON Schema 2020-12 for validation */
+    jsonSchema: JsonSchema2020;
+    /** JSON Forms UI Schema for rendering */
+    uiSchema: UISchema;
 }
 
 /**
- * Information about a decorated class found during codegen analysis.
- *
- * Used to track which classes need type metadata patches and where
- * they are located in the source tree.
+ * A Control element that binds to a JSON Schema property.
  */
-export declare interface DecoratedClassInfo {
-    /** Class name as it appears in the source file */
-    name: string;
-    /** Import path to the source file (relative to output, without extension) */
-    sourcePath: string;
-    /** Type metadata for all decorated properties in the class */
-    typeMetadata: Record<string, TypeMetadata>;
-    /** Whether the class is exported from its source file */
-    isExported: boolean;
-}
+export declare type ControlElement = z.infer<typeof controlSchema>;
+
+/**
+ * Zod schema for a Control element.
+ */
+export declare const controlSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Control">;
+    scope: z.ZodString;
+    label: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<false>]>>;
+    rule: z.ZodOptional<z.ZodObject<{
+        effect: z.ZodEnum<["SHOW", "HIDE", "ENABLE", "DISABLE"]>;
+        condition: z.ZodObject<{
+            scope: z.ZodString;
+            schema: z.ZodType<RuleConditionSchema, z.ZodTypeDef, RuleConditionSchema>;
+        }, "strict", z.ZodTypeAny, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodLiteral<"Control">;
+    scope: z.ZodString;
+    label: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<false>]>>;
+    rule: z.ZodOptional<z.ZodObject<{
+        effect: z.ZodEnum<["SHOW", "HIDE", "ENABLE", "DISABLE"]>;
+        condition: z.ZodObject<{
+            scope: z.ZodString;
+            schema: z.ZodType<RuleConditionSchema, z.ZodTypeDef, RuleConditionSchema>;
+        }, "strict", z.ZodTypeAny, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodLiteral<"Control">;
+    scope: z.ZodString;
+    label: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<false>]>>;
+    rule: z.ZodOptional<z.ZodObject<{
+        effect: z.ZodEnum<["SHOW", "HIDE", "ENABLE", "DISABLE"]>;
+        condition: z.ZodObject<{
+            scope: z.ZodString;
+            schema: z.ZodType<RuleConditionSchema, z.ZodTypeDef, RuleConditionSchema>;
+        }, "strict", z.ZodTypeAny, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
 
 /** JSON Schema with FormSpec extension properties for arbitrary x-formspec-* keys. */
 export declare type ExtendedJSONSchema7 = JSONSchema7 & FormSpecSchemaExtensions;
 
-/**
- * Finds all decorated classes in the given source files.
- */
-export declare function findDecoratedClasses(files: string[], baseDir: string): DecoratedClassInfo[];
-
-/**
- * FormSpec field definition (simplified for output).
- */
-export declare interface FormSpecField {
-    _field: string;
-    id: string;
-    label?: string;
-    placeholder?: string;
-    description?: string;
-    required?: boolean;
-    min?: number;
-    max?: number;
-    step?: number;
-    minLength?: number;
-    maxLength?: number;
-    minItems?: number;
-    maxItems?: number;
-    pattern?: string;
-    options?: (string | {
-        id: string;
-        label: string;
-    })[];
-    showWhen?: object;
-    group?: string;
-    fields?: FormSpecField[];
-}
-
 /** Extension properties for custom FormSpec decorators. */
 export declare type FormSpecSchemaExtensions = Record<`x-formspec-${string}`, unknown>;
 
-/**
- * Generates the codegen output file content.
- */
-export declare function generateCodegenOutput(classes: DecoratedClassInfo[], outputPath: string, baseDir: string): string;
-
 /**
  * Options for generating schemas from a decorated class.
  */
@@ -172,16 +224,17 @@ export declare interface GenerateFromClassOptions {
  * Result of generating schemas from a decorated class.
  */
 export declare interface GenerateFromClassResult {
-    /** JSON Schema for validation */
-    jsonSchema: ExtendedJSONSchema7;
-    /** FormSpec/UI Schema for rendering */
-    uiSchema: {
-        elements: FormSpecField[];
-    };
+    /** JSON Schema 2020-12 for validation */
+    jsonSchema: JsonSchema2020;
+    /** JSON Forms UI Schema for rendering */
+    uiSchema: UISchema;
 }
 
 /**
- * Generates a JSON Schema from a FormSpec.
+ * Generates a JSON Schema 2020-12 from a FormSpec.
+ *
+ * All generation routes through the canonical IR. The chain DSL is first
+ * canonicalized to a FormIR, then the IR-based generator produces the schema.
  *
  * @example
  * ```typescript
@@ -192,7 +245,7 @@ export declare interface GenerateFromClassResult {
  *
  * const schema = generateJsonSchema(form);
  * // {
- * //   $schema: "https://json-schema.org/draft-07/schema#",
+ * //   $schema: "https://json-schema.org/draft/2020-12/schema",
  * //   type: "object",
  * //   properties: {
  * //     name: { type: "string", title: "Name" },
@@ -203,25 +256,20 @@ export declare interface GenerateFromClassResult {
  * ```
  *
  * @param form - The FormSpec to convert
- * @returns A JSON Schema object
+ * @returns A JSON Schema 2020-12 object
  */
-export declare function generateJsonSchema<E extends readonly FormElement[]>(form: FormSpec<E>): JSONSchema7;
+export declare function generateJsonSchema<E extends readonly FormElement[]>(form: FormSpec<E>): JsonSchema2020;
 
 /**
- * Generates JSON Schema and FormSpec/UI Schema from a named TypeScript
+ * Generates JSON Schema and UI Schema from a named TypeScript
  * type — a decorated class, an interface with TSDoc tags, or a type alias.
  *
  * This is the recommended entry point. It automatically detects whether
  * the name resolves to a class, interface, or type alias and uses the
- * appropriate analysis pipeline:
- *
- * - **Classes**: extracts decorators and JSDoc constraints
- * - **Interfaces**: extracts TSDoc tags (`@Field_displayName`, `@Minimum`, etc.)
- * - **Type aliases**: object literal bodies analyzed like interfaces
+ * appropriate IR analysis pipeline.
  *
  * @example
  * ```typescript
- * // Works with both classes and interfaces — caller doesn't need to know
  * const result = generateSchemas({
  *   filePath: "./src/config.ts",
  *   typeName: "DiscountConfig",
@@ -229,15 +277,15 @@ export declare function generateJsonSchema<E extends readonly FormElement[]>(for
  * ```
  *
  * @param options - File path and type name
- * @returns Generated JSON Schema and FormSpec/UI Schema
+ * @returns Generated JSON Schema and UI Schema
  */
 export declare function generateSchemas(options: GenerateSchemasOptions): GenerateFromClassResult;
 
 /**
- * Generates JSON Schema and FormSpec/UI Schema from a decorated TypeScript class.
+ * Generates JSON Schema and UI Schema from a decorated TypeScript class.
  *
  * This is a high-level entry point that handles the entire pipeline:
- * creating a TypeScript program, finding the class, analyzing it,
+ * creating a TypeScript program, finding the class, analyzing it to IR,
  * and generating schemas — all in one call.
  *
  * @example
@@ -250,7 +298,7 @@ export declare function generateSchemas(options: GenerateSchemasOptions): Genera
  * ```
  *
  * @param options - File path, class name, and optional compiler options
- * @returns Generated JSON Schema and FormSpec/UI Schema
+ * @returns Generated JSON Schema and UI Schema
  */
 export declare function generateSchemasFromClass(options: GenerateFromClassOptions): GenerateFromClassResult;
 
@@ -267,6 +315,9 @@ export declare interface GenerateSchemasOptions {
 /**
  * Generates a JSON Forms UI Schema from a FormSpec.
  *
+ * All generation routes through the canonical IR. The chain DSL is first
+ * canonicalized to a FormIR, then the IR-based generator produces the schema.
+ *
  * @example
  * ```typescript
  * const form = formspec(
@@ -310,34 +361,80 @@ export declare function generateUiSchema<E extends readonly FormElement[]>(form:
 /**
  * Reads a FormSpec extension property from a JSON Schema node.
  *
- * Use this to safely read `x-formspec-*` properties from any schema,
- * including nested schemas typed as `JSONSchema7`.
+ * Accepts any schema object — `JSONSchema7`, `JsonSchema2020`, `ExtendedJSONSchema7`, etc.
  *
  * @param schema - Any JSON Schema node
  * @param key - Extension key (must start with `x-formspec-`)
  * @returns The extension value, or `undefined` if not present
  */
-export declare function getSchemaExtension(schema: JSONSchema7, key: `x-formspec-${string}`): unknown;
+export declare function getSchemaExtension(schema: object, key: `x-formspec-${string}`): unknown;
 
 /**
  * A group element with a label.
  */
-export declare interface GroupLayout extends UISchemaElementBase {
+export declare interface GroupLayout {
     type: "Group";
     label: string;
     elements: UISchemaElement[];
+    rule?: Rule | undefined;
+    options?: Record<string, unknown> | undefined;
+    [k: string]: unknown;
 }
 
+export declare const groupLayoutSchema: z.ZodType<GroupLayout>;
+
 /**
  * A horizontal layout element.
  */
-export declare interface HorizontalLayout extends UISchemaElementBase {
+export declare interface HorizontalLayout {
     type: "HorizontalLayout";
     elements: UISchemaElement[];
+    rule?: Rule | undefined;
+    options?: Record<string, unknown> | undefined;
+    [k: string]: unknown;
 }
 
+export declare const horizontalLayoutSchema: z.ZodType<HorizontalLayout>;
+
 /**
- * A JSON Schema definition (draft-07 subset).
+ * A JSON Schema 2020-12 document, sub-schema, or keyword collection.
+ *
+ * This interface covers the subset of JSON Schema 2020-12 that this generator
+ * emits, plus an index signature for custom `x-formspec-*` extension keywords.
+ */
+export declare interface JsonSchema2020 {
+    $schema?: string;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema2020>;
+    type?: string;
+    properties?: Record<string, JsonSchema2020>;
+    required?: string[];
+    items?: JsonSchema2020;
+    additionalProperties?: boolean;
+    enum?: readonly (string | number)[];
+    const?: string | number | boolean | null;
+    oneOf?: readonly JsonSchema2020[];
+    anyOf?: readonly JsonSchema2020[];
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    minLength?: number;
+    maxLength?: number;
+    minItems?: number;
+    maxItems?: number;
+    pattern?: string;
+    uniqueItems?: boolean;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    deprecated?: boolean;
+    [key: `x-${string}`]: unknown;
+}
+
+/**
+ * A JSON Schema definition (legacy subset used by Zod validator and types.ts).
  */
 export declare interface JSONSchema7 {
     $schema?: string;
@@ -388,8 +485,10 @@ export declare interface JSONSchema7 {
     "x-formspec-schemaSource"?: string;
 }
 
+export declare const jsonSchema7Schema: z.ZodType<JSONSchema7>;
+
 /**
- * JSON Schema Draft-07 type definitions.
+ * JSON Schema type definitions.
  *
  * These types are a subset of JSON Schema sufficient for form generation.
  */
@@ -398,44 +497,190 @@ export declare interface JSONSchema7 {
  */
 export declare type JSONSchemaType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
 
+/**
+ * Zod schema for JSON Schema primitive type strings.
+ */
+export declare const jsonSchemaTypeSchema: z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>;
+
+/**
+ * A Label element for displaying static text.
+ */
+export declare type LabelElement = z.infer<typeof labelElementSchema>;
+
+/**
+ * Zod schema for a Label element.
+ */
+export declare const labelElementSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Label">;
+    text: z.ZodString;
+    rule: z.ZodOptional<z.ZodObject<{
+        effect: z.ZodEnum<["SHOW", "HIDE", "ENABLE", "DISABLE"]>;
+        condition: z.ZodObject<{
+            scope: z.ZodString;
+            schema: z.ZodType<RuleConditionSchema, z.ZodTypeDef, RuleConditionSchema>;
+        }, "strict", z.ZodTypeAny, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodLiteral<"Label">;
+    text: z.ZodString;
+    rule: z.ZodOptional<z.ZodObject<{
+        effect: z.ZodEnum<["SHOW", "HIDE", "ENABLE", "DISABLE"]>;
+        condition: z.ZodObject<{
+            scope: z.ZodString;
+            schema: z.ZodType<RuleConditionSchema, z.ZodTypeDef, RuleConditionSchema>;
+        }, "strict", z.ZodTypeAny, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodLiteral<"Label">;
+    text: z.ZodString;
+    rule: z.ZodOptional<z.ZodObject<{
+        effect: z.ZodEnum<["SHOW", "HIDE", "ENABLE", "DISABLE"]>;
+        condition: z.ZodObject<{
+            scope: z.ZodString;
+            schema: z.ZodType<RuleConditionSchema, z.ZodTypeDef, RuleConditionSchema>;
+        }, "strict", z.ZodTypeAny, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }, {
+            schema: RuleConditionSchema;
+            scope: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }, {
+        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+        condition: {
+            schema: RuleConditionSchema;
+            scope: string;
+        };
+    }>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
+
 /**
  * Rule for conditional element visibility/enablement.
  */
-export declare interface Rule {
-    effect: RuleEffect;
-    condition: SchemaBasedCondition;
-}
+export declare type Rule = z.infer<typeof ruleSchema>;
 
 /**
- * JSON Schema subset for rule conditions.
+ * JSON Schema subset used in rule conditions.
  */
 export declare interface RuleConditionSchema {
     const?: unknown;
     enum?: readonly unknown[];
     type?: string;
+    not?: RuleConditionSchema;
     minimum?: number;
     maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    minLength?: number;
     properties?: Record<string, RuleConditionSchema>;
+    required?: string[];
     allOf?: RuleConditionSchema[];
 }
 
+export declare const ruleConditionSchema: z.ZodType<RuleConditionSchema>;
+
 /**
  * Rule effect types for conditional visibility.
  */
-export declare type RuleEffect = "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+export declare type RuleEffect = z.infer<typeof ruleEffectSchema>;
 
 /**
- * Runs the code generation.
+ * Zod schema for rule effect values.
  */
-export declare function runCodegen(options: CodegenOptions): void;
+export declare const ruleEffectSchema: z.ZodEnum<["SHOW", "HIDE", "ENABLE", "DISABLE"]>;
+
+/**
+ * Zod schema for a UI Schema rule.
+ */
+export declare const ruleSchema: z.ZodObject<{
+    effect: z.ZodEnum<["SHOW", "HIDE", "ENABLE", "DISABLE"]>;
+    condition: z.ZodObject<{
+        scope: z.ZodString;
+        schema: z.ZodType<RuleConditionSchema, z.ZodTypeDef, RuleConditionSchema>;
+    }, "strict", z.ZodTypeAny, {
+        schema: RuleConditionSchema;
+        scope: string;
+    }, {
+        schema: RuleConditionSchema;
+        scope: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+    condition: {
+        schema: RuleConditionSchema;
+        scope: string;
+    };
+}, {
+    effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+    condition: {
+        schema: RuleConditionSchema;
+        scope: string;
+    };
+}>;
 
 /**
  * Condition for a rule.
  */
-export declare interface SchemaBasedCondition {
+export declare type SchemaBasedCondition = z.infer<typeof schemaBasedConditionSchema>;
+
+/**
+ * Zod schema for a schema-based rule condition.
+ */
+export declare const schemaBasedConditionSchema: z.ZodObject<{
+    scope: z.ZodString;
+    schema: z.ZodType<RuleConditionSchema, z.ZodTypeDef, RuleConditionSchema>;
+}, "strict", z.ZodTypeAny, {
+    schema: RuleConditionSchema;
     scope: string;
+}, {
     schema: RuleConditionSchema;
-}
+    scope: string;
+}>;
 
 /**
  * Sets a FormSpec extension property on a JSON Schema node.
@@ -448,56 +693,25 @@ export declare interface SchemaBasedCondition {
  * @param key - Extension key (must start with `x-formspec-`)
  * @param value - Extension value
  */
-export declare function setSchemaExtension(schema: JSONSchema7, key: `x-formspec-${string}`, value: unknown): void;
+export declare function setSchemaExtension(schema: object, key: `x-formspec-${string}`, value: unknown): void;
 
 /**
- * Code generation for FormSpec type metadata.
- *
- * Generates a TypeScript file that patches decorated classes with
- * their extracted type metadata, enabling runtime schema generation
- * as an alternative to a TypeScript transformer.
- *
- * Usage:
- *   formspec codegen ./src/forms.ts -o ./src/__formspec_types__.ts
- *
- * Then in your code:
- *   import './__formspec_types__';  // Patches all decorated classes
- *   import { UserFormSchema, getUserFormFormSpec } from './__formspec_types__';
- *   const spec = getUserFormFormSpec();
- */
-/**
- * Type metadata format used by `@formspec/decorators`.
- *
- * Represents the runtime type information for a field that TypeScript
- * normally erases at compile time.
+ * Root UI Schema (always a layout — not a Control, Category, or Label).
  */
-export declare interface TypeMetadata {
-    /** Base type: "string", "number", "boolean", "enum", "array", "object", "unknown" */
-    type: string;
-    /** For enum types, the possible literal values */
-    values?: unknown[];
-    /** For array types, metadata about the array element type */
-    itemType?: TypeMetadata;
-    /** For object types, metadata about each property */
-    properties?: Record<string, TypeMetadata>;
-    /** Whether the field accepts null */
-    nullable?: boolean;
-    /** Whether the field is optional (T | undefined or ?: modifier) */
-    optional?: boolean;
-}
-
-/**
- * Root UI Schema (always a layout).
- */
-export declare type UISchema = VerticalLayout | HorizontalLayout | GroupLayout;
+export declare type UISchema = VerticalLayout | HorizontalLayout | GroupLayout | Categorization;
 
 /**
  * Union of all UI Schema element types.
  */
-export declare type UISchemaElement = ControlElement | VerticalLayout | HorizontalLayout | GroupLayout;
+export declare type UISchemaElement = ControlElement | VerticalLayout | HorizontalLayout | GroupLayout | Categorization | Category | LabelElement;
 
 /**
  * Base interface for all UI Schema elements.
+ *
+ * This is a manually maintained interface representing the common shape
+ * shared by all element types. It is kept as an interface (rather than
+ * derived from Zod) because it is the base of a discriminated union, not
+ * a union member itself.
  */
 export declare interface UISchemaElementBase {
     type: UISchemaElementType;
@@ -505,25 +719,36 @@ export declare interface UISchemaElementBase {
     options?: Record<string, unknown>;
 }
 
+export declare const uiSchemaElementSchema: z.ZodType<UISchemaElement>;
+
 /**
- * JSON Forms UI Schema type definitions.
- *
- * These types define the UI layout structure for JSON Forms.
- * See: https://jsonforms.io/docs/uischema/
+ * UI Schema element types.
  */
+export declare type UISchemaElementType = z.infer<typeof uiSchemaElementTypeSchema>;
+
 /**
- * UI Schema element types.
+ * Zod schema for UI Schema element type strings.
+ */
+export declare const uiSchemaElementTypeSchema: z.ZodEnum<["Control", "VerticalLayout", "HorizontalLayout", "Group", "Categorization", "Category", "Label"]>;
+
+/**
+ * Zod schema for the root UI Schema (layout types only).
  */
-export declare type UISchemaElementType = "Control" | "VerticalLayout" | "HorizontalLayout" | "Group" | "Categorization" | "Category";
+export declare const uiSchemaSchema: z.ZodType<UISchema>;
 
 /**
  * A vertical layout element.
  */
-export declare interface VerticalLayout extends UISchemaElementBase {
+export declare interface VerticalLayout {
     type: "VerticalLayout";
     elements: UISchemaElement[];
+    rule?: Rule | undefined;
+    options?: Record<string, unknown> | undefined;
+    [k: string]: unknown;
 }
 
+export declare const verticalLayoutSchema: z.ZodType<VerticalLayout>;
+
 /**
  * Builds and writes both JSON Schema and UI Schema files to disk.
  *