@rachelallyson/hero-hook-form 2.7.0 → 2.8.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import React$1, { ComponentProps } from 'react';
 import { Button } from '@heroui/react';
 import * as react_hook_form from 'react-hook-form';
-import { FieldValues, Path, RegisterOptions, Control, UseFormReturn, FieldErrors, UseFormProps, SubmitHandler, UseFormSetError, DefaultValues, ArrayPath, FieldArrayWithId } from 'react-hook-form';
+import { FieldValues, Path, RegisterOptions, ArrayPath, Control, UseFormReturn, FieldErrors, UseFormProps, SubmitHandler, DefaultValues, UseFormSetError, FieldPath, FieldArrayWithId } from 'react-hook-form';
 export { UseFormReturn, useFormContext } from 'react-hook-form';
 import * as zod from 'zod';
 import { z, ZodSchema } from 'zod';
@@ -17,6 +17,19 @@ import { Slider } from '@heroui/slider';
 import { Switch } from '@heroui/switch';
 import { Button as Button$1 } from '@heroui/button';
 
+/**
+ * All supported field types that can be used in form builders
+ * This type is used throughout the codebase to ensure consistency
+ */
+type FormFieldType = "input" | "textarea" | "select" | "autocomplete" | "checkbox" | "switch" | "radio" | "slider" | "date" | "file" | "fontPicker" | "stringArray";
+/**
+ * Helper to convert a Path<T>, ArrayPath<T>, or string to a string for use in React keys and DOM operations.
+ * Path<T> and ArrayPath<T> are branded string types, so this is safe - it's just removing the brand.
+ *
+ * @param path - The path to convert (can be Path<T>, ArrayPath<T>, string, or undefined)
+ * @returns The path as a plain string, or empty string if undefined
+ */
+declare function pathToString<T extends FieldValues>(path: Path<T> | ArrayPath<T> | string | undefined): string;
 interface FieldBaseProps<TFieldValues extends FieldValues, TValue> {
     name: Path<TFieldValues>;
     label?: string;
@@ -30,7 +43,7 @@ interface FieldBaseProps<TFieldValues extends FieldValues, TValue> {
     isDisabled?: boolean;
 }
 interface WithControl<TFieldValues extends FieldValues> {
-    control: Control<TFieldValues>;
+    control: Control<TFieldValues, any>;
 }
 interface BaseFormFieldConfig<TFieldValues extends FieldValues> {
     name: Path<TFieldValues>;
@@ -73,6 +86,16 @@ interface RadioFieldConfig<TFieldValues extends FieldValues> extends BaseFormFie
         value: string | number;
     }[];
 }
+interface CheckboxGroupFieldConfig<TFieldValues extends FieldValues> extends BaseFormFieldConfig<TFieldValues> {
+    type: "checkboxGroup";
+    defaultValue?: (string | number)[];
+    checkboxGroupOptions?: {
+        label: string;
+        value: string | number;
+    }[];
+    checkboxProps?: Omit<React.ComponentProps<typeof Checkbox>, "isSelected" | "onValueChange" | "isInvalid" | "errorMessage" | "isDisabled" | "name">;
+    orientation?: "vertical" | "horizontal";
+}
 interface SliderFieldConfig<TFieldValues extends FieldValues> extends BaseFormFieldConfig<TFieldValues> {
     type: "slider";
     defaultValue?: number;
@@ -100,10 +123,35 @@ interface FontPickerFieldConfig<TFieldValues extends FieldValues> extends BaseFo
         fontsLoadedTimeout?: number;
     };
 }
