@formspec/build 0.1.0-alpha.21 → 0.1.0-alpha.23

package/dist/build.d.ts

@@ -23,17 +23,39 @@
  * @packageDocumentation
  */
 
-import type { BuiltinConstraintBroadeningRegistration } from '@formspec/core';
-import type { ConstraintTagRegistration } from '@formspec/core';
-import type { CustomAnnotationRegistration } from '@formspec/core';
-import type { CustomConstraintRegistration } from '@formspec/core';
-import type { CustomTypeRegistration } from '@formspec/core';
-import type { ExtensionDefinition } from '@formspec/core';
-import type { FormElement } from '@formspec/core';
-import type { FormIR } from '@formspec/core';
-import type { FormSpec } from '@formspec/core';
-import type { JsonValue } from '@formspec/core';
-import { z } from 'zod';
+import { AnyField } from '@formspec/core';
+import { ArrayField } from '@formspec/core';
+import { BooleanField } from '@formspec/core';
+import { BuiltinConstraintBroadeningRegistration } from '@formspec/core';
+import { BuiltinConstraintName } from '@formspec/core';
+import { Conditional } from '@formspec/core';
+import { ConstraintSemanticRole } from '@formspec/core';
+import { ConstraintTagRegistration } from '@formspec/core';
+import { CustomAnnotationRegistration } from '@formspec/core';
+import { CustomConstraintRegistration } from '@formspec/core';
+import { CustomTypeRegistration } from '@formspec/core';
+import { DynamicEnumField } from '@formspec/core';
+import { DynamicSchemaField } from '@formspec/core';
+import { EnumOption } from '@formspec/core';
+import { EnumOptionValue } from '@formspec/core';
+import { ExtensionApplicableType } from '@formspec/core';
+import { ExtensionDefinition } from '@formspec/core';
+import { ExtensionPayloadValue } from '@formspec/core';
+import { ExtensionTypeKind } from '@formspec/core';
+import { FormElement } from '@formspec/core';
+import { FormSpec } from '@formspec/core';
+import { Group } from '@formspec/core';
+import { NumberField } from '@formspec/core';
+import { ObjectField } from '@formspec/core';
+import { StaticEnumField } from '@formspec/core';
+import { TextField } from '@formspec/core';
+import { VocabularyKeywordRegistration } from '@formspec/core';
+
+export { AnyField }
+
+export { ArrayField }
+
+export { BooleanField }
 
 /**
  * Builds both JSON Schema and UI Schema from a FormSpec.
@@ -97,7 +119,7 @@ export declare function buildMixedAuthoringSchemas(options: BuildMixedAuthoringS
  *
  * @public
  */
-export declare interface BuildMixedAuthoringSchemasOptions extends GenerateJsonSchemaFromIROptions {
+export declare interface BuildMixedAuthoringSchemasOptions extends StaticSchemaGenerationOptions {
     /** Path to the TypeScript source file. */
     readonly filePath: string;
     /** Name of the class, interface, or type alias to analyze. */
@@ -118,163 +140,57 @@ export declare interface BuildResult {
     readonly uiSchema: UISchema;
 }
 
+export { BuiltinConstraintBroadeningRegistration }
+
+export { BuiltinConstraintName }
+
 /**
  * A Categorization element (tab-based layout).
  *
  * @public
  */
 export declare interface Categorization {
-    type: "Categorization";
-    elements: Category[];
-    label?: string | undefined;
-    rule?: Rule | undefined;
-    options?: Record<string, unknown> | undefined;
-    [k: string]: unknown;
+    readonly type: "Categorization";
+    readonly elements: Category[];
+    readonly label?: string | undefined;
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
 }
 
-/**
- * Zod schema for a categorization element.
- *
- * @public
- */
-export declare const categorizationSchema: z.ZodType<Categorization>;
-
 /**
  * A Category element, used inside a Categorization layout.
  *
  * @public
  */
 export declare interface Category {
-    type: "Category";
-    label: string;
-    elements: UISchemaElement[];
-    rule?: Rule | undefined;
-    options?: Record<string, unknown> | undefined;
-    [k: string]: unknown;
+    readonly type: "Category";
+    readonly label: string;
+    readonly elements: UISchemaElement[];
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
 }
 
-/**
- * Zod schema for a category element.
- *
- * @public
- */
-export declare const categorySchema: z.ZodType<Category>;
+export { Conditional }
 
-/**
- * Generated schemas for a class.
- *
- * @public
- */
-export declare interface ClassSchemas {
-    /** JSON Schema 2020-12 for validation */
-    jsonSchema: JsonSchema2020;
-    /** JSON Forms UI Schema for rendering */
-    uiSchema: UISchema;
-}
+export { ConstraintSemanticRole }
 
-/**
- * A Control element that binds to a JSON Schema property.
- *
- * @public
- */
-export declare type ControlElement = z.infer<typeof controlSchema>;
+export { ConstraintTagRegistration }
 
 /**
- * Zod schema for a Control element.
+ * A Control element that binds to a JSON Schema property.
  *
  * @public
  */
-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, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }>>;
-    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, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }>>;
-    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, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }>>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.ZodTypeAny, "passthrough">>;
+export declare interface ControlElement {
+    readonly type: "Control";
+    readonly scope: string;
+    readonly label?: string | false | undefined;
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
+}
 
 /**
  * Creates an extension registry from a list of extension definitions.
@@ -291,12 +207,26 @@ export declare const controlSchema: z.ZodObject<{
  */
 export declare function createExtensionRegistry(extensions: readonly ExtensionDefinition[]): ExtensionRegistry;
 
