@gravionlabs/helix-zod 22.0.0

package/types/gravionlabs-helix-zod.d.ts

@@ -0,0 +1,457 @@
+import * as _angular_core from '@angular/core';
+import { WritableSignal, InjectionToken, Type, EnvironmentProviders } from '@angular/core';
+import * as _angular_forms_signals from '@angular/forms/signals';
+import { SchemaPath, Field, ValidationError, FieldTree, SchemaFn, FieldState, FormValueControl } from '@angular/forms/signals';
+import { z, ZodSchema } from 'zod';
+import { ValidatorKey } from '@gravionlabs/helix-core/validators';
+import * as _gravionlabs_helix_zod from '@gravionlabs/helix-zod';
+import { ValidatorFn } from '@angular/forms';
+
+/**
+ * Built-in widget kinds plus any custom key registered via
+ * `provideHelixDynamicForms({ widgets })`.
+ */
+type HelixWidgetKind = 'text' | 'email' | 'password' | 'textarea' | 'number' | 'checkbox' | 'select' | 'date' | 'object' | 'array' | 'union' | (string & {});
+interface HelixSelectOption {
+    label: string;
+    value: unknown;
+}
+/**
+ * UI metadata attached to a Zod field schema. Drives labels, widget selection,
+ * ordering and the conditional engine of the dynamic form renderer.
+ *
+ * Attach it with {@link helixMeta} (preferred — keeps the same schema instance)
+ * or via `schema.meta({ title, description, helix: { ... } })`.
+ *
+ * @template TRoot The root form model type the conditional predicates receive.
+ */
+interface HelixFieldMeta<TRoot = Record<string, unknown>> {
+    label?: string;
+    placeholder?: string;
+    hint?: string;
+    /** Overrides the widget inferred from the Zod type. */
+    widget?: HelixWidgetKind;
+    /** Options for select-like widgets. Inferred from `z.enum()` when omitted. */
+    options?: readonly HelixSelectOption[] | readonly string[];
+    /** Render order among siblings — lower first; fields without order keep shape order. */
+    order?: number;
+    /** Label of the add button for array widgets. */
+    addLabel?: string;
+    /** Label of the remove button for array widgets. */
+    removeLabel?: string;
+    /** Hides the field (and excludes its errors from parent validity) when true. */
+    hiddenWhen?: (root: TRoot) => boolean;
+    /** Disables the field when truthy; a string return becomes the disabled reason. */
+    disabledWhen?: (root: TRoot) => boolean | string;
+    readonlyWhen?: (root: TRoot) => boolean;
+    /** Marks the field required (signal-forms `required()` with `when`). */
+    requiredWhen?: (root: TRoot) => boolean;
+    /**
+     * Escape hatch: additional signal-forms rules applied to this field's path
+     * inside the generated schema (e.g. `p => validate(p, ...)`).
+     */
+    extraSchema?: (path: SchemaPath<any>) => void;
+    /** Arbitrary passthrough for custom widgets. */
+    [key: string]: unknown;
+}
+/**
+ * Typed registry backing {@link helixMeta}. Checked before the zod global
+ * registry by {@link readHelixMeta}.
+ */
+declare const helixFieldMetaRegistry: z.core.$ZodRegistry<HelixFieldMeta<Record<string, unknown>>, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+/**
+ * Attaches Helix UI metadata to a Zod schema and returns the **same** instance.
+ *
+ * Prefer this over `.meta()`, which clones the schema — metadata must live on
+ * the exact instance composed into the `z.object()` shape for the walker to
+ * find it.
+ *
+ * @example
+ * const UserSchema = z.object({
+ *   email: helixMeta(z.email(), { label: 'E-mail', placeholder: 'you@example.com' }),
+ * });
+ */
+declare function helixMeta<S extends z.ZodType, TRoot = Record<string, unknown>>(schema: S, meta: HelixFieldMeta<TRoot>): S;
+/**
+ * Reads {@link HelixFieldMeta} from a Zod schema: the typed registry first,
+ * then the zod global registry (`.meta()` — `title` → `label`,
+ * `description` → `hint`, `helix` key merged on top).
+ *
+ * Wrapper types (`optional`, `nullable`, `default`, `readonly`) are unwrapped
+ * and their metadata merged — outermost wins.
+ */
+declare function readHelixMeta(schema: z.ZodType): HelixFieldMeta;
+
+/**
+ * Renderer-facing description of one form field, produced by
+ * `zodToFieldDescriptors` from an annotated Zod schema.
+ */
+interface HelixFieldDescriptor {
+    /** Property name in the parent shape; `''` for the root descriptor. */
+    key: string;
+    /** Path from the root model to this field. */
+    path: readonly string[];
+    /** Resolved widget: `meta.widget` override or the kind inferred from the Zod type. */
+    widget: HelixWidgetKind;
+    meta: HelixFieldMeta;
+    /** The unwrapped inner Zod type (optional/nullable/default wrappers peeled). */
+    zodType: z.ZodType;
+    /** The original Zod schema including wrappers — used to build default values. */
+    zodSource: z.ZodType;
+    /** True when the field is neither optional nor nullable and has no default. */
+    required: boolean;
+    /** Native `<input type>` for input-based widgets. */
+    inputType?: string;
+    /** Options for select-like widgets (from meta or `z.enum()`). */
+    options?: readonly HelixSelectOption[];
+    /** Child descriptors for object fields, sorted by `meta.order`. */
+    children?: readonly HelixFieldDescriptor[];
+    /** Element descriptor for array fields (path relative to the array item). */
+    itemDescriptor?: HelixFieldDescriptor;
+    /** Variant map for discriminated unions. */
+    union?: {
+        discriminator: string;
+        /** Discriminator literal → object descriptor of that variant. */
+        variants: ReadonlyMap<string | number | boolean, HelixFieldDescriptor>;
+    };
+}
+
+/**
+ * Dispatches one field descriptor to its registered widget component.
+ *
+ * Handles `hidden()` centrally: a hidden field renders nothing, per the
+ * signal-forms guidance to `@if` on the hidden state.
+ *
+ * Imports no widget statically — composite widgets (object/array/union) import
+ * this component, and built-in registrations live in
+ * `provideHelixDynamicForms()`, which breaks the import cycle.
+ */
+declare class HelixDynamicField {
+    #private;
+    readonly field: _angular_core.InputSignal<Field<any>>;
+    readonly descriptor: _angular_core.InputSignal<HelixFieldDescriptor>;
+    protected readonly component: _angular_core.Signal<_angular_core.Type<unknown>>;
+    protected readonly outletInputs: _angular_core.Signal<{
+        field: Field<any>;
+        descriptor: HelixFieldDescriptor;
+    }>;
+    protected readonly hiddenState: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixDynamicField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixDynamicField, "helix-dynamic-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "descriptor": { "alias": "descriptor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a complete signal form from an annotated Zod object schema.
+ *
+ * - Validation: root-level `validateStandardSchema` — Zod issues are routed to
+ *   the matching fields.
+ * - Model: pass your own `WritableSignal` via `model`, or let the component
+ *   derive an initial value from the schema (`buildDefaultValue`).
+ * - Swapping the `schema` input recreates the form and resets its state.
+ * - `submitted` emits the **parsed** (`schema.parse`) value on valid submit.
+ *
+ * Requires `provideHelixDynamicForms()` in the injector chain.
+ */
+declare class HelixDynamicForm<T extends Record<string, unknown> = Record<string, unknown>> {
+    #private;
+    readonly schema: _angular_core.InputSignal<z.ZodObject<z.core.$ZodLooseShape, z.core.$strip>>;
+    /** Optional external model — omit to derive the initial value from the schema. */
+    readonly model: _angular_core.InputSignal<WritableSignal<T> | undefined>;
+    readonly submitLabel: _angular_core.InputSignal<string>;
+    readonly showSubmit: _angular_core.InputSignal<boolean>;
+    readonly submitted: _angular_core.OutputEmitterRef<T>;
+    protected readonly descriptors: _angular_core.Signal<HelixFieldDescriptor>;
+    /** The form's `FieldTree` — recreated (state reset) when the schema changes. */
+    readonly formTree: _angular_core.Signal<_angular_forms_signals.FieldTree<T, string | number, "writable">>;
+    protected childField(descriptor: HelixFieldDescriptor): any;
+    protected handleSubmit(event: Event): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixDynamicForm<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixDynamicForm<any>, "helix-dynamic-form", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "model": { "alias": "model"; "required": false; "isSignal": true; }; "submitLabel": { "alias": "submitLabel"; "required": false; "isSignal": true; }; "showSubmit": { "alias": "showSubmit"; "required": false; "isSignal": true; }; }, { "submitted": "submitted"; }, never, never, true, never>;
+}
+
+/**
+ * App-level hook to customize user-facing error messages centrally.
+ * Return a string to use it, or `null`/`undefined` to fall back to the
+ * default message for the error.
+ */
+type HelixErrorMessageResolver = (error: ValidationError, helixKey: ValidatorKey | null) => string | null | undefined;
+/**
+ * Maps a signal-forms `ValidationError` to the `ValidatorKey` message
+ * convention shared with `HelixZodValidators.fromZod`.
+ *
+ * @param error The signal-forms validation error.
+ * @param value The current field value — used to distinguish Required from
+ *              type errors on Zod `invalid_type` issues (Zod v4 dropped the
+ *              `received` field).
+ */
+declare function helixErrorKey(error: ValidationError, value?: unknown): ValidatorKey | null;
+/**
+ * Returns the message of the first displayable error, mirroring
+ * `HelixFormField`'s first-error convention.
+ *
+ * Order of precedence per error: `resolver` result → Zod issue message /
+ * signal-forms error message. Errors yielding no message are skipped.
+ */
+declare function helixFirstErrorMessage(errors: readonly ValidationError[], options?: {
+    value?: unknown;
+    resolver?: HelixErrorMessageResolver;
+}): string | null;
+
+/** Registers a widget component for a {@link HelixWidgetKind}. */
+interface HelixFieldWidgetRegistration {
+    widget: HelixWidgetKind;
+    /** Component with `field` and `descriptor` inputs (see `HelixFieldWidgetBase`). */
+    component: Type<unknown>;
+}
+/**
+ * Multi-provider token holding widget registrations. Later registrations win,
+ * so consumer widgets registered after the built-ins override them.
+ */
+declare const HELIX_DYNAMIC_FIELD_WIDGETS: InjectionToken<readonly HelixFieldWidgetRegistration[][]>;
+/** Optional app-level error message resolver used by all built-in widgets. */
+declare const HELIX_ERROR_MESSAGE_RESOLVER: InjectionToken<HelixErrorMessageResolver>;
+/** Resolves the widget component registered for a widget kind. */
+declare class HelixFieldWidgetResolver {
+    #private;
+    resolve(widget: HelixWidgetKind): Type<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixFieldWidgetResolver, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+interface HelixDynamicFormsConfig {
+    /**
+     * Additional widget registrations. Registered after the built-ins, so a
+     * registration for an existing kind (e.g. `'select'`) overrides it.
+     */
+    widgets?: readonly HelixFieldWidgetRegistration[];
+    /** Central override hook for user-facing error messages. */
+    errorMessageResolver?: HelixErrorMessageResolver;
+}
+/**
+ * Provides the dynamic-form widget registry (built-in widgets included) and
+ * optional configuration. Add it to `ApplicationConfig.providers` or a route's
+ * `providers`.
+ */
+declare function provideHelixDynamicForms(config?: HelixDynamicFormsConfig): EnvironmentProviders;
+
+/**
+ * Navigates a `FieldTree` by a root-relative property path
+ * (e.g. `['address', 'city']`).
+ */
+declare function fieldAtPath(tree: FieldTree<any>, path: readonly string[]): any;
+
+/**
+ * Builds the signal-forms schema for a Zod-driven dynamic form:
+ *
+ * 1. Root-level `validateStandardSchema(rootPath, zodSchema)` — Zod issue
+ *    paths route errors onto the matching child fields, including cross-field
+ *    `.refine()` errors with a `path`.
+ * 2. Conditional field state from {@link HelixFieldMeta} predicates
+ *    (`hiddenWhen`/`disabledWhen`/`readonlyWhen`/`requiredWhen`), evaluated
+ *    against the root form value.
+ * 3. `meta.extraSchema` escape-hatch rules per field.
+ * 4. `applyEach` for array items and `applyWhenValue` for discriminated-union
+ *    variants, so variant/item rules stay dormant unless active.
+ */
+declare function buildHelixSchema<T extends Record<string, unknown>>(zodSchema: z.ZodObject, root: HelixFieldDescriptor): SchemaFn<T>;
+
+/**
+ * Builds a fully-populated initial model value for a Zod schema — signal forms
+ * require a concrete model shape up front.
+ *
+ * Rules: `.default()` wins; strings → `''`; numbers/dates → `null` (paired
+ * with parse-transforming widgets); booleans → `false`; enums → first option;
+ * arrays → `[]`; objects → recursed shape; discriminated unions → default of
+ * the first variant; `optional`/`nullable` leaves without a more specific
+ * default → `undefined` / `null`.
+ */
+declare function buildDefaultValue(schema: z.ZodType): unknown;
+
+/**
+ * Walks an annotated `z.object()` schema and produces the recursive
+ * {@link HelixFieldDescriptor} tree consumed by the dynamic form renderer.
+ *
+ * Widget inference: string→text (`z.email()`→email), number→number,
+ * boolean→checkbox, date→date, enum/literal→select, array→array,
+ * object→object, discriminated union→union. Anything else requires a
+ * `widget` override in {@link HelixFieldMeta} (throws in dev mode otherwise).
+ */
+declare function zodToFieldDescriptors(schema: z.ZodObject): HelixFieldDescriptor;
+
+/**
+ * Base class for dynamic-form widgets. A widget is a standalone component with
+ * the two inputs below; `HelixDynamicField` instantiates it via
+ * `NgComponentOutlet` and feeds them in.
+ */
+declare abstract class HelixFieldWidgetBase<T = any> {
+    #private;
+    readonly field: _angular_core.InputSignal<Field<T>>;
+    readonly descriptor: _angular_core.InputSignal<HelixFieldDescriptor>;
+    protected readonly state: _angular_core.Signal<FieldState<T, string | number>>;
+    /** Touched-gated first error message — mirrors `HelixFormField.activeError`. */
+    protected readonly firstError: _angular_core.Signal<string | null>;
+    protected readonly label: _angular_core.Signal<string>;
+    protected readonly hint: _angular_core.Signal<string | undefined>;
+    protected readonly placeholder: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixFieldWidgetBase<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HelixFieldWidgetBase<any>, never, never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "descriptor": { "alias": "descriptor"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Built-in widget for `z.array()` fields — item list with add/remove. */
+declare class HelixArrayWidget extends HelixFieldWidgetBase<unknown[]> {
+    protected readonly itemFields: _angular_core.Signal<any[]>;
+    protected readonly addLabel: _angular_core.Signal<string>;
+    protected readonly removeLabel: _angular_core.Signal<string>;
+    protected add(): void;
+    protected removeAt(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixArrayWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixArrayWidget, "helix-array-widget", never, {}, {}, never, never, true, never>;
+}
+
+/** Built-in widget for boolean fields — checkbox with inline label. */
+declare class HelixCheckboxWidget extends HelixFieldWidgetBase<boolean> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixCheckboxWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixCheckboxWidget, "helix-checkbox-widget", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Native `<input type="date">` exposed as a signal-forms `FormValueControl`
+ * with a `Date | null` model — string↔Date conversion via `transformedValue`.
+ */
+declare class HelixDateInput implements FormValueControl<Date | null> {
+    readonly value: _angular_core.ModelSignal<Date | null>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    protected readonly rawValue: _angular_forms_signals.TransformedValueSignal<string>;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixDateInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixDateInput, "helix-date-input", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; }, never, never, true, never>;
+}
+
+/** Built-in widget for `z.date()` fields. */
+declare class HelixDateWidget extends HelixFieldWidgetBase<Date | null> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixDateWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixDateWidget, "helix-date-widget", never, {}, {}, never, never, true, never>;
+}
+
+/** Built-in widget for numeric fields. */
+declare class HelixNumberWidget extends HelixFieldWidgetBase<number | null> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixNumberWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixNumberWidget, "helix-number-widget", never, {}, {}, never, never, true, never>;
+}
+
+/** Built-in widget for nested `z.object()` fields — fieldset + recursion. */
+declare class HelixObjectWidget extends HelixFieldWidgetBase<Record<string, unknown>> {
+    protected childField(key: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixObjectWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixObjectWidget, "helix-object-widget", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Built-in widget for enum/select fields — wraps `HelixSelect`, which the
+ * signal-forms `FormField` directive binds via its `ControlValueAccessor`.
+ */
+declare class HelixSelectWidget extends HelixFieldWidgetBase<unknown> {
+    protected readonly selectOptions: _angular_core.Signal<_gravionlabs_helix_zod.HelixSelectOption[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixSelectWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixSelectWidget, "helix-select-widget", never, {}, {}, never, never, true, never>;
+}
+
+/** Built-in widget for `text`, `email` and `password` fields. */
+declare class HelixTextWidget extends HelixFieldWidgetBase<string> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixTextWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixTextWidget, "helix-text-widget", never, {}, {}, never, never, true, never>;
+}
+
+/** Built-in widget for multiline text (`widget: 'textarea'`). */
+declare class HelixTextareaWidget extends HelixFieldWidgetBase<string> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixTextareaWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixTextareaWidget, "helix-textarea-widget", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Built-in widget for `z.discriminatedUnion()` fields: a discriminator select
+ * plus the active variant's fields.
+ *
+ * Switching the discriminator **resets** the union value to the new variant's
+ * default (preserving the discriminator) — mandatory so the model always
+ * matches the active variant's shape and all field paths exist.
+ */
+declare class HelixUnionWidget extends HelixFieldWidgetBase<Record<string, unknown>> {
+    protected readonly discriminator: _angular_core.Signal<string>;
+    protected readonly tags: _angular_core.Signal<(string | number | boolean)[]>;
+    protected readonly activeTag: _angular_core.Signal<unknown>;
+    protected readonly variantChildren: _angular_core.Signal<_gravionlabs_helix_zod.HelixFieldDescriptor[]>;
+    protected childField(key: string): any;
+    protected onTagChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelixUnionWidget, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelixUnionWidget, "helix-union-widget", never, {}, {}, never, never, true, never>;
+}
+
+interface ZodHelixOptions {
+    /**
+     * Required when the schema contains `.refine()` or `.superRefine()`.
+     * Those produce `ZodIssueCode.custom` which has no automatic `ValidatorKey`
+     * mapping. The bridge throws a descriptive error in development (`ngDevMode`)
+     * and skips silently in production when this is missing and a custom issue occurs.
+     *
+     * @example
+     * HelixZodValidators.fromZod(
+     *   z.string().refine(v => !banned.includes(v), 'Not allowed'),
+     *   { fallbackKey: ValidatorKey.Pattern },
+     * )
+     */
+    fallbackKey?: ValidatorKey;
+    /**
+     * When `true` (default), empty values (`''`, `null`, `undefined`) bypass Zod
+     * and return `null` — matching `Validators`' default `allowEmpty = true`.
+     * Set to `false` to let Zod validate empty values (e.g. for required fields).
+     */
+    allowEmpty?: boolean;
+}
+declare const HelixZodValidators: {
+    /**
+     * Converts a Zod field schema into a Helix-compatible Angular `ValidatorFn`.
+     *
+     * Each `ZodIssue` is mapped to its `ValidatorKey`. `HelixFormField` reads
+     * those keys directly — no template changes required.
+     *
+     * All issues from a single `safeParse` are processed simultaneously, producing
+     * one `ValidationErrors` key per issue — equivalent to stacking multiple
+     * `Validators` calls.
+     *
+     * ### Known gaps
+     * - `ValidatorKey.OneOf` / `AllOf` — `z.enum()` produces `invalid_value`,
+     *   which has no automatic mapping. Use `fallbackKey` or continue using
+     *   `Validators.oneOf` / `Validators.allOf`.
+     * - `invalid_type` for `boolean` expected — Helix has no `Boolean` key.
+     *   Use `fallbackKey` or `Validators.pattern`.
+     *
+     * @param schema    A Zod field schema (e.g. `UserSchema.shape.email`).
+     *                  Do NOT pass schemas with `.transform()` — use the
+     *                  input-only (pre-transform) variant for form controls.
+     * @param options   `allowEmpty` (default `true`) and optional `fallbackKey`
+     *                  for `.refine()` / `custom` validators.
+     *
+     * @example
+     * // Standard field — no fallbackKey needed
+     * HelixZodValidators.fromZod(UserSchema.shape.email)
+     *
+     * @example
+     * // Schema with .refine() — fallbackKey required (Option B)
+     * HelixZodValidators.fromZod(
+     *   z.string().refine(v => !banned.includes(v), 'Username not allowed'),
+     *   { fallbackKey: ValidatorKey.Pattern },
+     * )
+     *
+     * @example
+     * // Required field — disable allowEmpty so empty value triggers Required / MinLength
+     * HelixZodValidators.fromZod(UserSchema.shape.name, { allowEmpty: false })
+     */
+    fromZod(schema: ZodSchema, options?: ZodHelixOptions): ValidatorFn;
+};
+
+export { HELIX_DYNAMIC_FIELD_WIDGETS, HELIX_ERROR_MESSAGE_RESOLVER, HelixArrayWidget, HelixCheckboxWidget, HelixDateInput, HelixDateWidget, HelixDynamicField, HelixDynamicForm, HelixFieldWidgetBase, HelixFieldWidgetResolver, HelixNumberWidget, HelixObjectWidget, HelixSelectWidget, HelixTextWidget, HelixTextareaWidget, HelixUnionWidget, HelixZodValidators, buildDefaultValue, buildHelixSchema, fieldAtPath, helixErrorKey, helixFieldMetaRegistry, helixFirstErrorMessage, helixMeta, provideHelixDynamicForms, readHelixMeta, zodToFieldDescriptors };
+export type { HelixDynamicFormsConfig, HelixErrorMessageResolver, HelixFieldDescriptor, HelixFieldMeta, HelixFieldWidgetRegistration, HelixSelectOption, HelixWidgetKind, ZodHelixOptions };