-interface CustomFieldConfig<TFieldValues extends FieldValues> extends BaseFormFieldConfig<TFieldValues> {
+interface StringArrayFieldConfig<TFieldValues extends FieldValues> extends BaseFormFieldConfig<TFieldValues> {
+    type: "stringArray";
+    defaultValue?: string[];
+    stringArrayProps?: {
+        /** Placeholder text for the input */
+        placeholder?: string;
+        /** Maximum number of items allowed */
+        maxItems?: number;
+        /** Minimum number of items required */
+        minItems?: number;
+        /** Allow duplicate values */
+        allowDuplicates?: boolean;
+        /** Custom validation function for each item */
+        validateItem?: (item: string) => string | true;
+        /** Transform item before adding (e.g., trim whitespace) */
+        transformItem?: (item: string) => string;
+        /** Custom chip render function */
+        renderChip?: (item: string, onRemove: () => void) => React.ReactNode;
+        /** Custom add button text */
+        addButtonText?: string;
+        /** Whether to show add button or use enter key */
+        showAddButton?: boolean;
+    };
+}
+interface CustomFieldConfig<TFieldValues extends FieldValues> extends Omit<BaseFormFieldConfig<TFieldValues>, "name"> {
     type: "custom";
+    name: Path<TFieldValues> | ArrayPath<TFieldValues>;
     render: (field: {
-        name: Path<TFieldValues>;
+        name: Path<TFieldValues> | ArrayPath<TFieldValues>;
         control: Control<TFieldValues>;
         form: UseFormReturn<TFieldValues>;
         errors: FieldErrors<TFieldValues>;
@@ -124,8 +172,10 @@ interface ConditionalFieldConfig<TFieldValues extends FieldValues> extends BaseF
  *
  * @template TFieldValues - The form data type
  */
-interface FieldArrayConfig<TFieldValues extends FieldValues> extends BaseFormFieldConfig<TFieldValues> {
+interface FieldArrayConfig<TFieldValues extends FieldValues> extends Omit<BaseFormFieldConfig<TFieldValues>, "name"> {
     type: "fieldArray";
+    /** Field array name - must be an ArrayPath (points to an array field) */
+    name: ArrayPath<TFieldValues>;
     /** Field configurations for each array item */
     fields: ZodFormFieldConfig<TFieldValues>[];
     /** Minimum number of items (default: 0) */
@@ -147,6 +197,8 @@ interface FieldArrayConfig<TFieldValues extends FieldValues> extends BaseFormFie
     };
     /** Function to create default item when adding new array item */
     defaultItem?: () => any;
+    /** Whether this field array should always be registered (for conditional rendering) */
+    alwaysRegistered?: boolean;
     /** Custom render function for array items */
     renderItem?: (props: {
         /** Item index (0-based) */
@@ -193,7 +245,7 @@ interface DynamicSectionConfig<TFieldValues extends FieldValues> extends BaseFor
 }
 interface ContentFieldConfig<TFieldValues extends FieldValues = FieldValues> {
     type: "content";
-    name?: string;
+    name?: Path<TFieldValues>;
     title?: string;
     description?: string;
     render?: (field: {
@@ -203,7 +255,7 @@ interface ContentFieldConfig<TFieldValues extends FieldValues = FieldValues> {
     }) => React.ReactNode;
     className?: string;
 }
-type FormFieldConfig<TFieldValues extends FieldValues> = StringFieldConfig<TFieldValues> | BooleanFieldConfig<TFieldValues> | RadioFieldConfig<TFieldValues> | SliderFieldConfig<TFieldValues> | DateFieldConfig<TFieldValues> | FileFieldConfig<TFieldValues> | FontPickerFieldConfig<TFieldValues> | CustomFieldConfig<TFieldValues> | ConditionalFieldConfig<TFieldValues> | FieldArrayConfig<TFieldValues> | DynamicSectionConfig<TFieldValues> | ContentFieldConfig<TFieldValues>;
+type FormFieldConfig<TFieldValues extends FieldValues> = StringFieldConfig<TFieldValues> | BooleanFieldConfig<TFieldValues> | RadioFieldConfig<TFieldValues> | CheckboxGroupFieldConfig<TFieldValues> | SliderFieldConfig<TFieldValues> | DateFieldConfig<TFieldValues> | FileFieldConfig<TFieldValues> | FontPickerFieldConfig<TFieldValues> | StringArrayFieldConfig<TFieldValues> | CustomFieldConfig<TFieldValues> | ConditionalFieldConfig<TFieldValues> | FieldArrayConfig<TFieldValues> | DynamicSectionConfig<TFieldValues> | ContentFieldConfig<TFieldValues>;
 interface FormConfig<TFieldValues extends FieldValues> {
     fields: FormFieldConfig<TFieldValues>[];
     layout?: "vertical" | "horizontal" | "grid" | "custom";
@@ -217,10 +269,12 @@ interface FormConfig<TFieldValues extends FieldValues> {
     className?: string;
     defaultValues?: Partial<TFieldValues>;
 }
-type ZodFormFieldConfig<TFieldValues extends FieldValues> = Omit<StringFieldConfig<TFieldValues>, "rules"> | Omit<BooleanFieldConfig<TFieldValues>, "rules"> | Omit<RadioFieldConfig<TFieldValues>, "rules"> | Omit<SliderFieldConfig<TFieldValues>, "rules"> | Omit<DateFieldConfig<TFieldValues>, "rules"> | Omit<FileFieldConfig<TFieldValues>, "rules"> | Omit<FontPickerFieldConfig<TFieldValues>, "rules"> | Omit<CustomFieldConfig<TFieldValues>, "rules"> | Omit<ConditionalFieldConfig<TFieldValues>, "rules"> | Omit<FieldArrayConfig<TFieldValues>, "rules"> | Omit<DynamicSectionConfig<TFieldValues>, "rules"> | ContentFieldConfig<TFieldValues>;
+type ZodFormFieldConfig<TFieldValues extends FieldValues> = Omit<StringFieldConfig<TFieldValues>, "rules"> | Omit<BooleanFieldConfig<TFieldValues>, "rules"> | Omit<RadioFieldConfig<TFieldValues>, "rules"> | Omit<CheckboxGroupFieldConfig<TFieldValues>, "rules"> | Omit<SliderFieldConfig<TFieldValues>, "rules"> | Omit<DateFieldConfig<TFieldValues>, "rules"> | Omit<FileFieldConfig<TFieldValues>, "rules"> | Omit<FontPickerFieldConfig<TFieldValues>, "rules"> | Omit<StringArrayFieldConfig<TFieldValues>, "rules"> | Omit<CustomFieldConfig<TFieldValues>, "rules"> | Omit<ConditionalFieldConfig<TFieldValues>, "rules"> | Omit<FieldArrayConfig<TFieldValues>, "rules"> | Omit<DynamicSectionConfig<TFieldValues>, "rules"> | ContentFieldConfig<TFieldValues>;
 interface ZodFormConfig<TFieldValues extends FieldValues> extends UseFormProps<TFieldValues> {
     schema: zod.ZodSchema<TFieldValues>;
-    fields: ZodFormFieldConfig<TFieldValues>[];
+    fields: (ZodFormFieldConfig<TFieldValues> | (Omit<ZodFormFieldConfig<FieldValues>, "name"> & {
+        name: Path<TFieldValues>;
+    }))[];
     onError?: (errors: FieldErrors<TFieldValues>) => void;
     errorDisplay?: "inline" | "toast" | "modal" | "none";
 }
@@ -308,7 +362,7 @@ interface FormProps$1<T extends FieldValues> {
     submitButtonText?: string;
     subtitle?: string;
     title?: string;
-    defaultValues?: Partial<T>;
+    defaultValues?: DefaultValues<T>;
 }
 /**
  * Base form component for building forms without Zod validation.
@@ -364,11 +418,16 @@ interface FormProps$1<T extends FieldValues> {
 declare function ConfigurableForm<T extends FieldValues>({ className, columns, defaultValues, fields, layout, onError, onSubmit, onSuccess, resetButtonText, showResetButton, spacing, submitButtonProps, submitButtonText, subtitle, title, }: FormProps$1<T>): React$1.JSX.Element;
 
 interface FormFieldProps<TFieldValues extends FieldValues> {
-    config: FormFieldConfig<TFieldValues>;
+    config: FormFieldConfig<TFieldValues> | ZodFormFieldConfig<TFieldValues> | (Omit<FormFieldConfig<FieldValues>, "name"> & {
+        name: Path<TFieldValues>;
+    }) | (Omit<ZodFormFieldConfig<FieldValues>, "name"> & {
+        name: Path<TFieldValues>;
+    });
     form: UseFormReturn<TFieldValues>;
     submissionState: FormSubmissionState;
 }
-declare const FormField: <TFieldValues extends FieldValues>(props: FormFieldProps<TFieldValues>) => React$1.JSX.Element;
+declare function FormFieldComponent<TFieldValues extends FieldValues>({ config, form, submissionState, }: FormFieldProps<TFieldValues>): string | number | bigint | boolean | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | React$1.JSX.Element | null | undefined;
+declare const FormField: typeof FormFieldComponent;
 
 type ServerAction<TState = unknown, TFormData = FormData> = (state: TState | undefined, formData: TFormData) => Promise<TState>;
 interface ActionState {
@@ -384,8 +443,12 @@ interface ServerActionFormProps<T extends FieldValues> {
     className?: string;
     columns?: 1 | 2 | 3;
     /** Default values for form fields */
-    defaultValues?: Partial<T>;
-    fields: FormFieldConfig<T>[];
+    defaultValues?: Partial<T> | Record<string, unknown>;
+    fields: (FormFieldConfig<T> | FormFieldConfig<any> | ZodFormFieldConfig<any> | (Omit<FormFieldConfig<FieldValues>, "name"> & {
+        name: Path<T>;
+    }) | (Omit<ZodFormFieldConfig<FieldValues>, "name"> & {
+        name: Path<T>;
+    }))[];
     /** Initial state for useActionState */
     initialState?: ActionState;
     layout?: "vertical" | "horizontal" | "grid";
@@ -494,7 +557,7 @@ interface ServerActionFormProps<T extends FieldValues> {
  * @see {@link ConfigurableForm} for forms without Server Actions
  * @category Components
  */
-declare function ServerActionForm<T extends FieldValues>({ action, className, clientValidationSchema, columns, defaultValues, fields, initialState, layout, onError, onSuccess, resetButtonText, showResetButton, spacing, submitButtonProps, submitButtonText, subtitle, title, }: ServerActionFormProps<T>): React$1.JSX.Element;
+declare function ServerActionForm<T extends FieldValues = FieldValues>({ action, className, clientValidationSchema, columns, defaultValues, fields, initialState, layout, onError, onSuccess, resetButtonText, showResetButton, spacing, submitButtonProps, submitButtonText, subtitle, title, }: ServerActionFormProps<T>): React$1.JSX.Element;
 
 /**
  * Configuration for an autocomplete option.
@@ -698,6 +761,119 @@ type CheckboxFieldProps<TFieldValues extends FieldValues> = FieldBaseProps<TFiel
  */
 declare function CheckboxField<TFieldValues extends FieldValues>(props: CheckboxFieldProps<TFieldValues>): React$1.JSX.Element;
 
+/**
+ * Configuration for a checkbox option in a checkbox group.
+ *
+ * @template TValue - The value type for the option
+ */
+interface CheckboxOption<TValue extends string | number> {
+    /** Display label for the option */
+    label: string;
+    /** Value of the option */
+    value: TValue;
+    /** Optional description text */
+    description?: string;
+    /** Whether the option is disabled */
+    disabled?: boolean;
+}
+/**
+ * Props for the CheckboxGroupField component.
+ *
+ * @template TFieldValues - The form data type
+ * @template TValue - The value type for the checkbox group (string or number)
+ *
+ * @example
+ * ```tsx
+ * import { CheckboxGroupField } from "@rachelallyson/hero-hook-form";
+ * import { useForm } from "react-hook-form";
+ *
+ * const form = useForm({
+ *   defaultValues: { interests: [] },
+ * });
+ *
+ * const options = [
+ *   { label: "Reading", value: "reading" },
+ *   { label: "Sports", value: "sports" },
+ *   { label: "Music", value: "music" },
+ * ];
+ *
+ * <CheckboxGroupField
+ *   control={form.control}
+ *   name="interests"
+ *   label="Interests"
+ *   options={options}
+ * />
+ * ```
+ */
+type CheckboxGroupFieldProps<TFieldValues extends FieldValues, TValue extends string | number = string> = FieldBaseProps<TFieldValues, TValue[]> & WithControl<TFieldValues> & {
+    /** Array of checkbox options */
+    options: readonly CheckboxOption<TValue>[];
+    /** Additional props to pass to individual Checkbox components */
+    checkboxProps?: Omit<React$1.ComponentProps<typeof Checkbox>, "isSelected" | "onValueChange" | "isInvalid" | "errorMessage" | "isDisabled" | "name">;
+    /** Layout orientation for the checkboxes */
+    orientation?: "vertical" | "horizontal";
+};
+/**
+ * A checkbox group field component that integrates React Hook Form with HeroUI Checkbox.
+ *
+ * This component provides a type-safe checkbox group field with validation support,
+ * error handling, and accessibility features. Multiple options can be selected,
+ * and the value is stored as an array of selected option values.
+ *
+ * @template TFieldValues - The form data type
+ * @template TValue - The value type for the checkbox group (string or number)
+ *
+ * @param props - The checkbox group field props
+ * @returns The rendered checkbox group field component
+ *
+ * @example
+ * ```tsx
+ * import { ZodForm, FormFieldHelpers } from "@rachelallyson/hero-hook-form";
+ * import { z } from "zod";
+ *
+ * const schema = z.object({
+ *   interests: z.array(z.string()).min(1, "Please select at least one interest"),
+ * });
+ *
+ * const options = [
+ *   { label: "Reading", value: "reading" },
+ *   { label: "Sports", value: "sports" },
+ *   { label: "Music", value: "music" },
+ * ];
+ *
+ * function MyForm() {
+ *   return (
+ *     <ZodForm
+ *       config={{
+ *         schema,
+ *         fields: [
+ *           FormFieldHelpers.checkboxGroup("interests", "Interests", options),
+ *         ],
+ *       }}
+ *       onSubmit={(data) => console.log(data)}
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With custom styling and horizontal layout
+ * <CheckboxGroupField
+ *   control={form.control}
+ *   name="interests"
+ *   label="Interests"
+ *   options={options}
+ *   orientation="horizontal"
+ *   checkboxProps={{
+ *     color: "primary",
+ *     size: "lg",
+ *   }}
+ * />
+ * ```
+ */
+declare function CheckboxGroupField<TFieldValues extends FieldValues, TValue extends string | number = string>(props: CheckboxGroupFieldProps<TFieldValues, TValue>): React$1.JSX.Element;
+
 /**
  * Props for the DateField component.
  *
@@ -1423,7 +1599,7 @@ interface UseFormHelperOptions<T extends FieldValues> {
     onError?: (error: FormValidationError) => void;
     onSubmit: SubmitHandler<T>;
     onSuccess?: (data: T) => void;
-    defaultValues?: Partial<T>;
+    defaultValues?: DefaultValues<T>;
     methods?: UseFormReturn<T>;
 }
 /**
@@ -1558,7 +1734,7 @@ declare function useFormHelper<T extends FieldValues>({ defaultValues, methods,
  * @category Hooks
  */
 declare function useHeroForm<TFieldValues extends FieldValues>(): {
-    defaults: Required<Pick<HeroHookFormDefaultsConfig, "input" | "textarea" | "select" | "switch" | "radioGroup" | "checkbox" | "slider" | "dateInput" | "submitButton">>;
+    defaults: Required<Pick<HeroHookFormDefaultsConfig, "input" | "textarea" | "select" | "checkbox" | "switch" | "slider" | "radioGroup" | "dateInput" | "submitButton">>;
     watch: react_hook_form.UseFormWatch<TFieldValues>;
     getValues: react_hook_form.UseFormGetValues<TFieldValues>;
     getFieldState: react_hook_form.UseFormGetFieldState<TFieldValues>;
@@ -2001,6 +2177,7 @@ interface ZodFormProps<T extends FieldValues> {
     className?: string;
     columns?: 1 | 2 | 3;
     config: ZodFormConfig<T>;
+    errorDisplay?: "inline" | "toast" | "modal" | "none";
     layout?: "vertical" | "horizontal" | "grid";
     onError?: (error: FormValidationError) => void;
     onSubmit: SubmitHandler<T>;
@@ -2177,7 +2354,7 @@ declare function useZodForm<TFieldValues extends FieldValues>(config: ZodFormCon
 /**
  * Helper function to create Zod form configurations
  */
-declare function createZodFormConfig<TFieldValues extends FieldValues>(schema: z.ZodSchema<TFieldValues>, fields: ZodFormFieldConfig<TFieldValues>[], defaultValues?: Partial<TFieldValues>): ZodFormConfig<TFieldValues>;
+declare function createZodFormConfig<TFieldValues extends FieldValues>(schema: z.ZodSchema<TFieldValues>, fields: ZodFormFieldConfig<TFieldValues>[], defaultValues?: DefaultValues<TFieldValues>): ZodFormConfig<TFieldValues>;
 
 /**
  * Basic form field builder for creating form field configurations.
@@ -2327,6 +2504,11 @@ declare function createBasicFormBuilder<T extends FieldValues>(): BasicFormBuild
  * @see {@link createBasicFormBuilder} for builder pattern alternative
  * @category Builders
  */
+type InputPropsType = Omit<React$1.ComponentProps<typeof Input>, "value" | "onValueChange" | "label" | "isInvalid" | "errorMessage" | "isDisabled">;
+declare function inputHelper<T extends FieldValues>(name: Path<T>, label: string): ZodFormFieldConfig<T>;
+declare function inputHelper<T extends FieldValues>(name: Path<T>, label: string, type: "text" | "email" | "tel" | "password"): ZodFormFieldConfig<T>;
+declare function inputHelper<T extends FieldValues>(name: Path<T>, label: string, inputProps: InputPropsType): ZodFormFieldConfig<T>;
+declare function inputHelper<T extends FieldValues>(name: Path<T>, label: string, type: "text" | "email" | "tel" | "password", inputProps: InputPropsType): ZodFormFieldConfig<T>;
 declare const FormFieldHelpers: {
     /**
      * Create an autocomplete field
@@ -2366,6 +2548,33 @@ declare const FormFieldHelpers: {
      * ```
      */
     checkbox: <T extends FieldValues>(name: Path<T>, label: string, checkboxProps?: Omit<React$1.ComponentProps<typeof Checkbox>, "isSelected" | "onValueChange" | "isInvalid" | "errorMessage" | "isDisabled">) => ZodFormFieldConfig<T>;
+    /**
+     * Create a checkbox group field (multiple checkboxes saving to an array)
+     *
+     * @example
+     * ```tsx
+     * // Simple checkbox group
+     * FormFieldHelpers.checkboxGroup("interests", "Interests", [
+     *   { label: "Reading", value: "reading" },
+     *   { label: "Sports", value: "sports" },
+     *   { label: "Music", value: "music" },
+     * ])
+     *
+     * // With horizontal layout and custom styling
+     * FormFieldHelpers.checkboxGroup("interests", "Interests", options, {
+     *   orientation: "horizontal",
+     *   checkboxProps: { color: "primary", size: "lg" }
+     * })
+     * ```
+     */
+    checkboxGroup: <T extends FieldValues>(name: Path<T>, label: string, options: {
+        label: string;
+        value: string | number;
+    }[], config?: {
+        checkboxProps?: Omit<React$1.ComponentProps<typeof Checkbox>, "isSelected" | "onValueChange" | "isInvalid" | "errorMessage" | "isDisabled" | "name">;
+        orientation?: "vertical" | "horizontal";
+        description?: string;
+    }) => ZodFormFieldConfig<T>;
     /**
      * Create a conditional field that shows/hides based on form data
      *
@@ -2390,6 +2599,41 @@ declare const FormFieldHelpers: {
      * ```
      */
     conditional: <T extends FieldValues = FieldValues>(name: Path<T>, condition: (formData: Partial<T>) => boolean, field: ZodFormFieldConfig<T>) => ZodFormFieldConfig<T>;
+    /**
+     * Create a conditional field array that avoids memory leaks in Cypress tests.
+     *
+     * This helper creates a field array that is always registered but conditionally
+     * rendered, preventing the register/unregister cycles that cause memory
+     * accumulation in Cypress Electron renderer.
+     *
+     * @param name - The field array name
+     * @param condition - Function that determines if the field array should be visible
+     * @param label - Display label for the field array
+     * @param fields - Field configurations for array items
+     * @param options - Additional field array options
+     *
+     * @example
+     * ```tsx
+     * // Memory-safe conditional field array for multiple choice options
+     * FormFieldHelpers.conditionalFieldArray(
+     *   "choices",
+     *   (data) => data.questionType === 'MULTIPLE_CHOICE',
+     *   "Answer Choices",
+     *   [
+     *     FormFieldHelpers.input("text", "Choice Text"),
+     *     FormFieldHelpers.checkbox("isCorrect", "Correct Answer"),
+     *   ]
+     * )
+     * ```
+     */
+    conditionalFieldArray: <T extends FieldValues = FieldValues>(name: ArrayPath<T>, condition: (formData: Partial<T>) => boolean, label: string, fields: ZodFormFieldConfig<T>[], options?: {
+        min?: number;
+        max?: number;
+        addButtonText?: string;
+        removeButtonText?: string;
+        enableReordering?: boolean;
+        defaultItem?: () => any;
+    }) => ZodFormFieldConfig<T>;
     /**
      * Create a content field for headers, questions, or custom content between fields
      *
@@ -2411,7 +2655,34 @@ declare const FormFieldHelpers: {
             isSubmitting: boolean;
         }) => React$1.ReactNode;
         className?: string;
-        name?: string;
+        name?: Path<T>;
+    }) => ZodFormFieldConfig<T>;
+    /**
+     * Create a custom field with full control over rendering
+     *
+     * @example
+     * ```tsx
+     * // Custom field with render function
+     * FormFieldHelpers.custom<FormData>(
+     *   "skills",
+     *   "Skills",
+     *   ({ form, control }) => {
+     *     // Custom rendering logic
+     *     return <div>...</div>;
+     *   }
+     * )
+     * ```
+     */
+    custom: <T extends FieldValues>(name: Path<T> | ArrayPath<T>, label: string, render: (field: {
+        name: Path<T> | ArrayPath<T>;
+        control: Control<T>;
+        form: UseFormReturn<T>;
+        errors: FieldErrors<T>;
+        isSubmitting: boolean;
+    }) => React$1.ReactNode, options?: {
+        description?: string;
+        className?: string;
+        isDisabled?: boolean;
     }) => ZodFormFieldConfig<T>;
     /**
      * Create a date field
@@ -2490,7 +2761,10 @@ declare const FormFieldHelpers: {
      * // With type
      * FormFieldHelpers.input("email", "Email", "email")
      *
-     * // With full customization
+     * // With props only (no type)
+     * FormFieldHelpers.input("name", "Name", { placeholder: "Enter name" })
+     *
+     * // With type and props
      * FormFieldHelpers.input("email", "Email", "email", {
      *   placeholder: "Enter your email",
      *   classNames: { input: "custom-input" },
@@ -2499,7 +2773,25 @@ declare const FormFieldHelpers: {
      * })
      * ```
      */
-    input: <T extends FieldValues>(name: Path<T>, label: string, type?: "text" | "email" | "tel" | "password", inputProps?: Omit<React$1.ComponentProps<typeof Input>, "value" | "onValueChange" | "label" | "isInvalid" | "errorMessage" | "isDisabled">) => ZodFormFieldConfig<T>;
+    input: typeof inputHelper;
+    /**
+     * Create a radio group field
+     *
+     * @example
+     * ```tsx
+     * // Simple radio group
+     * FormFieldHelpers.radio("gender", "Gender", [
+     *   { label: "Male", value: "male" },
+     *   { label: "Female", value: "female" }
+     * ])
+     *
+     * // With full customization
+     * FormFieldHelpers.radio("gender", "Gender", options, {
+     *   orientation: "horizontal",
+     *   classNames: { base: "custom-radio" }
+     * })
+     * ```
+     */
     /**
      * Create a radio group field
      *
@@ -2604,6 +2896,26 @@ declare const FormFieldHelpers: {
 };
 /**
  * Common field collections
+ *
+ * These helpers provide reusable field sets for common form patterns.
+ * The `as Path<T>` assertions are necessary because TypeScript cannot prove
+ * that string literals like "street" or "email" are valid paths in an arbitrary
+ * form type `T`. These helpers are designed to work with any form type that
+ * happens to have these fields - the type safety is enforced when you use them
+ * with a specific form schema.
+ *
+ * @example
+ * ```tsx
+ * const schema = z.object({
+ *   street: z.string(),
+ *   city: z.string(),
+ *   // ... other fields
+ * });
+ *
+ * const fields = [
+ *   ...CommonFields.address<z.infer<typeof schema>>(),
+ * ];
+ * ```
  */
 declare const CommonFields: {
     /**
@@ -2621,10 +2933,163 @@ declare const CommonFields: {
 };
 
 /**
- * Unified field creation function
- * Takes field type as first argument and delegates to appropriate helper
+ * Discriminated union types for field creation parameters
+ * This eliminates the need for 'unknown' types and type assertions
+ */
+type FieldCreationParams<T extends FieldValues> = {
+    type: "input";
+    name: Path<T>;
+    label: string;
+    props?: {
+        type?: "text" | "email" | "tel" | "password" | "number" | "url";
+        placeholder?: string;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    };
+} | {
+    type: "textarea";
+    name: Path<T>;
+    label: string;
+    props?: {
+        placeholder?: string;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+        rows?: number;
+    };
+} | {
+    type: "select";
+    name: Path<T>;
+    label: string;
+    options: {
+        label: string;
+        value: string | number;
+    }[];
+} | {
+    type: "autocomplete";
+    name: Path<T>;
+    label: string;
+    options: {
+        label: string;
+        value: string | number;
+    }[];
+    props?: Record<string, unknown>;
+} | {
+    type: "checkbox";
+    name: Path<T>;
+    label: string;
+    props?: {
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    };
+} | {
+    type: "switch";
+    name: Path<T>;
+    label: string;
+    props?: {
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    };
+} | {
+    type: "radio";
+    name: Path<T>;
+    label: string;
+    options: {
+        label: string;
+        value: string | number;
+    }[];
+    props?: {
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+        orientation?: "horizontal" | "vertical";
+    };
+} | {
+    type: "slider";
+    name: Path<T>;
+    label: string;
+    props?: {
+        min?: number;
+        max?: number;
+        step?: number;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    };
+} | {
+    type: "date";
+    name: Path<T>;
+    label: string;
+    props?: {
+        placeholder?: string;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    };
+} | {
+    type: "file";
+    name: Path<T>;
+    label: string;
+    props?: {
+        accept?: string;
+        multiple?: boolean;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    };
+} | {
+    type: "fontPicker";
+    name: Path<T>;
+    label: string;
+    props?: {
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+        fontPickerProps?: {
+            showFontPreview?: boolean;
+            loadAllVariants?: boolean;
+            onFontsLoaded?: (loaded: boolean) => void;
+            fontsLoadedTimeout?: number;
+        };
+    };
+} | {
+    type: "stringArray";
+    name: Path<T>;
+    label: string;
+    props?: {
+        placeholder?: string;
+        maxItems?: number;
+        minItems?: number;
+        allowDuplicates?: boolean;
+        validateItem?: (item: string) => string | true;
+        transformItem?: (item: string) => string;
+        addButtonText?: string;
+        showAddButton?: boolean;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    };
+} | {
+    type: "content";
+    name?: Path<T>;
+    label?: string;
+    title?: string | null;
+    description?: string | null;
+    render?: (field: {
+        form: UseFormReturn<T>;
+        errors: FieldErrors<T>;
+        isSubmitting: boolean;
+    }) => React$1.ReactNode;
+    className?: string;
+};
+/**
+ * Unified field creation function using discriminated union types
+ * This provides full type safety without complex overloads
  */
-declare function createField<T extends FieldValues>(type: string, name: Path<T>, label: string, optionsOrProps?: any, props?: any): ZodFormFieldConfig<T>;
+declare function createField<T extends FieldValues>(params: FieldCreationParams<T>): ZodFormFieldConfig<T>;
 /**
  * Builder pattern for advanced field creation
  */
@@ -2633,21 +3098,7 @@ declare class AdvancedFieldBuilder<T extends FieldValues> {
     /**
      * Add any field type using the unified API
      */
-    field(type: "input", name: Path<T>, label: string, props?: Parameters<typeof createField<T>>[3]): this;
-    field(type: "textarea", name: Path<T>, label: string, props?: Parameters<typeof createField<T>>[3]): this;
-    field(type: "select", name: Path<T>, label: string, options: {
-        label: string;
-        value: string | number;
-    }[], props?: Parameters<typeof createField<T>>[4]): this;
-    field(type: "checkbox", name: Path<T>, label: string, props?: Parameters<typeof createField<T>>[3]): this;
-    field(type: "switch", name: Path<T>, label: string, props?: Parameters<typeof createField<T>>[3]): this;
-    field(type: "radio", name: Path<T>, label: string, options: {
-        label: string;
-        value: string | number;
-    }[], props?: Parameters<typeof createField<T>>[4]): this;
-    field(type: "slider", name: Path<T>, label: string, props?: Parameters<typeof createField<T>>[3]): this;
-    field(type: "date", name: Path<T>, label: string, props?: Parameters<typeof createField<T>>[3]): this;
-    field(type: "file", name: Path<T>, label: string, props?: Parameters<typeof createField<T>>[3]): this;
+    field(params: FieldCreationParams<T>): this;
     /**
      * Add a conditional field that shows/hides based on form data
      */
@@ -2655,7 +3106,7 @@ declare class AdvancedFieldBuilder<T extends FieldValues> {
     /**
      * Add a field array for dynamic repeating field groups
      */
-    fieldArray(name: Path<T>, label: string, fields: ZodFormFieldConfig<any>[], options?: {
+    fieldArray(name: ArrayPath<T>, label: string, fields: ZodFormFieldConfig<T>[], options?: {
         min?: number;
         max?: number;
         addButtonText?: string;
@@ -2681,22 +3132,7 @@ declare class FieldArrayItemBuilder<TItem extends FieldValues> {
     /**
      * Add any field type using the unified API for array items
      */
-    field(type: "input", name: Path<TItem>, label: string, props?: Parameters<typeof createField<TItem>>[3]): this;
-    field(type: "textarea", name: Path<TItem>, label: string, props?: Parameters<typeof createField<TItem>>[3]): this;
-    field(type: "select", name: Path<TItem>, label: string, options: {
-        label: string;
-        value: string | number;
-    }[], props?: Parameters<typeof createField<TItem>>[4]): this;
-    field(type: "checkbox", name: Path<TItem>, label: string, props?: Parameters<typeof createField<TItem>>[3]): this;
-    field(type: "switch", name: Path<TItem>, label: string, props?: Parameters<typeof createField<TItem>>[3]): this;
-    field(type: "radio", name: Path<TItem>, label: string, options: {
-        label: string;
-        value: string | number;
-    }[], props?: Parameters<typeof createField<TItem>>[4]): this;
-    field(type: "slider", name: Path<TItem>, label: string, props?: Parameters<typeof createField<TItem>>[3]): this;
-    field(type: "date", name: Path<TItem>, label: string, props?: Parameters<typeof createField<TItem>>[3]): this;
-    field(type: "file", name: Path<TItem>, label: string, props?: Parameters<typeof createField<TItem>>[3]): this;
-    field(type: "fontPicker", name: Path<TItem>, label: string, props?: Parameters<typeof createField<TItem>>[3]): this;
+    field(params: FieldCreationParams<TItem>): this;
     /**
      * Build the field array item configuration
      */
@@ -2713,8 +3149,8 @@ declare class FieldArrayBuilder<T extends FieldValues, TArrayName extends Path<T
     private arrayName;
     private fields;
     constructor(arrayName: TArrayName);
-    field(type: string, name: string, label: string, optionsOrProps?: any, props?: any): this;
-    build(): ZodFormFieldConfig<any>[];
+    field(params: FieldCreationParams<Record<string, any>>): this;
+    build(): ZodFormFieldConfig<T>[];
 }
 /**
  * Create a field array builder that constructs proper paths for array items
@@ -2883,17 +3319,32 @@ declare const field: {
     textarea: <T extends FieldValues>(name: Path<T>, label: string, options?: Parameters<TypeInferredBuilder<T>["textarea"]>[2]) => TypeInferredBuilder<T>;
 };
 
+/**
+ * Helper type to construct a nested path from a base path and sub-path.
+ * Attempts to construct the path and falls back to Path<T> if TypeScript
+ * can't verify the nested structure at compile time.
+ *
+ * @example
+ * type T = { user: { name: string } };
+ * type Nested = ConstructNestedPath<T, "user", "name">; // "user.name"
+ */
+type ConstructNestedPath<T extends FieldValues, TBasePath extends Path<T>, TSubPath extends string> = `${TBasePath}.${TSubPath}` extends Path<T> ? `${TBasePath}.${TSubPath}` : Path<T>;
 /**
  * Enhanced nested path builder with better syntax for complex nested structures
  * Provides multiple approaches for handling nested field paths
  */
 declare class NestedPathBuilder<T extends FieldValues> {
-    private fields;
+    fields: ZodFormFieldConfig<T>[];
     /**
      * Create a nested object path builder
      * Usage: builder.nest("address").field("street", "Street Address")
+     *
+     * @param path - A path in the form data structure. When called from root level,
+     *               accepts Path<T>. When called after .end() from a nested context,
+     *               accepts any string for nested paths under sections.
+     * @returns A builder for nested paths under the specified path
      */
-    nest<TPath extends Path<T>>(path: TPath): NestedObjectBuilder<T, TPath>;
+    nest(path: string & {}): NestedObjectBuilder<T, Path<T>>;
     /**
      * Create a section-based path builder
      * Usage: builder.section("shipping").field("street", "Street Address")
@@ -2901,14 +3352,14 @@ declare class NestedPathBuilder<T extends FieldValues> {
     section<TPath extends Path<T>>(path: TPath): SectionBuilder<T, TPath>;
     /**
      * Add a field with single path
-     * Usage: builder.field("firstName", "First Name")
+     * Usage: builder.field({ type: "input", name: "firstName", label: "First Name" })
      */
-    field(name: Path<T>, label: string, type?: string, props?: any): this;
+    field(params: FieldCreationParams<T> | FieldCreationParams<Record<string, any>>): this;
     /**
      * Add a field with path segments
-     * Usage: builder.fieldPath(["user", "profile", "name"], "Full Name")
+     * Usage: builder.fieldPath({ type: "input", name: path.join("."), label: "Full Name" })
      */
-    fieldPath(path: string[], label: string, type?: string, props?: any): this;
+    fieldPath(params: FieldCreationParams<T>): this;
     /**
      * Add a field with template literal path
      * Usage: builder.field`user.profile.name`("Full Name")
@@ -2930,11 +3381,16 @@ declare class NestedObjectBuilder<T extends FieldValues, TPath extends Path<T>>
     /**
      * Add a field to the current nested path
      */
-    field<FName extends string>(fieldName: FName, label: string, type?: string, props?: any): NestedObjectBuilder<T, TPath>;
+    field(params: FieldCreationParams<Record<string, any>>): NestedObjectBuilder<T, TPath>;
     /**
      * Nest deeper into the object
+     *
+     * @param subPath - A string representing a nested path under the current path.
+     *                  The parameter accepts any string; TypeScript validates the constructed
+     *                  path (basePath.subPath) in the return type.
+     * @returns A builder for the nested path
      */
-    nest<SubPath extends string>(subPath: SubPath): NestedObjectBuilder<T, TPath>;
+    nest<SubPath extends string>(subPath: SubPath): NestedObjectBuilder<T, ConstructNestedPath<T, TPath, SubPath>>;
     /**
      * Return to the parent builder
      */
@@ -2950,20 +3406,25 @@ declare class SectionBuilder<T extends FieldValues, TPath extends Path<T>> {
     /**
      * Add a field to the current section
      */
-    field<FName extends string>(fieldName: FName, label: string, type?: string, props?: any): SectionBuilder<T, TPath>;
+    field(params: FieldCreationParams<Record<string, any>>): SectionBuilder<T, TPath>;
     /**
      * Add multiple fields to the section
      */
     fields(fieldDefinitions: {
         name: string;
         label: string;
-        type?: string;
-        props?: any;
+        type?: FormFieldType;
+        props?: Record<string, unknown>;
     }[]): SectionBuilder<T, TPath>;
     /**
      * Nest deeper into the section
+     *
+     * @param subPath - A string representing a nested path under the current section path.
+     *                  The parameter accepts any string; TypeScript validates the constructed
+     *                  path (basePath.subPath) in the return type.
+     * @returns A builder for the nested path
      */
-    nest<SubPath extends string>(subPath: SubPath): NestedObjectBuilder<T, TPath>;
+    nest<SubPath extends string = string>(subPath: SubPath): NestedObjectBuilder<T, ConstructNestedPath<T, TPath, string>>;
     /**
      * Return to the parent builder
      */
@@ -2979,7 +3440,9 @@ declare class FieldTemplateBuilder<T extends FieldValues> {
     /**
      * Complete the field definition
      */
-    complete(label: string, type?: string, props?: any): NestedPathBuilder<T>;
+    complete(params: Omit<FieldCreationParams<Record<string, any>>, "name"> & {
+        name?: string;
+    }): NestedPathBuilder<T>;
 }
 /**
  * Factory function for creating the nested path builder
@@ -2989,9 +3452,9 @@ declare function createNestedPathBuilder<T extends FieldValues>(): NestedPathBui
 /**
  * Options for the useDebouncedValidation hook.
  */
-interface UseDebouncedValidationOptions {
+interface UseDebouncedValidationOptions<T extends FieldValues = FieldValues> {
     delay?: number;
-    fields?: string[];
+    fields?: Path<T>[];
     enabled?: boolean;
 }
 /**
@@ -3044,7 +3507,7 @@ interface UseDebouncedValidationOptions {
  * @see {@link useDebouncedFieldValidation} for single field debouncing
  * @category Hooks
  */
-declare function useDebouncedValidation<T extends Record<string, any>>(form: UseFormReturn<T>, options?: UseDebouncedValidationOptions): {
+declare function useDebouncedValidation<T extends FieldValues>(form: UseFormReturn<T>, options?: UseDebouncedValidationOptions<T>): {
     debouncedTrigger: () => void;
     isDebouncing: boolean;
 };
@@ -3095,7 +3558,7 @@ declare function useDebouncedValidation<T extends Record<string, any>>(form: Use
  * @see {@link useDebouncedValidation} for multiple fields
  * @category Hooks
  */
-declare function useDebouncedFieldValidation<T extends Record<string, any>>(form: UseFormReturn<T>, fieldName: keyof T, options?: {
+declare function useDebouncedFieldValidation<T extends FieldValues>(form: UseFormReturn<T>, fieldName: Path<T>, options?: {
     delay?: number;
     enabled?: boolean;
 }): {
@@ -3109,7 +3572,7 @@ declare function useDebouncedFieldValidation<T extends Record<string, any>>(form
  * @template T - The form data type
  */
 interface UseInferredFormOptions<T extends FieldValues> {
-    defaultValues?: Partial<T>;
+    defaultValues?: DefaultValues<T>;
     mode?: "onChange" | "onBlur" | "onSubmit" | "onTouched" | "all";
     reValidateMode?: "onChange" | "onBlur" | "onSubmit";
     shouldFocusError?: boolean;
@@ -3213,6 +3676,33 @@ declare function useTypeInferredForm<T extends FieldValues>(formConfig: {
     fields: ZodFormFieldConfig<T>[];
 }, options?: UseInferredFormOptions<T>): UseFormReturn<T>;
 
+/**
+ * Hook for lazy field registration to reduce initial memory usage.
+ *
+ * This hook registers fields only when they become active (e.g., when a condition is met),
+ * preventing the memory overhead of always-registered fields while avoiding
+ * register/unregister cycles that cause memory leaks in Cypress.
+ *
+ * @param fieldName - The field name to potentially register
+ * @param shouldRegister - Function that determines if the field should be registered
+ * @param defaultValue - Default value for the field when registered
+ * @param rules - Validation rules for the field
+ */
+declare function useLazyFieldRegistration<TFieldValues extends FieldValues>(fieldName: FieldPath<TFieldValues>, shouldRegister: () => boolean, defaultValue?: any, rules?: any): {
+    currentValue: undefined;
+    isRegistered: boolean;
+};
+/**
+ * Hook for lazy field array registration.
+ *
+ * Similar to useLazyFieldRegistration but specifically for field arrays,
+ * which have more complex registration requirements.
+ */
+declare function useLazyFieldArrayRegistration<TFieldValues extends FieldValues>(arrayName: FieldPath<TFieldValues>, shouldRegister: () => boolean, defaultValue?: any[]): {
+    currentValue: any;
+    isRegistered: boolean;
+};
+
 /**
  * Props for the ConditionalField component.
  *
@@ -3292,6 +3782,8 @@ declare function ContentField<TFieldValues extends FieldValues>({ config, form,
 interface FieldArrayFieldProps<TFieldValues extends FieldValues> {
     config: FieldArrayConfig<TFieldValues>;
     className?: string;
+    /** Whether this field array should always be registered (for conditional rendering) */
+    alwaysRegistered?: boolean;
 }
 /**
  * Field array component for dynamic repeating field groups.
@@ -3408,7 +3900,7 @@ interface FieldArrayFieldProps<TFieldValues extends FieldValues> {
  * @see {@link createFieldArrayCustomConfig} for advanced custom rendering
  * @category Fields
  */
-declare function FieldArrayField<TFieldValues extends FieldValues>({ className, config, }: FieldArrayFieldProps<TFieldValues>): React$1.JSX.Element | null;
+declare function FieldArrayField<TFieldValues extends FieldValues>({ alwaysRegistered, className, config, }: FieldArrayFieldProps<TFieldValues>): React$1.JSX.Element | null;
 
 /**
  * Props for the DynamicSectionField component.
@@ -3521,7 +4013,7 @@ declare function throttle<T extends (...args: any[]) => any>(func: T, limit: num
 /**
  * Memoization helper for expensive computations
  */
-declare function useMemoizedCallback<T extends (...args: any[]) => any>(callback: T, deps: React.DependencyList): T;
+declare function useMemoizedCallback<T extends (...args: unknown[]) => unknown>(callback: T, deps: React.DependencyList): T;
 /**
  * Shallow comparison for React.memo
  */
@@ -3700,6 +4192,40 @@ interface CreateFieldArrayCustomConfigOptions<TFieldValues extends FieldValues>
  */
 declare function createFieldArrayCustomConfig<TFieldValues extends FieldValues>(options: CreateFieldArrayCustomConfigOptions<TFieldValues>): CustomFieldConfig<TFieldValues>;
 
+/**
+ * Memory management utilities for field arrays to prevent memory leaks
+ * in Cypress tests and long-running applications.
+ */
+/**
+ * Hook to clean up field array memory when component unmounts.
+ * Helps prevent memory accumulation in Cypress Electron renderer.
+ */
+declare function useFieldArrayMemoryCleanup<TFieldValues extends FieldValues>(arrayName: FieldPath<TFieldValues>): {
+    cleanup: () => void;
+};
+/**
+ * Utility to force garbage collection hints for Cypress tests.
+ * Only effective when experimentalMemoryManagement is enabled.
+ */
+declare function suggestGarbageCollection(): void;
+/**
+ * Memory-safe field array operations that include cleanup hints.
+ */
+declare const memorySafeFieldArray: {
+    /**
+     * Add items to a field array with memory management.
+     */
+    addItems: <TFieldValues extends FieldValues>(append: (value: any) => void, items: any[], onProgress?: (addedCount: number) => void) => void;
+    /**
+     * Clear entire field array with memory cleanup.
+     */
+    clearArray: <TFieldValues extends FieldValues>(setValue: (name: FieldPath<TFieldValues>, value: any) => void, arrayName: FieldPath<TFieldValues>) => void;
+    /**
+     * Remove items from a field array with memory cleanup.
+     */
+    removeItems: <TFieldValues extends FieldValues>(remove: (index: number) => void, indices: number[]) => void;
+};
+
 /**
  * Common validation patterns for forms
  */
@@ -3783,4 +4309,4 @@ declare const validationUtils: {
     }>;
 };
 
-export { AdvancedFieldBuilder, type ArraySyncOptions, type ArraySyncResult, AutocompleteField, type AutocompleteFieldProps, type AutocompleteOption, type BaseFormFieldConfig, BasicFormBuilder, type BooleanFieldConfig, type ButtonDefaults, type CheckboxDefaults, CheckboxField, type CheckboxFieldProps, type CommonFieldDefaults, CommonFields, ConditionalField, type ConditionalFieldConfig, type ConditionalFieldProps, type ConditionalValidation, ConfigurableForm, ContentField, type ContentFieldConfig, type CreateFieldArrayCustomConfigOptions, type CustomFieldConfig, DateField, type DateFieldConfig, type DateFieldProps, type DateInputDefaults, type DynamicSectionConfig, DynamicSectionField, type DynamicSectionFieldProps, type EnhancedFormState, FieldArrayBuilder, type FieldArrayConfig, FieldArrayField, type FieldArrayFieldProps, FieldArrayItemBuilder, type FieldBaseProps, type FieldGroup, FileField, type FileFieldConfig, type FileFieldProps, FontPickerField, type FontPickerFieldConfig, type FontPickerFieldProps, type FormConfig, FormField, type FormFieldConfig, FormFieldHelpers, type FormProps, FormProvider, FormStatus, type FormStatusProps, type FormStep, type FormSubmissionState, type FormTestUtils, FormToast, type FormToastProps, type FormValidationError, type HeroHookFormDefaultsConfig, HeroHookFormProvider, type HeroHookFormProviderProps, type InputDefaults, InputField, type InputFieldProps, type RadioFieldConfig, type RadioGroupDefaults, RadioGroupField, type RadioGroupFieldProps, type SelectDefaults, SelectField, type SelectFieldProps, ServerActionForm, type ServerFieldError, type ServerFormError, SimpleForm, type SimpleFormProps, type SliderDefaults, SliderField, type SliderFieldConfig, type SliderFieldProps, type StringFieldConfig, SubmitButton, type SubmitButtonProps, type SwitchDefaults, SwitchField, type SwitchFieldProps, type TextareaDefaults, TextareaField, type TextareaFieldProps, TypeInferredBuilder, type UseDebouncedValidationOptions, type UseEnhancedFormStateOptions, type UseInferredFormOptions, type ValidationUtils, type WithControl, type WizardFormConfig, ZodForm, type ZodFormConfig, type ZodFormFieldConfig, applyServerErrors, asyncValidation, commonValidations, createAdvancedBuilder, createBasicFormBuilder, createDateSchema, createEmailSchema, createField, createFieldArrayBuilder, createFieldArrayCustomConfig, createFieldArrayItemBuilder, createFileSchema, createFormTestUtils, createFutureDateSchema, createMaxLengthSchema, createMinLengthSchema, createMockFormData, createMockFormErrors, createNestedPathBuilder, createNumberRangeSchema, createOptimizedFieldHandler, createPasswordSchema, createPastDateSchema, createPhoneSchema, createRequiredCheckboxSchema, createRequiredSchema, createTypeInferredBuilder, createUrlSchema, createZodFormConfig, crossFieldValidation, debounce, deepEqual, defineInferredForm, errorMessages, field, getFieldError, getFormErrors, hasFieldError, hasFormErrors, serverValidation, shallowEqual, simulateFieldInput, simulateFormSubmission, syncArrays, throttle, useDebouncedFieldValidation, useDebouncedValidation, useEnhancedFormState, useFormHelper, useHeroForm, useHeroHookFormDefaults, useInferredForm, useMemoizedCallback, useMemoizedFieldProps, usePerformanceMonitor, useTypeInferredForm, useZodForm, validationPatterns, validationUtils, waitForFormState };
+export { AdvancedFieldBuilder, type ArraySyncOptions, type ArraySyncResult, AutocompleteField, type AutocompleteFieldProps, type AutocompleteOption, type BaseFormFieldConfig, BasicFormBuilder, type BooleanFieldConfig, type ButtonDefaults, type CheckboxDefaults, CheckboxField, type CheckboxFieldProps, CheckboxGroupField, type CheckboxGroupFieldConfig, type CheckboxGroupFieldProps, type CommonFieldDefaults, CommonFields, ConditionalField, type ConditionalFieldConfig, type ConditionalFieldProps, type ConditionalValidation, ConfigurableForm, ContentField, type ContentFieldConfig, type CreateFieldArrayCustomConfigOptions, type CustomFieldConfig, DateField, type DateFieldConfig, type DateFieldProps, type DateInputDefaults, type DynamicSectionConfig, DynamicSectionField, type DynamicSectionFieldProps, type EnhancedFormState, FieldArrayBuilder, type FieldArrayConfig, FieldArrayField, type FieldArrayFieldProps, FieldArrayItemBuilder, type FieldBaseProps, type FieldCreationParams, type FieldGroup, FileField, type FileFieldConfig, type FileFieldProps, FontPickerField, type FontPickerFieldConfig, type FontPickerFieldProps, type FormConfig, FormField, type FormFieldConfig, FormFieldHelpers, type FormFieldType, type FormProps, FormProvider, FormStatus, type FormStatusProps, type FormStep, type FormSubmissionState, type FormTestUtils, FormToast, type FormToastProps, type FormValidationError, type HeroHookFormDefaultsConfig, HeroHookFormProvider, type HeroHookFormProviderProps, type InputDefaults, InputField, type InputFieldProps, type RadioFieldConfig, type RadioGroupDefaults, RadioGroupField, type RadioGroupFieldProps, type SelectDefaults, SelectField, type SelectFieldProps, ServerActionForm, type ServerFieldError, type ServerFormError, SimpleForm, type SimpleFormProps, type SliderDefaults, SliderField, type SliderFieldConfig, type SliderFieldProps, type StringArrayFieldConfig, type StringFieldConfig, SubmitButton, type SubmitButtonProps, type SwitchDefaults, SwitchField, type SwitchFieldProps, type TextareaDefaults, TextareaField, type TextareaFieldProps, TypeInferredBuilder, type UseDebouncedValidationOptions, type UseEnhancedFormStateOptions, type UseInferredFormOptions, type ValidationUtils, type WithControl, type WizardFormConfig, ZodForm, type ZodFormConfig, type ZodFormFieldConfig, applyServerErrors, asyncValidation, commonValidations, createAdvancedBuilder, createBasicFormBuilder, createDateSchema, createEmailSchema, createField, createFieldArrayBuilder, createFieldArrayCustomConfig, createFieldArrayItemBuilder, createFileSchema, createFormTestUtils, createFutureDateSchema, createMaxLengthSchema, createMinLengthSchema, createMockFormData, createMockFormErrors, createNestedPathBuilder, createNumberRangeSchema, createOptimizedFieldHandler, createPasswordSchema, createPastDateSchema, createPhoneSchema, createRequiredCheckboxSchema, createRequiredSchema, createTypeInferredBuilder, createUrlSchema, createZodFormConfig, crossFieldValidation, debounce, deepEqual, defineInferredForm, errorMessages, field, getFieldError, getFormErrors, hasFieldError, hasFormErrors, memorySafeFieldArray, pathToString, serverValidation, shallowEqual, simulateFieldInput, simulateFormSubmission, suggestGarbageCollection, syncArrays, throttle, useDebouncedFieldValidation, useDebouncedValidation, useEnhancedFormState, useFieldArrayMemoryCleanup, useFormHelper, useHeroForm, useHeroHookFormDefaults, useInferredForm, useLazyFieldArrayRegistration, useLazyFieldRegistration, useMemoizedCallback, useMemoizedFieldProps, usePerformanceMonitor, useTypeInferredForm, useZodForm, validationPatterns, validationUtils, waitForFormState };