@rachelallyson/hero-hook-form 1.2.0 → 2.0.0

package/dist/index.d.ts

@@ -103,7 +103,27 @@ interface CustomFieldConfig<TFieldValues extends FieldValues> extends BaseFormFi
         isSubmitting: boolean;
     }) => React.ReactNode;
 }
-type FormFieldConfig<TFieldValues extends FieldValues> = StringFieldConfig<TFieldValues> | BooleanFieldConfig<TFieldValues> | RadioFieldConfig<TFieldValues> | SliderFieldConfig<TFieldValues> | DateFieldConfig<TFieldValues> | FileFieldConfig<TFieldValues> | FontPickerFieldConfig<TFieldValues> | CustomFieldConfig<TFieldValues>;
+interface ConditionalFieldConfig<TFieldValues extends FieldValues> extends BaseFormFieldConfig<TFieldValues> {
+    type: "conditional";
+    condition: (formData: Partial<TFieldValues>) => boolean;
+    field: ZodFormFieldConfig<TFieldValues>;
+}
+interface FieldArrayConfig<TFieldValues extends FieldValues> extends BaseFormFieldConfig<TFieldValues> {
+    type: "fieldArray";
+    fields: ZodFormFieldConfig<TFieldValues>[];
+    min?: number;
+    max?: number;
+    addButtonText?: string;
+    removeButtonText?: string;
+}
+interface DynamicSectionConfig<TFieldValues extends FieldValues> extends BaseFormFieldConfig<TFieldValues> {
+    type: "dynamicSection";
+    title?: string;
+    description?: string;
+    condition: (formData: Partial<TFieldValues>) => boolean;
+    fields: ZodFormFieldConfig<TFieldValues>[];
+}
+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>;
 interface FormConfig<TFieldValues extends FieldValues> {
     fields: FormFieldConfig<TFieldValues>[];
     layout?: "vertical" | "horizontal" | "grid" | "custom";
@@ -117,7 +137,7 @@ 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">;
+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">;
 interface ZodFormConfig<TFieldValues extends FieldValues> extends UseFormProps<TFieldValues> {
     schema: zod.ZodSchema<TFieldValues>;
     fields: ZodFormFieldConfig<TFieldValues>[];
@@ -220,7 +240,7 @@ interface FormFieldProps<TFieldValues extends FieldValues> {
     form: UseFormReturn<TFieldValues>;
     submissionState: FormSubmissionState;
 }
-declare function FormField<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: <TFieldValues extends FieldValues>(props: FormFieldProps<TFieldValues>) => React$1.JSX.Element;
 
 type CheckboxFieldProps<TFieldValues extends FieldValues> = FieldBaseProps<TFieldValues, boolean> & WithControl<TFieldValues> & {
     checkboxProps?: Omit<React$1.ComponentProps<typeof Checkbox>, "isSelected" | "onValueChange" | "isInvalid" | "errorMessage" | "isDisabled">;
@@ -256,7 +276,7 @@ type InputFieldProps<TFieldValues extends FieldValues> = FieldBaseProps<TFieldVa
     inputProps?: Omit<React$1.ComponentProps<typeof Input>, "value" | "onValueChange" | "label" | "isInvalid" | "errorMessage" | "isDisabled">;
     transform?: (value: string) => string;
 };
-declare function InputField<TFieldValues extends FieldValues>(props: InputFieldProps<TFieldValues>): React$1.JSX.Element;
+declare const InputField: <TFieldValues extends FieldValues>(props: InputFieldProps<TFieldValues>) => React$1.JSX.Element;
 
 interface RadioOption<TValue extends string | number> {
     label: string;
@@ -418,9 +438,38 @@ interface FormProps<TFieldValues extends FieldValues> {
 }
 declare function FormProvider<TFieldValues extends FieldValues>(props: FormProps<TFieldValues>): React$1.JSX.Element;
 
+interface EnhancedFormState<T extends FieldValues> {
+    status: "idle" | "submitting" | "success" | "error";
+    isSubmitting: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    error?: string;
+    submittedData?: T;
+    touchedFields: Set<Path<T>>;
+    dirtyFields: Set<Path<T>>;
+    hasErrors: boolean;
+    errorCount: number;
+    handleSuccess: (data: T) => void;
+    handleError: (error: string) => void;
+    reset: () => void;
+}
+interface UseEnhancedFormStateOptions<T extends FieldValues> {
+    onSuccess?: (data: T) => void;
+    onError?: (error: string) => void;
+    successMessage?: string;
+    errorMessage?: string;
+    autoReset?: boolean;
+    resetDelay?: number;
+}
+declare function useEnhancedFormState<T extends FieldValues>(form: UseFormReturn<T>, options?: UseEnhancedFormStateOptions<T>): EnhancedFormState<T>;
+
 interface SubmitButtonProps {
     children: React$1.ReactNode;
     isLoading?: boolean;
+    isSuccess?: boolean;
+    successText?: string;
+    loadingText?: string;
+    enhancedState?: EnhancedFormState<any>;
     buttonProps?: Omit<React$1.ComponentProps<typeof Button$1>, "type" | "isLoading">;
 }
 declare function SubmitButton(props: SubmitButtonProps): React$1.JSX.Element;
@@ -565,6 +614,29 @@ declare const commonValidations: {
     requiredCheckbox: (fieldName: string) => z.ZodBoolean;
     url: z.ZodString;
 };
+/**
+ * Cross-field validation helpers
+ */
+declare const crossFieldValidation: {
+    /**
+     * Password confirmation validation
+     */
+    passwordConfirmation: (passwordField: string, confirmField: string) => z.ZodObject<{
+        [x: string]: z.ZodString;
+    }, z.core.$strip>;
+    /**
+     * Date range validation
+     */
+    dateRange: (startField: string, endField: string) => z.ZodObject<{
+        [x: string]: z.ZodString;
+    }, z.core.$strip>;
+    /**
+     * Conditional required field validation
+     */
+    conditionalRequired: (field: string, conditionField: string, conditionValue: any) => z.ZodObject<{
+        [x: string]: z.ZodString | z.ZodAny;
+    }, z.core.$strip>;
+};
 
 interface ZodFormProps<T extends FieldValues> {
     className?: string;
@@ -602,4 +674,657 @@ declare function useZodForm<TFieldValues extends FieldValues>(config: ZodFormCon
  */
 declare function createZodFormConfig<TFieldValues extends FieldValues>(schema: z.ZodSchema<TFieldValues>, fields: ZodFormFieldConfig<TFieldValues>[], defaultValues?: Partial<TFieldValues>): ZodFormConfig<TFieldValues>;
 
-export { type BaseFormFieldConfig, type BooleanFieldConfig, type ButtonDefaults, type CheckboxDefaults, CheckboxField, type CheckboxFieldProps, type CommonFieldDefaults, type ConditionalValidation, ConfigurableForm, type CustomFieldConfig, DateField, type DateFieldConfig, type DateFieldProps, type DateInputDefaults, type FieldBaseProps, type FieldGroup, FileField, type FileFieldConfig, type FileFieldProps, FontPickerField, type FontPickerFieldConfig, type FontPickerFieldProps, type FormConfig, FormField, type FormFieldConfig, type FormProps, FormProvider, type FormStep, type FormSubmissionState, type FormTestUtils, type FormValidationError, type HeroHookFormDefaultsConfig, HeroHookFormProvider, type HeroHookFormProviderProps, type InputDefaults, InputField, type InputFieldProps, type RadioFieldConfig, type RadioGroupDefaults, RadioGroupField, type RadioGroupFieldProps, type SelectDefaults, SelectField, type SelectFieldProps, type ServerFieldError, type ServerFormError, type SliderDefaults, SliderField, type SliderFieldConfig, type SliderFieldProps, type StringFieldConfig, SubmitButton, type SubmitButtonProps, type SwitchDefaults, SwitchField, type SwitchFieldProps, type TextareaDefaults, TextareaField, type TextareaFieldProps, type ValidationUtils, type WithControl, type WizardFormConfig, ZodForm, type ZodFormConfig, type ZodFormFieldConfig, applyServerErrors, commonValidations, createConditionalSchema, createConfirmPasswordSchema, createDateSchema, createEmailSchema, createFileSchema, createFormTestUtils, createFutureDateSchema, createMaxLengthSchema, createMinLengthSchema, createMockFormData, createMockFormErrors, createNumberRangeSchema, createPasswordSchema, createPastDateSchema, createPhoneSchema, createRequiredCheckboxSchema, createRequiredSchema, createUrlSchema, createZodFormConfig, getFieldError, getFormErrors, hasFieldError, hasFormErrors, simulateFieldInput, simulateFormSubmission, useFormHelper, useHeroForm, useHeroHookFormDefaults, useZodForm, waitForFormState };
+/**
+ * Basic form field builder that eliminates "as const" assertions
+ * Focuses on the most common use cases
+ */
+declare class BasicFormBuilder<T extends FieldValues> {
+    private fields;
+    /**
+     * Add an input field
+     */
+    input(name: Path<T>, label: string, type?: "text" | "email" | "tel" | "password"): this;
+    /**
+     * Add a textarea field
+     */
+    textarea(name: Path<T>, label: string, placeholder?: string): this;
+    /**
+     * Add a select field
+     */
+    select(name: Path<T>, label: string, options: {
+        label: string;
+        value: string | number;
+    }[]): this;
+    /**
+     * Add a checkbox field
+     */
+    checkbox(name: Path<T>, label: string): this;
+    /**
+     * Add a switch field
+     */
+    switch(name: Path<T>, label: string): this;
+    /**
+     * Build the final field configuration array
+     */
+    build(): ZodFormFieldConfig<T>[];
+}
+/**
+ * Create a new simple form field builder
+ */
+declare function createBasicFormBuilder<T extends FieldValues>(): BasicFormBuilder<T>;
+/**
+ * Simple helper functions for common field types
+ */
+declare const FormFieldHelpers: {
+    /**
+     * Create an input field
+     */
+    input: <T extends FieldValues>(name: Path<T>, label: string, type?: "text" | "email" | "tel" | "password") => ZodFormFieldConfig<T>;
+    /**
+     * Create a textarea field
+     */
+    textarea: <T extends FieldValues>(name: Path<T>, label: string, placeholder?: string) => ZodFormFieldConfig<T>;
+    /**
+     * Create a select field
+     */
+    select: <T extends FieldValues>(name: Path<T>, label: string, options: {
+        label: string;
+        value: string | number;
+    }[]) => ZodFormFieldConfig<T>;
+    /**
+     * Create a checkbox field
+     */
+    checkbox: <T extends FieldValues>(name: Path<T>, label: string) => ZodFormFieldConfig<T>;
+    /**
+     * Create a switch field
+     */
+    switch: <T extends FieldValues>(name: Path<T>, label: string) => ZodFormFieldConfig<T>;
+};
+/**
+ * Common field collections
+ */
+declare const CommonFields: {
+    /**
+     * Personal information fields
+     */
+    personal: <T extends FieldValues>() => ZodFormFieldConfig<T>[];
+    /**
+     * Address fields
+     */
+    address: <T extends FieldValues>() => ZodFormFieldConfig<T>[];
+    /**
+     * Terms and conditions fields
+     */
+    terms: <T extends FieldValues>() => ZodFormFieldConfig<T>[];
+};
+
+/**
+ * Unified field creation function
+ * Takes field type as first argument and delegates to appropriate helper
+ */
+declare function createField<T extends FieldValues>(type: string, name: Path<T>, label: string, optionsOrProps?: any, props?: any): ZodFormFieldConfig<T>;
+/**
+ * Builder pattern for advanced field creation
+ */
+declare class AdvancedFieldBuilder<T extends FieldValues> {
+    private fields;
+    /**
+     * 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;
+    /**
+     * Add a conditional field that shows/hides based on form data
+     */
+    conditionalField(name: Path<T>, condition: (formData: Partial<T>) => boolean, field: ZodFormFieldConfig<T>): this;
+    /**
+     * Add a field array for dynamic repeating field groups
+     */
+    fieldArray(name: Path<T>, label: string, fields: ZodFormFieldConfig<any>[], options?: {
+        min?: number;
+        max?: number;
+        addButtonText?: string;
+        removeButtonText?: string;
+    }): this;
+    /**
+     * Add a dynamic section that shows/hides based on form data
+     */
+    dynamicSection(name: Path<T>, condition: (formData: Partial<T>) => boolean, fields: ZodFormFieldConfig<T>[], options?: {
+        title?: string;
+        description?: string;
+    }): this;
+    /**
+     * Build the final field configuration array
+     */
+    build(): ZodFormFieldConfig<T>[];
+}
+/**
+ * Field Array Builder for strongly-typed array item fields
+ */
+declare class FieldArrayItemBuilder<TItem extends FieldValues> {
+    private fields;
+    /**
+     * 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;
+    /**
+     * Build the field array item configuration
+     */
+    build(): ZodFormFieldConfig<TItem>[];
+}
+/**
+ * Create a field array item builder for strongly-typed array fields
+ */
+declare function createFieldArrayItemBuilder<TItem extends FieldValues>(): FieldArrayItemBuilder<TItem>;
+/**
+ * Field Array Builder for constructing field arrays with proper paths
+ */
+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>[];
+}
+/**
+ * Create a field array builder that constructs proper paths for array items
+ */
+declare function createFieldArrayBuilder<T extends FieldValues, TArrayName extends Path<T>>(arrayName: TArrayName): FieldArrayBuilder<T, TArrayName>;
+/**
+ * Create a new advanced field builder
+ */
+declare function createAdvancedBuilder<T extends FieldValues>(): AdvancedFieldBuilder<T>;
+
+/**
+ * Type-inferred form builder that auto-generates both schema and field configs
+ */
+declare class TypeInferredBuilder<T extends FieldValues> {
+    private schemaFields;
+    private formFields;
+    /**
+     * Add a text field
+     */
+    text(name: Path<T>, label: string, options?: {
+        placeholder?: string;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string;
+    }): this;
+    /**
+     * Add an email field
+     */
+    email(name: Path<T>, label: string, options?: {
+        placeholder?: string;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    }): this;
+    /**
+     * Add a number field
+     */
+    number(name: Path<T>, label: string, options?: {
+        placeholder?: string;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+        min?: number;
+        max?: number;
+        step?: number;
+    }): this;
+    /**
+     * Add a textarea field
+     */
+    textarea(name: Path<T>, label: string, options?: {
+        placeholder?: string;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+        rows?: number;
+        minLength?: number;
+    }): this;
+    /**
+     * Add a select field
+     */
+    select(name: Path<T>, label: string, options: {
+        label: string;
+        value: string | number;
+    }[], fieldOptions?: {
+        placeholder?: string;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    }): this;
+    /**
+     * Add a checkbox field
+     */
+    checkbox(name: Path<T>, label: string, options?: {
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+        required?: boolean;
+    }): this;
+    /**
+     * Add a switch field
+     */
+    switch(name: Path<T>, label: string, options?: {
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    }): this;
+    /**
+     * Add a radio field
+     */
+    radio(name: Path<T>, label: string, options: {
+        label: string;
+        value: string | number;
+    }[], fieldOptions?: {
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+        orientation?: "horizontal" | "vertical";
+    }): this;
+    /**
+     * Add a slider field
+     */
+    slider(name: Path<T>, label: string, options?: {
+        min?: number;
+        max?: number;
+        step?: number;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    }): this;
+    /**
+     * Add a date field
+     */
+    date(name: Path<T>, label: string, options?: {
+        placeholder?: string;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    }): this;
+    /**
+     * Add a file field
+     */
+    file(name: Path<T>, label: string, options?: {
+        accept?: string;
+        multiple?: boolean;
+        description?: string;
+        isDisabled?: boolean;
+        className?: string;
+    }): this;
+    /**
+     * Build the final schema and fields
+     */
+    build(): {
+        schema: z.ZodSchema<T>;
+        fields: ZodFormFieldConfig<T>[];
+    };
+}
+/**
+ * Create a new type-inferred form builder
+ */
+declare function createTypeInferredBuilder<T extends FieldValues>(): TypeInferredBuilder<T>;
+/**
+ * Define a form with type inference
+ */
+declare function defineInferredForm<T extends FieldValues>(fieldDefinitions: (builder: TypeInferredBuilder<T>) => TypeInferredBuilder<T>): {
+    schema: z.ZodSchema<T>;
+    fields: ZodFormFieldConfig<T>[];
+};
+/**
+ * Field type builders for individual field creation
+ */
+declare const field: {
+    text: <T extends FieldValues>(name: Path<T>, label: string, options?: Parameters<TypeInferredBuilder<T>["text"]>[2]) => TypeInferredBuilder<T>;
+    email: <T extends FieldValues>(name: Path<T>, label: string, options?: Parameters<TypeInferredBuilder<T>["email"]>[2]) => TypeInferredBuilder<T>;
+    number: <T extends FieldValues>(name: Path<T>, label: string, options?: Parameters<TypeInferredBuilder<T>["number"]>[2]) => TypeInferredBuilder<T>;
+    textarea: <T extends FieldValues>(name: Path<T>, label: string, options?: Parameters<TypeInferredBuilder<T>["textarea"]>[2]) => TypeInferredBuilder<T>;
+    select: <T extends FieldValues>(name: Path<T>, label: string, options: {
+        label: string;
+        value: string | number;
+    }[], fieldOptions?: Parameters<TypeInferredBuilder<T>["select"]>[3]) => TypeInferredBuilder<T>;
+    checkbox: <T extends FieldValues>(name: Path<T>, label: string, options?: Parameters<TypeInferredBuilder<T>["checkbox"]>[2]) => TypeInferredBuilder<T>;
+    switch: <T extends FieldValues>(name: Path<T>, label: string, options?: Parameters<TypeInferredBuilder<T>["switch"]>[2]) => TypeInferredBuilder<T>;
+    radio: <T extends FieldValues>(name: Path<T>, label: string, options: {
+        label: string;
+        value: string | number;
+    }[], fieldOptions?: Parameters<TypeInferredBuilder<T>["radio"]>[3]) => TypeInferredBuilder<T>;
+    slider: <T extends FieldValues>(name: Path<T>, label: string, options?: Parameters<TypeInferredBuilder<T>["slider"]>[2]) => TypeInferredBuilder<T>;
+    date: <T extends FieldValues>(name: Path<T>, label: string, options?: Parameters<TypeInferredBuilder<T>["date"]>[2]) => TypeInferredBuilder<T>;
+    file: <T extends FieldValues>(name: Path<T>, label: string, options?: Parameters<TypeInferredBuilder<T>["file"]>[2]) => TypeInferredBuilder<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;
+    /**
+     * Create a nested object path builder
+     * Usage: builder.nest("address").field("street", "Street Address")
+     */
+    nest<TPath extends Path<T>>(path: TPath): NestedObjectBuilder<T, TPath>;
+    /**
+     * Create a section-based path builder
+     * Usage: builder.section("shipping").field("street", "Street Address")
+     */
+    section<TPath extends Path<T>>(path: TPath): SectionBuilder<T, TPath>;
+    /**
+     * Add a field with single path
+     * Usage: builder.field("firstName", "First Name")
+     */
+    field(name: Path<T>, label: string, type?: string, props?: any): this;
+    /**
+     * Add a field with path segments
+     * Usage: builder.fieldPath(["user", "profile", "name"], "Full Name")
+     */
+    fieldPath(path: string[], label: string, type?: string, props?: any): this;
+    /**
+     * Add a field with template literal path
+     * Usage: builder.field`user.profile.name`("Full Name")
+     */
+    fieldTemplate(path: TemplateStringsArray, ...args: any[]): FieldTemplateBuilder<T>;
+    /**
+     * Return to the parent builder (no-op for root builder)
+     */
+    end(): this;
+    build(): ZodFormFieldConfig<T>[];
+}
+/**
+ * Nested object builder for chaining nested paths
+ */
+declare class NestedObjectBuilder<T extends FieldValues, TPath extends Path<T>> {
+    private parent;
+    private path;
+    constructor(parent: NestedPathBuilder<T>, path: TPath);
+    /**
+     * Add a field to the current nested path
+     */
+    field<FName extends string>(fieldName: FName, label: string, type?: string, props?: any): NestedObjectBuilder<T, TPath>;
+    /**
+     * Nest deeper into the object
+     */
+    nest<SubPath extends string>(subPath: SubPath): NestedObjectBuilder<T, TPath>;
+    /**
+     * Return to the parent builder
+     */
+    end(): NestedPathBuilder<T>;
+}
+/**
+ * Section builder for grouping related fields
+ */
+declare class SectionBuilder<T extends FieldValues, TPath extends Path<T>> {
+    private parent;
+    private path;
+    constructor(parent: NestedPathBuilder<T>, path: TPath);
+    /**
+     * Add a field to the current section
+     */
+    field<FName extends string>(fieldName: FName, label: string, type?: string, props?: any): SectionBuilder<T, TPath>;
+    /**
+     * Add multiple fields to the section
+     */
+    fields(fieldDefinitions: Array<{
+        name: string;
+        label: string;
+        type?: string;
+        props?: any;
+    }>): SectionBuilder<T, TPath>;
+    /**
+     * Nest deeper into the section
+     */
+    nest<SubPath extends string>(subPath: SubPath): NestedObjectBuilder<T, TPath>;
+    /**
+     * Return to the parent builder
+     */
+    end(): NestedPathBuilder<T>;
+}
+/**
+ * Template literal field builder
+ */
+declare class FieldTemplateBuilder<T extends FieldValues> {
+    private parent;
+    private path;
+    constructor(parent: NestedPathBuilder<T>, path: string);
+    /**
+     * Complete the field definition
+     */
+    complete(label: string, type?: string, props?: any): NestedPathBuilder<T>;
+}
+/**
+ * Factory function for creating the nested path builder
+ */
+declare function createNestedPathBuilder<T extends FieldValues>(): NestedPathBuilder<T>;
+
+interface UseDebouncedValidationOptions {
+    delay?: number;
+    fields?: string[];
+    enabled?: boolean;
+}
+declare function useDebouncedValidation<T extends Record<string, any>>(form: UseFormReturn<T>, options?: UseDebouncedValidationOptions): {
+    debouncedTrigger: () => void;
+    isDebouncing: boolean;
+};
+declare function useDebouncedFieldValidation<T extends Record<string, any>>(form: UseFormReturn<T>, fieldName: keyof T, options?: {
+    delay?: number;
+    enabled?: boolean;
+}): {
+    debouncedFieldTrigger: () => void;
+    isDebouncing: boolean;
+};
+
+interface UseInferredFormOptions<T extends FieldValues> {
+    defaultValues?: Partial<T>;
+    mode?: "onChange" | "onBlur" | "onSubmit" | "onTouched" | "all";
+    reValidateMode?: "onChange" | "onBlur" | "onSubmit";
+    shouldFocusError?: boolean;
+    shouldUnregister?: boolean;
+    delayError?: number;
+}
+declare function useInferredForm<T extends FieldValues>(schema: any, fields: ZodFormFieldConfig<T>[], options?: UseInferredFormOptions<T>): UseFormReturn<T>;
+/**
+ * Hook that works with type-inferred forms
+ */
+declare function useTypeInferredForm<T extends FieldValues>(formConfig: {
+    schema: any;
+    fields: ZodFormFieldConfig<T>[];
+}, options?: UseInferredFormOptions<T>): UseFormReturn<T>;
+
+interface ConditionalFieldProps<TFieldValues extends FieldValues> {
+    config: ConditionalFieldConfig<TFieldValues>;
+    control: Control<TFieldValues>;
+    className?: string;
+}
+declare function ConditionalField<TFieldValues extends FieldValues>({ config, control, className, }: ConditionalFieldProps<TFieldValues>): React$1.JSX.Element | null;
+
+interface FieldArrayFieldProps<TFieldValues extends FieldValues> {
+    config: FieldArrayConfig<TFieldValues>;
+    className?: string;
+}
+declare function FieldArrayField<TFieldValues extends FieldValues>({ config, className, }: FieldArrayFieldProps<TFieldValues>): React$1.JSX.Element | null;
+
+interface DynamicSectionFieldProps<TFieldValues extends FieldValues> {
+    config: DynamicSectionConfig<TFieldValues>;
+    control: Control<TFieldValues>;
+    className?: string;
+}
+declare function DynamicSectionField<TFieldValues extends FieldValues>({ config, control, className, }: DynamicSectionFieldProps<TFieldValues>): React$1.JSX.Element | null;
+
+interface FormStatusProps<T extends Record<string, any>> {
+    state: EnhancedFormState<T>;
+    onDismiss?: () => void;
+    className?: string;
+    showDetails?: boolean;
+}
+declare function FormStatus<T extends Record<string, any>>({ state, onDismiss, className, showDetails, }: FormStatusProps<T>): React$1.JSX.Element | null;
+interface FormToastProps<T extends Record<string, any>> {
+    state: EnhancedFormState<T>;
+    onDismiss?: () => void;
+    position?: "top-right" | "top-left" | "bottom-right" | "bottom-left";
+    duration?: number;
+}
+declare function FormToast<T extends Record<string, any>>({ state, onDismiss, position, duration, }: FormToastProps<T>): React$1.JSX.Element | null;
+
+/**
+ * Debounce function for field changes
+ */
+declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * Throttle function for high-frequency events
+ */
+declare function throttle<T extends (...args: any[]) => any>(func: T, limit: number): (...args: Parameters<T>) => void;
+/**
+ * Memoization helper for expensive computations
+ */
+declare function useMemoizedCallback<T extends (...args: any[]) => any>(callback: T, deps: React.DependencyList): T;
+/**
+ * Shallow comparison for React.memo
+ */
+declare function shallowEqual<T extends Record<string, any>>(prevProps: T, nextProps: T): boolean;
+/**
+ * Deep comparison for complex objects
+ */
+declare function deepEqual<T extends Record<string, any>>(prevProps: T, nextProps: T): boolean;
+/**
+ * Performance monitoring utilities (dev mode only)
+ */
+declare function usePerformanceMonitor(componentName: string, enabled?: boolean): {
+    renderCount: number;
+    resetRenderCount: () => void;
+};
+/**
+ * Optimized field change handler
+ */
+declare function createOptimizedFieldHandler<T>(onChange: (value: T) => void, options?: {
+    debounce?: number;
+    throttle?: number;
+    validate?: boolean;
+}): (value: T) => void;
+/**
+ * Memoized field props to prevent unnecessary re-renders
+ */
+declare function useMemoizedFieldProps<T extends Record<string, any>>(props: T, deps: React.DependencyList): T;
+/**
+ * Batch field updates to reduce re-renders
+ */
+declare function useBatchedFieldUpdates<T extends Record<string, any>>(form: any, fields: (keyof T)[]): {
+    batchUpdate: (fieldName: keyof T, value: any) => void;
+};
+
+/**
+ * Common validation patterns for forms
+ */
+declare const validationPatterns: {
+    email: z.ZodString;
+    phoneUS: z.ZodString;
+    phoneInternational: z.ZodString;
+    url: z.ZodString;
+    password: z.ZodString;
+    strongPassword: z.ZodString;
+    creditCard: z.ZodString;
+    ssn: z.ZodString;
+    zipCode: z.ZodString;
+    date: z.ZodString;
+    time: z.ZodString;
+};
+/**
+ * Async validation helpers
+ */
+declare const asyncValidation: {
+    /**
+     * Email availability check
+     */
+    emailAvailability: (email: string) => Promise<boolean>;
+    /**
+     * Username availability check
+     */
+    usernameAvailability: (username: string) => Promise<boolean>;
+};
+/**
+ * Custom error messages
+ */
+declare const errorMessages: {
+    required: (fieldName: string) => string;
+    minLength: (fieldName: string, min: number) => string;
+    maxLength: (fieldName: string, max: number) => string;
+    min: (fieldName: string, min: number) => string;
+    max: (fieldName: string, max: number) => string;
+    pattern: (fieldName: string) => string;
+    email: () => string;
+    url: () => string;
+    phone: () => string;
+    date: () => string;
+    time: () => string;
+};
+/**
+ * Server-side validation integration
+ */
+declare const serverValidation: {
+    /**
+     * Apply server errors to form
+     */
+    applyServerErrors: (errors: Record<string, string[]>, setError: any) => void;
+    /**
+     * Clear server errors
+     */
+    clearServerErrors: (fields: string[], clearErrors: any) => void;
+};
+/**
+ * Form validation utilities
+ */
+declare const validationUtils: {
+    /**
+     * Debounced validation
+     */
+    debounceValidation: (fn: Function, delay?: number) => (...args: any[]) => void;
+    /**
+     * Validate form data against schema
+     */
+    validateForm: (data: any, schema: z.ZodSchema) => Promise<{
+        success: boolean;
+        errors: Record<string, string>;
+    }>;
+    /**
+     * Get field error message
+     */
+    getFieldError: (errors: Record<string, string>, field: string) => string | undefined;
+    /**
+     * Check if field has error
+     */
+    hasFieldError: (errors: Record<string, string>, field: string) => boolean;
+};
+
+export { AdvancedFieldBuilder, type BaseFormFieldConfig, BasicFormBuilder, type BooleanFieldConfig, type ButtonDefaults, type CheckboxDefaults, CheckboxField, type CheckboxFieldProps, type CommonFieldDefaults, CommonFields, ConditionalField, type ConditionalFieldConfig, type ConditionalFieldProps, type ConditionalValidation, ConfigurableForm, 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, type ServerFieldError, type ServerFormError, 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, createConditionalSchema, createConfirmPasswordSchema, createDateSchema, createEmailSchema, createField, createFieldArrayBuilder, 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, throttle, useBatchedFieldUpdates, useDebouncedFieldValidation, useDebouncedValidation, useEnhancedFormState, useFormHelper, useHeroForm, useHeroHookFormDefaults, useInferredForm, useMemoizedCallback, useMemoizedFieldProps, usePerformanceMonitor, useTypeInferredForm, useZodForm, validationPatterns, validationUtils, waitForFormState };