/// <reference types="react" />
export declare type Name = string | number;
export declare type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
export declare type BooleanTree<T> = {
    [K in keyof T]?: T[K] extends object ? BooleanTree<T[K]> : boolean;
};
export declare type FormErrors<T extends object> = {
    [P in keyof T]?: T[P] extends object ? FormErrors<T[P]> : string[];
};
export interface FormMeta<T extends object> {
    formValue: T;
    submitCount: number;
    resetForm: () => void;
    submit: () => void;
    forgetState: () => void;
    setFormValue: (setValue: SetFormValueFunc<T>) => void;
    setFormVisited: (set: SetFormVisitedFunc<T>) => void;
    setFormTouched: (set: SetFormTouchedFunc<T>) => void;
}
export interface SetFormValueFunc<T extends object> {
    (previousValue: T): T;
}
export interface SetFieldValueFunc<T> {
    (previousValue: T): T;
}
export interface SetFormVisitedFunc<T extends object> {
    (previousVisited: BooleanTree<T>): BooleanTree<T>;
}
export interface SetFormTouchedFunc<T extends object> {
    (previousTouched: BooleanTree<T>): BooleanTree<T>;
}
export interface InputProps<T = any> {
    name: string;
    value: T;
    onBlur: (e: React.FocusEvent<any>) => void;
    onFocus: (e: React.FocusEvent<any>) => void;
    onChange: (e: React.ChangeEvent<any>) => void;
}
export interface UseFieldConfig<F extends object, T = any> {
    validate?: FieldValidator<T, F> | Array<FieldValidator<T, F>>;
}
export interface FieldConfig<F extends object, T = any> {
    name: Name;
    render?: (props: FieldProps<F, T>) => JSX.Element;
    validate?: FieldValidator<T, F> | Array<FieldValidator<T, F>>;
    component?: React.ComponentType<FieldProps<F, T>> | string;
    [key: string]: any;
}
export declare type UseFieldFn<T, F extends object> = (name: Name, props: UseFieldConfig<F, T>) => UseFieldProps<F, T>;
export declare type UseFieldProps<F extends object, T = any> = [InputProps<T>, FieldMeta<F, T>];
export interface FieldProps<F extends object, T = any> {
    input: InputProps<T>;
    meta: FieldMeta<F, T>;
    [key: string]: any;
}
export interface FieldMeta<F extends object, T = any> extends FormMeta<F> {
    path: string;
    visited: boolean;
    isDirty: boolean;
    touched: boolean;
    isActive: boolean;
    isValid: boolean;
    errors: string[];
    initialValue: T;
    setValue: (value: T | SetFieldValueFunc<T>, touch?: boolean) => void;
    setVisited: (value: boolean) => void;
    setTouched: (value: boolean) => void;
}
export declare type ValidationResult = string | void | undefined;
export interface FieldValidator<T, F extends object> {
    (value: T, formValue: F): ValidationResult;
}
export interface FormState<F extends object> {
    formValue: F;
    errorCount: number;
    submitCount: number;
    errors: FormErrors<F>;
    touched: BooleanTree<F>;
    visited: BooleanTree<F>;
    activeField: string | null;
}
export interface RepeatConfig<T> {
    name: Name;
    fallback?: T[];
    children: (value: T[], utils: ArrayHelpers<T>) => React.ReactNode;
}
export interface ArrayHelpers<T> {
    push: (...items: T[]) => number;
    pop: () => T | undefined;
    shift: () => T | undefined;
    unshift: (...items: T[]) => number;
    insert: (index: number, ...items: T[]) => number;
    swap: (index1: number, index2: number) => void;
    remove: (index: number) => T | undefined;
    setValue: (value: T[] | SetFieldValueFunc<T[]>) => void;
}
export interface SectionHelpers<T> {
    setValue: (value: T | SetFieldValueFunc<T>) => void;
}
export interface YaflBaseContext<F extends object, T = F> {
    value: T;
    initialValue: T;
    errorCount: number;
    formValue: F;
    touched: BooleanTree<any>;
    visited: BooleanTree<any>;
    activeField: string | null;
    submitCount: number;
    formIsValid: boolean;
    formIsDirty: boolean;
    errors: FormErrors<F>;
    submit: () => void;
    resetForm: () => void;
    forgetState: () => void;
    setActiveField: (path: string | null) => void;
    touchField: (path: string, touched: boolean) => void;
    visitField: (path: string, visited: boolean) => void;
    registerErrors: (path: string, errors: string[]) => void;
    unregisterErrors: (path: string, errors: string[]) => void;
    setFormValue: (setFunc: SetFormValueFunc<F>) => void;
    setValue: (path: string, value: any, setTouched?: boolean) => void;
    setFormTouched: (setFunc: SetFormTouchedFunc<F>) => void;
    setFormVisited: (setFunc: SetFormVisitedFunc<F>) => void;
    unregisterField: (path: string) => void;
    registerField: (path: string) => void;
}
export interface FormProvider<F extends object, T = F> extends YaflBaseContext<F, T> {
    path: string;
    branchValues: any;
    commonValues: Record<string, any>;
}
export interface FormProps<F extends object> extends FormMeta<F> {
    initialValue: F;
    formIsValid: boolean;
    formIsDirty: boolean;
    activeField: string | null;
    visited: BooleanTree<F>;
    touched: BooleanTree<F>;
    errorCount: number;
    errors: FormErrors<F>;
    [key: string]: any;
}
export interface UseFormConfig<T extends object> {
    initialValue?: T;
    disabled?: boolean;
    initialSubmitCount?: number;
    initialTouched?: BooleanTree<T>;
    initialVisited?: BooleanTree<T>;
    submitUnregisteredValues?: boolean;
    persistFieldState?: boolean;
    onSubmit?: (formValue: T, props: FormProps<T>) => boolean | void;
    rememberStateOnReinitialize?: boolean;
    onStateChange?: (previousState: FormState<T>, nextState: FormState<T>) => void;
    onFormValueChange?: (prev: T, next: T) => void;
}
export interface FormConfig<T extends object> extends UseFormConfig<T> {
    commonValues?: ((state: {
        formValue: T;
    }) => Record<string, any>) | Record<string, any>;
    branchValues?: ((state: {
        formValue: T;
    }) => Record<string, any>) | Record<string, any>;
    children: React.ReactNode | ((props: FormProps<T>) => React.ReactNode);
}