-/**
- * JSON Schema with FormSpec extension properties for arbitrary `x-formspec-*` keys.
- *
- * @public
- */
-export declare type ExtendedJSONSchema7 = JSONSchema7 & FormSpecSchemaExtensions;
+export { CustomAnnotationRegistration }
+
+export { CustomConstraintRegistration }
+
+export { CustomTypeRegistration }
+
+export { DynamicEnumField }
+
+export { DynamicSchemaField }
+
+export { EnumOption }
+
+export { EnumOptionValue }
+
+/* Excluded from this release type: ExtendedJSONSchema7 */
+export { ExtensionApplicableType }
+
+export { ExtensionDefinition }
+
+export { ExtensionPayloadValue }
 
 /**
  * A registry of extensions that provides lookup by fully-qualified ID.
@@ -357,19 +287,20 @@ export declare interface ExtensionRegistry {
     findAnnotation(annotationId: string): CustomAnnotationRegistration | undefined;
 }
 
-/**
- * Extension properties for custom FormSpec constraint tags.
- *
- * @public
- */
-export declare type FormSpecSchemaExtensions = Record<`x-formspec-${string}`, unknown>;
+export { ExtensionTypeKind }
+
+export { FormElement }
+
+export { FormSpec }
+
+/* Excluded from this release type: FormSpecSchemaExtensions */
 
 /**
  * Options for generating schemas from a decorated class.
  *
  * @public
  */
