export type ValidationRule<T> = (value: T) => string | undefined;
export interface FieldConfig<T> {
    /** Initial value */
    initialValue: T;
    /** Validation rules (return error string or undefined) */
    validate?: ValidationRule<T>[];
    /** Whether field is required */
    required?: boolean;
    /** Custom required message */
    requiredMessage?: string;
}
export interface FormFieldState<T> {
    value: T;
    error?: string;
    touched: boolean;
    dirty: boolean;
}
export interface UseFormValidationOptions<T extends Record<string, unknown>> {
    /** Field configurations */
    fields: {
        [K in keyof T]: FieldConfig<T[K]>;
    };
    /** Validate on change (default: only after blur) */
    validateOnChange?: boolean;
    /** Validate on blur (default: true) */
    validateOnBlur?: boolean;
}
export interface UseFormValidationResult<T extends Record<string, unknown>> {
    /** Current form values */
    values: T;
    /** Field errors */
    errors: Partial<Record<keyof T, string>>;
    /** Which fields have been touched (blurred) */
    touched: Partial<Record<keyof T, boolean>>;
    /** Which fields have been modified */
    dirty: Partial<Record<keyof T, boolean>>;
    /** Whether the form is valid */
    isValid: boolean;
    /** Whether any field has been modified */
    isDirty: boolean;
    /** Set a field value */
    setValue: <K extends keyof T>(field: K, value: T[K]) => void;
    /** Set multiple values at once */
    setValues: (values: Partial<T>) => void;
    /** Mark a field as touched (trigger validation) */
    setTouched: (field: keyof T) => void;
    /** Validate a single field */
    validateField: (field: keyof T) => string | undefined;
    /** Validate all fields */
    validateAll: () => boolean;
    /** Reset form to initial values */
    reset: () => void;
    /** Reset a single field */
    resetField: (field: keyof T) => void;
    /** Get props for an input field */
    getFieldProps: <K extends keyof T>(field: K) => {
        value: T[K];
        onChange: (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => void;
        onBlur: () => void;
        name: string;
        'aria-invalid': boolean;
    };
    /** Get error message for a field (only if touched) */
    getFieldError: (field: keyof T) => string | undefined;
}
/**
 * useFormValidation Hook
 *
 * A comprehensive form validation hook with touched state tracking,
 * field-level validation, and accessibility support.
 *
 * @example
 * ```tsx
 * const { values, errors, getFieldProps, getFieldError, validateAll, isValid } = useFormValidation({
 *   fields: {
 *     email: {
 *       initialValue: '',
 *       required: true,
 *       requiredMessage: 'Email is required',
 *       validate: [
 *         (v) => !v.includes('@') ? 'Invalid email format' : undefined,
 *       ],
 *     },
 *     password: {
 *       initialValue: '',
 *       required: true,
 *       validate: [
 *         (v) => v.length < 8 ? 'Password must be at least 8 characters' : undefined,
 *       ],
 *     },
 *   },
 * });
 *
 * const handleSubmit = (e: FormEvent) => {
 *   e.preventDefault();
 *   if (validateAll()) {
 *     // Submit form
 *   }
 * };
 *
 * return (
 *   <form onSubmit={handleSubmit}>
 *     <input {...getFieldProps('email')} type="email" />
 *     {getFieldError('email') && <span>{getFieldError('email')}</span>}
 *
 *     <input {...getFieldProps('password')} type="password" />
 *     {getFieldError('password') && <span>{getFieldError('password')}</span>}
 *
 *     <button type="submit" disabled={!isValid}>Submit</button>
 *   </form>
 * );
 * ```
 */
export declare function useFormValidation<T extends Record<string, unknown>>({ fields, validateOnChange, validateOnBlur, }: UseFormValidationOptions<T>): UseFormValidationResult<T>;
export default useFormValidation;
//# sourceMappingURL=useFormValidation.d.ts.map