type UseFormOptions<T> = {
    initialValues: T;
    validateOn?: "change" | "blur" | "submit";
    asyncDebounceMs?: number;
    blockSubmitWhileValidating?: boolean;
};
type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date | Function;
type KeyOf<T> = Extract<keyof T, string>;
type DeepMap<T, V> = T extends Primitive ? V : T extends Array<infer U> ? Array<DeepMap<U, V>> : T extends object ? {
    [K in KeyOf<T>]?: DeepMap<T[K], V>;
} : V;
type Errors<T> = DeepMap<T, string>;
type Touched<T> = DeepMap<T, boolean>;
type Validating<T> = DeepMap<T, boolean>;
type Rules<T> = {
    required?: boolean | string;
    pattern?: RegExp | {
        value: RegExp;
        message: string;
    };
    minLength?: number | {
        value: number;
        message: string;
    };
    maxLength?: number | {
        value: number;
        message: string;
    };
    min?: number | {
        value: number;
        message: string;
    };
    max?: number | {
        value: number;
        message: string;
    };
    asyncDebounceMs?: number;
    /** Return a string for error message, or undefined for valid. */
    validate?: (value: unknown, values: T) => string | undefined;
    /** Return a Promise resolving to a string error message or undefined. */
    validateAsync?: (value: unknown, values: T) => Promise<string | undefined>;
};
type ResetOptions = {
    keepErrors?: boolean;
    keepTouched?: boolean;
    keepDirty?: boolean;
    keepValidating?: boolean;
};
type ResetFieldOptions = {
    keepError?: boolean;
    keepTouched?: boolean;
    keepDirty?: boolean;
    keepValidating?: boolean;
};

type FieldMeta = {
    isTouched: boolean;
    isDirty: boolean;
    isValidating: boolean;
    error: string | undefined;
    showError: boolean;
};

declare function useForm<T extends Record<string, any>>(options: UseFormOptions<T>): {
    values: T;
    errors: any;
    touched: Touched<T>;
    dirty: any;
    validating: Validating<T>;
    isValid: boolean;
    isDirty: boolean;
    isValidating: boolean;
    shouldShowError: (name: string) => boolean;
    getFieldMeta: (name: string) => FieldMeta;
    formState: {
        isValid: boolean;
        isDirty: boolean;
        isValidating: boolean;
        submitCount: number;
        hasSubmitted: boolean;
    };
    register: (name: string, rules?: Rules<any>) => {
        name: string;
        value: any;
        onChange: (e: any) => void;
        onBlur: () => void;
    };
    setValue: (name: string, value: any, opts?: {
        shouldValidate?: boolean;
        shouldTouch?: boolean;
    }) => void;
    setValues: (partial: Partial<T>, opts?: {
        shouldValidate?: boolean;
        shouldTouch?: boolean;
        bypassDebounce?: boolean;
    }) => void;
    setError: (name: string, message: string) => void;
    clearError: (name: string) => void;
    clearErrors: () => void;
    setTouched: (name: string, isTouched: boolean) => void;
    touchAll: () => void;
    reset: (opts?: ResetOptions) => void;
    resetField: (name: string, opts?: ResetFieldOptions) => void;
    append: (name: string, value: any, opts?: {
        shouldValidate?: boolean;
        shouldTouch?: boolean;
    }) => void;
    remove: (name: string, index: number, opts?: {
        shouldValidate?: boolean;
        shouldTouch?: boolean;
    }) => void;
    insert: (name: string, index: number, value: any, opts?: {
        shouldValidate?: boolean;
        shouldTouch?: boolean;
    }) => void;
    replace: (name: string, index: number, value: any, opts?: {
        shouldValidate?: boolean;
        shouldTouch?: boolean;
    }) => void;
    move: (name: string, fromIndex: number, toIndex: number) => void;
    swap: (name: string, indexA: number, indexB: number) => void;
    validateField: (name: string, nextValues: T) => boolean;
    handleSubmit: (onValid: (vals: T) => void, onInvalid?: (errs: Errors<T>) => void) => (e?: any) => Promise<void>;
    submitCount: number;
    hasSubmitted: boolean;
};

export { type Errors, type Rules, type UseFormOptions, useForm };