-export declare interface GenerateFromClassOptions extends GenerateJsonSchemaFromIROptions {
+export declare interface GenerateFromClassOptions extends StaticSchemaGenerationOptions {
     /** Path to the TypeScript source file */
     filePath: string;
     /** Class name to analyze */
@@ -421,78 +352,18 @@ export declare interface GenerateFromClassResult {
 export declare function generateJsonSchema<E extends readonly FormElement[]>(form: FormSpec<E>, options?: GenerateJsonSchemaOptions): JsonSchema2020;
 
 /**
- * Generates a JSON Schema 2020-12 object from a canonical FormIR.
- *
- * Groups and conditionals are flattened — they influence UI layout but do not
- * affect the data schema. All fields appear at the level they would occupy in
- * the output data.
- *
- * Named types in the `typeRegistry` are emitted as `$defs` entries and
- * referenced via `$ref` (per PP7 — high-fidelity output).
- *
- * @example
- * ```typescript
- * import { canonicalizeDSL } from "./canonicalize/index.js";
- * import { generateJsonSchemaFromIR } from "./json-schema/ir-generator.js";
- * import { formspec, field } from "@formspec/dsl";
- *
- * const form = formspec(
- *   field.text("name", { label: "Name", required: true }),
- *   field.number("age", { min: 0 }),
- * );
- * const ir = canonicalizeDSL(form);
- * const schema = generateJsonSchemaFromIR(ir);
- * // {
- * //   $schema: "https://json-schema.org/draft/2020-12/schema",
- * //   type: "object",
- * //   properties: {
- * //     name: { type: "string", title: "Name" },
- * //     age:  { type: "number", minimum: 0 }
- * //   },
- * //   required: ["name"]
- * // }
- * ```
- *
- * Advanced API — most consumers should use `generateJsonSchema()` or
- * `buildFormSchemas()`, which canonicalize form definitions automatically.
- * Callers of this function are responsible for providing pre-canonicalized IR.
- *
- * @param ir - The canonical FormIR produced by a canonicalizer
- * @returns A plain JSON-serializable JSON Schema 2020-12 object
- *
- * @public
- */
-export declare function generateJsonSchemaFromIR(ir: FormIR, options?: GenerateJsonSchemaFromIROptions): JsonSchema2020;
-
-/**
- * Options for generating JSON Schema from a canonical FormIR.
+ * Options for generating JSON Schema from a Chain DSL form.
  *
  * @public
  */
-export declare interface GenerateJsonSchemaFromIROptions {
+export declare interface GenerateJsonSchemaOptions {
     /**
-     * Registry used to resolve custom types, constraints, and annotations.
-     *
-     * JSON Schema generation throws when custom IR nodes are present without a
-     * matching registration in this registry.
-     */
-    readonly extensionRegistry?: ExtensionRegistry | undefined;
-    /**
-     * Vendor prefix passed to extension `toJsonSchema` hooks.
+     * Vendor prefix for emitted extension keywords.
      * @defaultValue "x-formspec"
      */
     readonly vendorPrefix?: string | undefined;
 }
 
-/**
- * Options for generating JSON Schema from a Chain DSL form.
- *
- * These options are forwarded to the IR-based JSON Schema generator.
- *
- * @public
- */
-export declare type GenerateJsonSchemaOptions = GenerateJsonSchemaFromIROptions;
-
 /**
  * Generates JSON Schema and UI Schema from a named TypeScript
  * type — a decorated class, an interface with TSDoc tags, or a type alias.
@@ -544,7 +415,7 @@ export declare function generateSchemasFromClass(options: GenerateFromClassOptio
  *
  * @public
  */
-export declare interface GenerateSchemasOptions extends GenerateJsonSchemaFromIROptions {
+export declare interface GenerateSchemasOptions extends StaticSchemaGenerationOptions {
     /** Path to the TypeScript source file */
     filePath: string;
     /** Name of the exported class, interface, or type alias to analyze */
@@ -599,18 +470,7 @@ export declare interface GenerateSchemasOptions extends GenerateJsonSchemaFromIR
  */
 export declare function generateUiSchema<E extends readonly FormElement[]>(form: FormSpec<E>): UISchema;
 
-/**
- * Reads a FormSpec extension property from a JSON Schema node.
- *
- * 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
- *
- * @public
- */
-export declare function getSchemaExtension(schema: object, key: `x-formspec-${string}`): unknown;
+export { Group }
 
 /**
  * A group element with a label.
@@ -618,41 +478,27 @@ export declare function getSchemaExtension(schema: object, key: `x-formspec-${st
  * @public
  */
 export declare interface GroupLayout {
-    type: "Group";
-    label: string;
-    elements: UISchemaElement[];
-    rule?: Rule | undefined;
-    options?: Record<string, unknown> | undefined;
-    [k: string]: unknown;
+    readonly type: "Group";
+    readonly label: string;
+    readonly elements: UISchemaElement[];
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
 }
 
-/**
- * Zod schema for a group layout element.
- *
- * @public
- */
-export declare const groupLayoutSchema: z.ZodType<GroupLayout>;
-
 /**
  * A horizontal layout element.
  *
  * @public
  */
 export declare interface HorizontalLayout {
-    type: "HorizontalLayout";
-    elements: UISchemaElement[];
-    rule?: Rule | undefined;
-    options?: Record<string, unknown> | undefined;
-    [k: string]: unknown;
+    readonly type: "HorizontalLayout";
+    readonly elements: UISchemaElement[];
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
 }
 
-/**
- * Zod schema for a horizontal layout element.
- *
- * @public
- */
-export declare const horizontalLayoutSchema: z.ZodType<HorizontalLayout>;
-
 /**
  * A JSON Schema 2020-12 document, sub-schema, or keyword collection.
  *
@@ -671,7 +517,7 @@ export declare interface JsonSchema2020 {
     items?: JsonSchema2020;
     additionalProperties?: boolean | JsonSchema2020;
     enum?: readonly (string | number)[];
-    const?: JsonValue;
+    const?: unknown;
     allOf?: readonly JsonSchema2020[];
     oneOf?: readonly JsonSchema2020[];
     anyOf?: readonly JsonSchema2020[];
@@ -694,186 +540,22 @@ export declare interface JsonSchema2020 {
     [key: `x-${string}`]: unknown;
 }
 
-/**
- * A JSON Schema definition (legacy subset used by Zod validator and types.ts).
- *
- * @public
- */
-export declare interface JSONSchema7 {
-    $schema?: string;
-    $id?: string;
-    $ref?: string;
-    title?: string;
-    description?: string;
-    deprecated?: boolean;
-    type?: JSONSchemaType | JSONSchemaType[];
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: number;
-    exclusiveMaximum?: number;
-    enum?: readonly (string | number | boolean | null)[];
-    const?: string | number | boolean | null;
-    properties?: Record<string, JSONSchema7>;
-    required?: string[];
-    additionalProperties?: boolean | JSONSchema7;
-    items?: JSONSchema7 | JSONSchema7[];
-    minItems?: number;
-    maxItems?: number;
-    allOf?: JSONSchema7[];
-    anyOf?: JSONSchema7[];
-    oneOf?: JSONSchema7[];
-    not?: JSONSchema7;
-    if?: JSONSchema7;
-    then?: JSONSchema7;
-    else?: JSONSchema7;
-    format?: string;
-    default?: unknown;
-    /**
-     * Data source key for dynamic enum fields.
-     * Indicates that options should be fetched from a registered resolver.
-     */
-    "x-formspec-source"?: string;
-    /**
-     * Field names whose values are needed to fetch dynamic enum options.
-     * Used for dependent/cascading dropdowns.
-     */
-    "x-formspec-params"?: readonly string[];
-    /**
-     * Schema source identifier for dynamic schema fields.
-     * Indicates that the schema should be loaded dynamically at runtime.
-     */
-    "x-formspec-schemaSource"?: string;
-}
-
-/**
- * Zod schema for the legacy JSON Schema 7 subset used by `@formspec/build`.
- *
- * @public
- */
-export declare const jsonSchema7Schema: z.ZodType<JSONSchema7>;
-
-/**
- * JSON Schema type definitions.
- *
- * These types are a subset of JSON Schema sufficient for form generation.
- */
-/**
- * JSON Schema primitive types.
- *
- * @public
- */
-export declare type JSONSchemaType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
+/* Excluded from this release type: JSONSchema7 */
 
-/**
- * Zod schema for JSON Schema primitive type strings.
- *
- * @public
- */
-export declare const jsonSchemaTypeSchema: z.ZodEnum<["string", "number", "integer", "boolean", "object", "array", "null"]>;
+/* Excluded from this release type: JSONSchemaType */
 
 /**
  * A Label element for displaying static text.
  *
  * @public
  */
-export declare type LabelElement = z.infer<typeof labelElementSchema>;
-
-/**
- * Zod schema for a Label element.
- *
- * @public
- */
-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, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }>>;
-    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, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }>>;
-    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, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }, {
-        condition: {
-            schema: RuleConditionSchema;
-            scope: string;
-        };
-        effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-    }>>;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.ZodTypeAny, "passthrough">>;
+export declare interface LabelElement {
+    readonly type: "Label";
+    readonly text: string;
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
+}
 
 /**
  * Result of generating schemas from a mixed-authoring composition.
@@ -887,12 +569,19 @@ export declare interface MixedAuthoringSchemas {
     readonly uiSchema: UISchema;
 }
 
+export { NumberField }
+
+export { ObjectField }
+
 /**
  * Rule for conditional element visibility/enablement.
  *
  * @public
  */
-export declare type Rule = z.infer<typeof ruleSchema>;
+export declare interface Rule {
+    readonly effect: RuleEffect;
+    readonly condition: SchemaBasedCondition;
+}
 
 /**
  * JSON Schema subset used in rule conditions.
@@ -915,94 +604,50 @@ export declare interface RuleConditionSchema {
 }
 
 /**
- * Zod schema for the rule-condition JSON Schema subset.
+ * JSON Forms UI Schema type definitions.
  *
- * @public
- */
-export declare const ruleConditionSchema: z.ZodType<RuleConditionSchema>;
-
-/**
- * Rule effect types for conditional visibility.
+ * These are the consumer-facing TypeScript shapes. Runtime validation remains
+ * defined separately in `./schema.ts`.
  *
- * @public
- */
-export declare type RuleEffect = z.infer<typeof ruleEffectSchema>;
-
-/**
- * Zod schema for rule effect values.
- *
- * @public
+ * See: https://jsonforms.io/docs/uischema/
  */
-export declare const ruleEffectSchema: z.ZodEnum<["SHOW", "HIDE", "ENABLE", "DISABLE"]>;
-
 /**
- * Zod schema for a UI Schema rule.
+ * Rule effect types for conditional visibility.
  *
  * @public
  */
-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, {
-    condition: {
-        schema: RuleConditionSchema;
-        scope: string;
-    };
-    effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-}, {
-    condition: {
-        schema: RuleConditionSchema;
-        scope: string;
-    };
-    effect: "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
-}>;
+export declare type RuleEffect = "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
 
 /**
  * Condition for a rule.
  *
  * @public
  */
-export declare type SchemaBasedCondition = z.infer<typeof schemaBasedConditionSchema>;
+export declare interface SchemaBasedCondition {
+    readonly scope: string;
+    readonly schema: RuleConditionSchema;
+}
 
-/**
- * Zod schema for a schema-based rule condition.
- *
- * @public
- */
-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;
-}>;
+export { StaticEnumField }
 
 /**
- * Sets a FormSpec extension property on a JSON Schema node.
- *
- * Use this to safely add `x-formspec-*` properties to any schema,
- * including nested schemas typed as `JSONSchema7` (which don't carry
- * the extension index signature).
- *
- * @param schema - Any JSON Schema node
- * @param key - Extension key (must start with `x-formspec-`)
- * @param value - Extension value
+ * Shared options for schema generation flows that support custom extensions.
  *
  * @public
  */
-export declare function setSchemaExtension(schema: object, key: `x-formspec-${string}`, value: unknown): void;
+export declare interface StaticSchemaGenerationOptions {
+    /**
+     * Registry used to resolve custom types, constraints, and annotations.
+     */
+    readonly extensionRegistry?: ExtensionRegistry | undefined;
+    /**
+     * Vendor prefix for emitted extension keywords.
+     * @defaultValue "x-formspec"
+     */
+    readonly vendorPrefix?: string | undefined;
+}
+
+export { TextField }
 
 /**
  * Root UI Schema (always a layout — not a Control, Category, or Label).
@@ -1034,33 +679,12 @@ export declare interface UISchemaElementBase {
     options?: Record<string, unknown>;
 }
 
-/**
- * Zod schema for any UI Schema element.
- *
- * @public
- */
-export declare const uiSchemaElementSchema: z.ZodType<UISchemaElement>;
-
 /**
  * UI Schema element types.
  *
  * @public
  */
-export declare type UISchemaElementType = z.infer<typeof uiSchemaElementTypeSchema>;
-
-/**
- * Zod schema for UI Schema element type strings.
- *
- * @public
- */
-export declare const uiSchemaElementTypeSchema: z.ZodEnum<["Control", "VerticalLayout", "HorizontalLayout", "Group", "Categorization", "Category", "Label"]>;
-
-/**
- * Zod schema for the root UI Schema (layout types only).
- *
- * @public
- */
-export declare const uiSchemaSchema: z.ZodType<UISchema>;
+export declare type UISchemaElementType = "Control" | "VerticalLayout" | "HorizontalLayout" | "Group" | "Categorization" | "Category" | "Label";
 
 /**
  * A vertical layout element.
@@ -1068,19 +692,14 @@ export declare const uiSchemaSchema: z.ZodType<UISchema>;
  * @public
  */
 export declare interface VerticalLayout {
-    type: "VerticalLayout";
-    elements: UISchemaElement[];
-    rule?: Rule | undefined;
-    options?: Record<string, unknown> | undefined;
-    [k: string]: unknown;
+    readonly type: "VerticalLayout";
+    readonly elements: UISchemaElement[];
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
 }
 
-/**
- * Zod schema for a vertical layout element.
- *
- * @public
- */
-export declare const verticalLayoutSchema: z.ZodType<VerticalLayout>;
+export { VocabularyKeywordRegistration }
 
 /**
  * Builds and writes both JSON Schema and UI Schema files to disk.
@@ -1120,7 +739,7 @@ export declare function writeSchemas<E extends readonly FormElement[]>(form: For
  *
  * @public
  */
-export declare interface WriteSchemasOptions extends GenerateJsonSchemaFromIROptions {
+export declare interface WriteSchemasOptions extends GenerateJsonSchemaOptions {
     /** Output directory for the schema files */
     readonly outDir: string;
     /** Base name for the output files (without extension). Defaults to "schema" */