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

package/dist/build-alpha.d.ts

@@ -0,0 +1,836 @@
+/**
+ * `@formspec/build` - Build tools for FormSpec
+ *
+ * This package provides generators to compile FormSpec forms into:
+ * - JSON Schema 2020-12 (for validation)
+ * - JSON Forms UI Schema (for rendering)
+ *
+ * @example
+ * ```typescript
+ * import { buildFormSchemas } from "@formspec/build";
+ * import { formspec, field, group } from "@formspec/dsl";
+ *
+ * const form = formspec(
+ *   group("Customer",
+ *     field.text("name", { label: "Name", required: true }),
+ *     field.text("email", { label: "Email" }),
+ *   ),
+ * );
+ *
+ * const { jsonSchema, uiSchema } = buildFormSchemas(form);
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+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.
+ *
+ * This is a convenience function that combines `generateJsonSchema`
+ * and `generateUiSchema`.
+ *
+ * @example
+ * ```typescript
+ * const form = formspec(
+ *   field.text("name", { required: true }),
+ *   field.number("age", { min: 0 }),
+ * );
+ *
+ * const { jsonSchema, uiSchema } = buildFormSchemas(form);
+ *
+ * // Use with JSON Forms renderer
+ * <JsonForms
+ *   schema={jsonSchema}
+ *   uischema={uiSchema}
+ *   data={formData}
+ *   renderers={materialRenderers}
+ * />
+ * ```
+ *
+ * @param form - The FormSpec to build schemas from
+ * @returns Object containing both jsonSchema and uiSchema
+ *
+ * @public
+ */
+export declare function buildFormSchemas<E extends readonly FormElement[]>(form: FormSpec<E>, options?: BuildFormSchemasOptions): BuildResult;
+
+/**
+ * Options for building schemas from a FormSpec.
+ *
+ * Currently identical to `GenerateJsonSchemaOptions`. Defined separately so the
+ * Chain DSL surface can grow independently in the future if needed.
+ *
+ * @public
+ */
+export declare type BuildFormSchemasOptions = GenerateJsonSchemaOptions;
+
+/**
+ * Builds JSON Schema and UI Schema from a TSDoc-derived model with ChainDSL
+ * field overlays.
+ *
+ * Overlays are matched by field name. The static model wins for structure,
+ * ordering, and constraints; ChainDSL overlays may contribute dynamic runtime
+ * field metadata such as dynamic enum or dynamic schema keywords, and may fill
+ * in missing annotations.
+ *
+ * @public
+ */
+export declare function buildMixedAuthoringSchemas(options: BuildMixedAuthoringSchemasOptions): MixedAuthoringSchemas;
+
+/**
+ * Options for generating mixed-authoring schemas.
+ *
+ * The `typeName` can resolve to a class, interface, or object type alias, just
+ * like `generateSchemas()`.
+ *
+ * @public
+ */
+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. */
+    readonly typeName: string;
+    /** ChainDSL overlays to apply to the static model. Groups and conditionals are flattened by field name. */
+    readonly overlays: FormSpec<readonly FormElement[]>;
+}
+
+/**
+ * Result of building form schemas.
+ *
+ * @public
+ */
+export declare interface BuildResult {
+    /** JSON Schema 2020-12 for validation */
+    readonly jsonSchema: JsonSchema2020;
+    /** JSON Forms UI Schema for rendering */
+    readonly uiSchema: UISchema;
+}
+
+export { BuiltinConstraintBroadeningRegistration }
+
+export { BuiltinConstraintName }
+
+/**
+ * A Categorization element (tab-based layout).
+ *
+ * @public
+ */
+export declare interface Categorization {
+    readonly type: "Categorization";
+    readonly elements: Category[];
+    readonly label?: string | undefined;
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
+}
+
+/**
+ * A Category element, used inside a Categorization layout.
+ *
+ * @public
+ */
+export declare interface Category {
+    readonly type: "Category";
+    readonly label: string;
+    readonly elements: UISchemaElement[];
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
+}
+
+export { Conditional }
+
+export { ConstraintSemanticRole }
+
+export { ConstraintTagRegistration }
+
+/**
+ * A Control element that binds to a JSON Schema property.
+ *
+ * @public
+ */
+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.
+ *
+ * The registry indexes all types, constraints, and annotations by their
+ * fully-qualified IDs (`<extensionId>/<name>`) for O(1) lookup during
+ * generation and validation.
+ *
+ * @param extensions - The extension definitions to register.
+ * @returns An {@link ExtensionRegistry} instance.
+ * @throws If duplicate type/constraint/annotation IDs are detected across extensions.
+ *
+ * @public
+ */
+export declare function createExtensionRegistry(extensions: readonly ExtensionDefinition[]): ExtensionRegistry;
+
+export { CustomAnnotationRegistration }
+
+export { CustomConstraintRegistration }
+
+export { CustomTypeRegistration }
+
+export { DynamicEnumField }
+
+export { DynamicSchemaField }
+
+export { EnumOption }
+
+export { EnumOptionValue }
+
+/**
+ * JSON Schema with FormSpec extension properties for arbitrary `x-formspec-*` keys.
+ *
+ * @beta
+ */
+export declare type ExtendedJSONSchema7 = JSONSchema7 & FormSpecSchemaExtensions;
+
+export { ExtensionApplicableType }
+
+export { ExtensionDefinition }
+
+export { ExtensionPayloadValue }
+
+/**
+ * A registry of extensions that provides lookup by fully-qualified ID.
+ *
+ * Type IDs follow the format: `<extensionId>/<typeName>`
+ * Constraint IDs follow the format: `<extensionId>/<constraintName>`
+ * Annotation IDs follow the format: `<extensionId>/<annotationName>`
+ *
+ * @public
+ */
+export declare interface ExtensionRegistry {
+    /** The extensions registered in this registry (in registration order). */
+    readonly extensions: readonly ExtensionDefinition[];
+    /**
+     * Look up a custom type registration by its fully-qualified type ID.
+     *
+     * @param typeId - The fully-qualified type ID (e.g., "x-stripe/monetary/Decimal").
+     * @returns The registration if found, otherwise `undefined`.
+     */
+    findType(typeId: string): CustomTypeRegistration | undefined;
+    /**
+     * Look up a custom type registration by a TypeScript-facing type name.
+     *
+     * This is used during TSDoc/class analysis to resolve extension-defined
+     * custom types from source-level declarations.
+     */
+    findTypeByName(typeName: string): {
+        readonly extensionId: string;
+        readonly registration: CustomTypeRegistration;
+    } | undefined;
+    /**
+     * Look up a custom constraint registration by its fully-qualified constraint ID.
+     *
+     * @param constraintId - The fully-qualified constraint ID.
+     * @returns The registration if found, otherwise `undefined`.
+     */
+    findConstraint(constraintId: string): CustomConstraintRegistration | undefined;
+    /**
+     * Look up a TSDoc custom constraint-tag registration by tag name.
+     */
+    findConstraintTag(tagName: string): {
+        readonly extensionId: string;
+        readonly registration: ConstraintTagRegistration;
+    } | undefined;
+    /**
+     * Look up built-in tag broadening for a given custom type ID.
+     */
+    findBuiltinConstraintBroadening(typeId: string, tagName: string): {
+        readonly extensionId: string;
+        readonly registration: BuiltinConstraintBroadeningRegistration;
+    } | undefined;
+    /**
+     * Look up a custom annotation registration by its fully-qualified annotation ID.
+     *
+     * @param annotationId - The fully-qualified annotation ID.
+     * @returns The registration if found, otherwise `undefined`.
+     */
+    findAnnotation(annotationId: string): CustomAnnotationRegistration | undefined;
+}
+
+export { ExtensionTypeKind }
+
+export { FormElement }
+
+export { FormSpec }
+
+/**
+ * Extension properties for custom FormSpec constraint tags.
+ *
+ * @beta
+ */
+export declare type FormSpecSchemaExtensions = Record<`x-formspec-${string}`, unknown>;
+
+/**
+ * Options for generating schemas from a decorated class.
+ *
+ * @public
+ */
+export declare interface GenerateFromClassOptions extends StaticSchemaGenerationOptions {
+    /** Path to the TypeScript source file */
+    filePath: string;
+    /** Class name to analyze */
+    className: string;
+}
+
+/**
+ * Result of generating schemas from a decorated class.
+ *
+ * @public
+ */
+export declare interface GenerateFromClassResult {
+    /** JSON Schema 2020-12 for validation */
+    jsonSchema: JsonSchema2020;
+    /** JSON Forms UI Schema for rendering */
+    uiSchema: UISchema;
+}
+
+/**
+ * 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
+ * const form = formspec(
+ *   field.text("name", { label: "Name", required: true }),
+ *   field.number("age", { min: 0 }),
+ * );
+ *
+ * const schema = generateJsonSchema(form);
+ * // {
+ * //   $schema: "https://json-schema.org/draft/2020-12/schema",
+ * //   type: "object",
+ * //   properties: {
+ * //     name: { type: "string", title: "Name" },
+ * //     age: { type: "number", minimum: 0 }
+ * //   },
+ * //   required: ["name"]
+ * // }
+ * ```
+ *
+ * @param form - The FormSpec to convert
+ * @returns A JSON Schema 2020-12 object
+ *
+ * @public
+ */
+export declare function generateJsonSchema<E extends readonly FormElement[]>(form: FormSpec<E>, options?: GenerateJsonSchemaOptions): JsonSchema2020;
+
+/**
+ * Options for generating JSON Schema from a Chain DSL form.
+ *
+ * @public
+ */
+export declare interface GenerateJsonSchemaOptions {
+    /**
+     * Vendor prefix for emitted extension keywords.
+     * @defaultValue "x-formspec"
+     */
+    readonly vendorPrefix?: string | undefined;
+}
+
+/**
+ * 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 IR analysis pipeline.
+ *
+ * @example
+ * ```typescript
+ * const result = generateSchemas({
+ *   filePath: "./src/config.ts",
+ *   typeName: "DiscountConfig",
+ * });
+ * ```
+ *
+ * @param options - File path and type name
+ * @returns Generated JSON Schema and UI Schema
+ *
+ * @public
+ */
+export declare function generateSchemas(options: GenerateSchemasOptions): GenerateFromClassResult;
+
+/**
+ * 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 to IR,
+ * and generating schemas — all in one call.
+ *
+ * @example
+ * ```typescript
+ * const result = generateSchemasFromClass({
+ *   filePath: "./src/forms.ts",
+ *   className: "UserForm",
+ * });
+ * console.log(result.jsonSchema);
+ * ```
+ *
+ * @param options - File path, class name, and optional compiler options
+ * @returns Generated JSON Schema and UI Schema
+ *
+ * @public
+ */
+export declare function generateSchemasFromClass(options: GenerateFromClassOptions): GenerateFromClassResult;
+
+/**
+ * Options for generating schemas from a named type (class, interface, or type alias).
+ *
+ * @public
+ */
+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 */
+    typeName: string;
+}
+
+/**
+ * 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(
+ *   group("Customer",
+ *     field.text("name", { label: "Name" }),
+ *   ),
+ *   when("status", "draft",
+ *     field.text("notes", { label: "Notes" }),
+ *   ),
+ * );
+ *
+ * const uiSchema = generateUiSchema(form);
+ * // {
+ * //   type: "VerticalLayout",
+ * //   elements: [
+ * //     {
+ * //       type: "Group",
+ * //       label: "Customer",
+ * //       elements: [
+ * //         { type: "Control", scope: "#/properties/name", label: "Name" }
+ * //       ]
+ * //     },
+ * //     {
+ * //       type: "Control",
+ * //       scope: "#/properties/notes",
+ * //       label: "Notes",
+ * //       rule: {
+ * //         effect: "SHOW",
+ * //         condition: { scope: "#/properties/status", schema: { const: "draft" } }
+ * //       }
+ * //     }
+ * //   ]
+ * // }
+ * ```
+ *
+ * @param form - The FormSpec to convert
+ * @returns A JSON Forms UI Schema
+ *
+ * @public
+ */
+export declare function generateUiSchema<E extends readonly FormElement[]>(form: FormSpec<E>): UISchema;
+
+export { Group }
+
+/**
+ * A group element with a label.
+ *
+ * @public
+ */
+export declare interface GroupLayout {
+    readonly type: "Group";
+    readonly label: string;
+    readonly elements: UISchemaElement[];
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
+}
+
+/**
+ * A horizontal layout element.
+ *
+ * @public
+ */
+export declare interface HorizontalLayout {
+    readonly type: "HorizontalLayout";
+    readonly elements: UISchemaElement[];
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
+}
+
+/**
+ * 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.
+ *
+ * @public
+ */
+export declare interface JsonSchema2020 {
+    $schema?: string;
+    $ref?: string;
+    $defs?: Record<string, JsonSchema2020>;
+    type?: string;
+    properties?: Record<string, JsonSchema2020>;
+    required?: string[];
+    items?: JsonSchema2020;
+    additionalProperties?: boolean | JsonSchema2020;
+    enum?: readonly (string | number)[];
+    const?: unknown;
+    allOf?: readonly JsonSchema2020[];
+    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;
+    format?: string;
+    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).
+ *
+ * @beta
+ */
+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;
+}
+
+/**
+ * JSON Schema type definitions.
+ *
+ * These types are a subset of JSON Schema sufficient for form generation.
+ */
+/**
+ * JSON Schema primitive types.
+ *
+ * @beta
+ */
+export declare type JSONSchemaType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
+
+/**
+ * A Label element for displaying static text.
+ *
+ * @public
+ */
+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.
+ *
+ * @public
+ */
+export declare interface MixedAuthoringSchemas {
+    /** JSON Schema 2020-12 for validation. */
+    readonly jsonSchema: JsonSchema2020;
+    /** JSON Forms UI Schema for rendering. */
+    readonly uiSchema: UISchema;
+}
+
+export { NumberField }
+
+export { ObjectField }
+
+/**
+ * Rule for conditional element visibility/enablement.
+ *
+ * @public
+ */
+export declare interface Rule {
+    readonly effect: RuleEffect;
+    readonly condition: SchemaBasedCondition;
+}
+
+/**
+ * JSON Schema subset used in rule conditions.
+ *
+ * @public
+ */
+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[];
+}
+
+/**
+ * JSON Forms UI Schema type definitions.
+ *
+ * These are the consumer-facing TypeScript shapes. Runtime validation remains
+ * defined separately in `./schema.ts`.
+ *
+ * See: https://jsonforms.io/docs/uischema/
+ */
+/**
+ * Rule effect types for conditional visibility.
+ *
+ * @public
+ */
+export declare type RuleEffect = "SHOW" | "HIDE" | "ENABLE" | "DISABLE";
+
+/**
+ * Condition for a rule.
+ *
+ * @public
+ */
+export declare interface SchemaBasedCondition {
+    readonly scope: string;
+    readonly schema: RuleConditionSchema;
+}
+
+export { StaticEnumField }
+
+/**
+ * Shared options for schema generation flows that support custom extensions.
+ *
+ * @public
+ */
+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).
+ *
+ * @public
+ */
+export declare type UISchema = VerticalLayout | HorizontalLayout | GroupLayout | Categorization;
+
+/**
+ * Union of all UI Schema element types.
+ *
+ * @public
+ */
+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.
+ *
+ * @public
+ */
+export declare interface UISchemaElementBase {
+    type: UISchemaElementType;
+    rule?: Rule;
+    options?: Record<string, unknown>;
+}
+
+/**
+ * UI Schema element types.
+ *
+ * @public
+ */
+export declare type UISchemaElementType = "Control" | "VerticalLayout" | "HorizontalLayout" | "Group" | "Categorization" | "Category" | "Label";
+
+/**
+ * A vertical layout element.
+ *
+ * @public
+ */
+export declare interface VerticalLayout {
+    readonly type: "VerticalLayout";
+    readonly elements: UISchemaElement[];
+    readonly rule?: Rule | undefined;
+    readonly options?: Record<string, unknown> | undefined;
+    readonly [k: string]: unknown;
+}
+
+export { VocabularyKeywordRegistration }
+
+/**
+ * Builds and writes both JSON Schema and UI Schema files to disk.
+ *
+ * This is a convenience function for build-time schema generation.
+ * It creates the output directory if it doesn't exist.
+ *
+ * @example
+ * ```typescript
+ * import { formspec, field } from "formspec";
+ * import { writeSchemas } from "@formspec/build";
+ *
+ * const ProductForm = formspec(
+ *   field.text("name", { required: true }),
+ *   field.enum("status", ["draft", "active"]),
+ * );
+ *
+ * // Write schemas to ./generated/product-schema.json and ./generated/product-uischema.json
+ * const { jsonSchemaPath, uiSchemaPath } = writeSchemas(ProductForm, {
+ *   outDir: "./generated",
+ *   name: "product",
+ * });
+ *
+ * console.log(`Generated: ${jsonSchemaPath}, ${uiSchemaPath}`);
+ * ```
+ *
+ * @param form - The FormSpec to build schemas from
+ * @param options - Output options (directory, file name, indentation)
+ * @returns Object containing paths to the generated files
+ *
+ * @public
+ */
+export declare function writeSchemas<E extends readonly FormElement[]>(form: FormSpec<E>, options: WriteSchemasOptions): WriteSchemasResult;
+
+/**
+ * Options for writing schemas to disk.
+ *
+ * @public
+ */
+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" */
+    readonly name?: string;
+    /** Number of spaces for JSON indentation. Defaults to 2 */
+    readonly indent?: number;
+}
+
+/**
+ * Result of writing schemas to disk.
+ *
+ * @public
+ */
+export declare interface WriteSchemasResult {
+    /** Path to the generated JSON Schema file */
+    readonly jsonSchemaPath: string;
+    /** Path to the generated UI Schema file */
+    readonly uiSchemaPath: string;
+}
+
+export { }