import React$1, { Dispatch, SetStateAction, ReactNode, ReactElement } from 'react';

type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;

type DictDeepActionKeyWayItemStringType = string;
type DictDeepActionKeyWayItemDictType = {
    name: string;
    index: number;
};
type DictDeepActionKeyWayItemType = DictDeepActionKeyWayItemStringType | DictDeepActionKeyWayItemDictType;
type DictDeepActionKeyWayType = DictDeepActionKeyWayItemType[];

type UseIsErrorFieldNameType = string | DictDeepActionKeyWayType;
type UseIsErrorFieldIsErrorItemType = {
    name: UseIsErrorFieldNameType;
    errorMessage?: string;
};
type UseIsErrorFieldIsErrorType = UseIsErrorFieldIsErrorItemType[];
type UseIsErrorFieldIsErrorFieldType = (name: UseIsErrorFieldNameType) => boolean;
type UseIsErrorFieldGetErrorMessageType = (name: UseIsErrorFieldNameType) => string | undefined;
type UseIsErrorFieldAddErrorFieldType = (name: UseIsErrorFieldNameType, errorMessage?: string) => void;
type UseIsErrorFieldRemoveErrorFieldType = (name: UseIsErrorFieldNameType) => void;
type UseIsErrorFieldReturnType = {
    isErrorField: UseIsErrorFieldIsErrorFieldType;
    addErrorField: UseIsErrorFieldAddErrorFieldType;
    removeErrorField: UseIsErrorFieldRemoveErrorFieldType;
    getErrorMessage: UseIsErrorFieldGetErrorMessageType;
    clearErrors: () => void;
    isError: UseIsErrorFieldIsErrorType;
};
declare function useIsErrorField({ additionIsErrorFields, sensitiveSearch, }?: {
    additionIsErrorFields?: UseIsErrorFieldIsErrorType;
    sensitiveSearch?: boolean;
}): UseIsErrorFieldReturnType;

type UseFormDataSetValueType = (value: any, keyWay: DictDeepActionKeyWayType, options?: {
    unionToArray: boolean;
    index?: number;
}) => void;
type UseFormDataGetValueType = (keyWay: DictDeepActionKeyWayType) => any;
type UseFormDataDeleteArrayItemType = (keyWay: DictDeepActionKeyWayType) => void;
type UseFormDataReturnType<T> = {
    formData: T;
    setFormData: Dispatch<SetStateAction<T>>;
    setValue: UseFormDataSetValueType;
    getValue: UseFormDataGetValueType;
    resetForm: () => void;
    clearForm: () => void;
    deleteArrayItem: UseFormDataDeleteArrayItemType;
};
declare function useFormData<T extends Record<string, any>>(value?: T): UseFormDataReturnType<T>;

declare function isDict(variable: any): boolean;

declare function setDeepValue(dict: {
    [key: string]: any;
}, value: any, options: {
    keysWay: DictDeepActionKeyWayType;
}): {
    [key: string]: any;
};

declare function getDeepValue(dict: {
    [key: string]: any;
}, keyWay: DictDeepActionKeyWayType): any;

declare function isArray(value: any): value is any[];

declare function isEqualArrays(a: any[], b: any[]): boolean;

declare function getUniqueArray<T>(array: T[], comparator?: (a: T, b: T) => boolean): T[];

declare function handleScrollEnd(e: React$1.UIEvent<HTMLDivElement>, callback: (e: React$1.UIEvent<HTMLDivElement>) => void): void;

declare function isCustomComponent(element: React.ReactElement): boolean;

type FlexFieldClassNameType = {
    flexField?: string;
    inputField?: string;
    isError?: string;
    disabled?: string;
    focus?: string;
    pointer?: string;
    textIcon?: string;
    trashIcon?: string;
    dropdownIcon?: string;
};
type FlexFieldPropsType = {
    value?: any;
    type?: HTMLInputElement['type'];
    onChange?: (value: any) => void;
    mask?: any;
    placeholder?: string;
    required?: boolean;
    disabled?: boolean;
    isError?: boolean;
    onFocus?: (e: any) => void;
    onBlur?: (e: any) => void;
    onClick?: (e: React$1.MouseEvent<HTMLDivElement>) => void;
    beforeElements?: ReactNode;
    afterElements?: ReactNode;
    textIcon?: ReactElement;
    trashIcon?: ReactElement;
    dropdownIcon?: ReactElement;
    onTextIconClick?: () => void;
    onTrashIconClick?: () => void;
    onDropdownIconClick?: () => void;
    notInput?: boolean;
    className?: FlexFieldClassNameType;
};

declare const FlexField: React$1.ForwardRefExoticComponent<FlexFieldPropsType & React$1.RefAttributes<HTMLDivElement>>;

type SelectFieldOptionsItemClassNameType = {
    selectFieldOptionsItem?: string;
    label?: string;
    active?: string;
};
type SelectFieldOptionsOwnerItemPropsType = {
    active?: boolean;
    onClick?: () => void;
};
type SelectFieldOptionsItemPropsType = {
    option: SelectFieldOptionsItemType;
    active?: boolean;
    onClick?: () => void;
    className?: SelectFieldOptionsItemClassNameType;
};

type SelectModalWindowClassNameType = SelectFieldOptionsItemClassNameType & {
    selectModalWindow?: string;
};
type SelectModalWindowPropsType = {
    value: SelectFieldValueType;
    onChange: (value: any[]) => void;
    options: SelectFieldOptionsType;
    onScrollToBottom?: () => void;
    className?: SelectModalWindowClassNameType;
};

type SelectFieldClassNameType = FlexFieldClassNameType & SelectModalWindowClassNameType & {
    selectField?: string;
    modalWindow?: string;
};
type SelectFieldOptionsItemType = {
    value: any;
    label?: string;
    component?: ReactElement<SelectFieldOptionsOwnerItemPropsType>;
};
type SelectFieldOptionsType = SelectFieldOptionsItemType[];
type SelectFieldValueType = any[] | any;
type SelectFieldLoadMoreOptionsType = (optionsCount: number) => Promise<SelectFieldOptionsType>;
type SelectFieldPropsType = {
    value?: SelectFieldValueType;
    onChange?: (value: any) => void;
    isError?: boolean;
    isSearching?: boolean;
    required?: boolean;
    multiple?: boolean;
    disabled?: boolean;
    offOptionsSyncing?: boolean;
    placeholder?: string;
    onBlur?: () => void;
    options?: SelectFieldOptionsType;
    autoClose?: boolean;
    loadMoreOptions?: SelectFieldLoadMoreOptionsType;
    className?: SelectFieldClassNameType;
};

declare function SelectField({ value, onChange, options, placeholder, isError, isSearching, required, multiple, disabled, offOptionsSyncing, autoClose, onBlur, loadMoreOptions, className, }: SelectFieldPropsType): React$1.JSX.Element;

type InputFieldWrapperClassNameType = {
    inputFieldWrapper?: string;
    isError?: string;
    labelText?: string;
    hintText?: string;
    helperLink?: string;
    required?: string;
    hintError?: string;
};
type InputFieldWrapperHelperLinkType = {
    text: ReactNode;
    href?: string;
} | {
    element: ReactElement;
} | {
    text: string;
    onClick?: () => void;
};
type InputFieldWrapperPropsType = {
    children?: ReactNode;
    labelText?: string;
    hintText?: string;
    isErrorHintText?: string;
    helperLink?: InputFieldWrapperHelperLinkType;
    isError?: boolean;
    viewRequired?: boolean;
    className?: InputFieldWrapperClassNameType;
};

declare function InputFieldWrapper({ children, labelText, hintText, isErrorHintText, helperLink, isError, viewRequired, className, }: InputFieldWrapperPropsType): React$1.JSX.Element;

type SwitcherFieldClassNameType = {
    switcherField?: string;
    active?: string;
};
type SwitcherFieldPropsType = {
    value?: boolean;
    onChange?: (value: any) => void;
    disabled?: boolean;
    className?: SwitcherFieldClassNameType;
    switcherWrapper?: ReactElement;
    children?: ReactNode;
};

declare function SwitcherField({ value, onChange, children, disabled, switcherWrapper, className }: SwitcherFieldPropsType): React$1.JSX.Element;

type RadioFieldItemClassNameType = {
    radioFieldItem?: string;
    checkbox?: string;
    label?: string;
    active?: string;
};
type RadioFieldOwnerItemPropsType = {
    onClick?: () => void;
    active?: boolean;
    disabled?: boolean;
};
type RadioFieldItemPropsType = {
    option: RadioFieldOptionsItemType;
    onClick?: () => void;
    active?: boolean;
    disabled?: boolean;
    className?: RadioFieldItemClassNameType;
};

type RadioFieldClassNameType = RadioFieldItemClassNameType & {
    radioField?: string;
};
type RadioFieldOptionsItemType = {
    value: any;
    label?: string;
    component?: ReactElement<RadioFieldOwnerItemPropsType>;
};
type RadioFieldOptionsType = RadioFieldOptionsItemType[];
type RadioFieldValueType = any | any[];
type RadioFieldPropsType = {
    value?: RadioFieldValueType;
    onChange?: (value: any) => void;
    options?: RadioFieldOptionsType;
    required?: boolean;
    multiple?: boolean;
    disabled?: boolean;
    className?: RadioFieldClassNameType;
};

declare function RadioField({ value, onChange, options, required, multiple, disabled, className, }: RadioFieldPropsType): React$1.JSX.Element;

type TextareaFieldClassNameType = {
    textareaField?: string;
    isError?: string;
};
type TextareaFieldPropsType = {
    value?: string;
    name?: string;
    placeholder?: string;
    onChange?: (value: any) => void;
    isError?: boolean;
    required?: boolean;
    disabled?: boolean;
    className?: TextareaFieldClassNameType;
};

declare function TextareaField({ value, name, placeholder, onChange, required, disabled, isError, className, }: TextareaFieldPropsType): React$1.JSX.Element;

type InputFieldTypes = 'switcher' | 'select' | 'radio' | 'textarea' | HTMLInputElement['type'];
type InputFieldClassNameType = SwitcherFieldClassNameType & FlexFieldClassNameType & RadioFieldClassNameType & SelectFieldClassNameType & TextareaFieldClassNameType & InputFieldWrapperClassNameType & {};
type AllFields = SelectFieldPropsType & RadioFieldPropsType & FlexFieldPropsType & SwitcherFieldPropsType & TextareaFieldPropsType & InputFieldWrapperPropsType;
type InputFieldPropsType = Omit<AllFields, 'value' | 'onChange'> & {
    value?: any;
    onChange?: (value: any) => void;
    type?: InputFieldTypes;
    offWrapper?: boolean;
    className?: InputFieldClassNameType;
};

declare function InputField({ type, offWrapper, className, ...props }: InputFieldPropsType): React$1.JSX.Element;

type BLOCK_SCHEMA = {
    type: 'block';
    props?: Overwrite<React$1.HTMLProps<HTMLDivElement>, {
        children?: FORM_BUILDER_SCHEMA;
    }>;
};
type ADDITION_PROPS = {
    type: 'addition_props';
    props: {
        className?: {
            [key: string]: string;
        };
    };
};
type CUSTOM_FIELD_WRAPPER_SCHEMA = {
    type: 'custom_field_wrapper';
    props: Overwrite<InputFieldWrapperPropsType, {
        children?: FORM_BUILDER_SCHEMA;
    }>;
};
type InputFieldValidationFunObjectReturnType = {
    status: boolean;
    message: string;
};
type InputFieldValidationFunReturnType = string | boolean | InputFieldValidationFunObjectReturnType;
type InputFieldValidationFunType = (data: any) => InputFieldValidationFunReturnType;
type InputFieldOnBlurValidationType = {
    required?: boolean;
    fun?: InputFieldValidationFunType;
};
type INPUT_FIELD_SCHEMA = {
    type: 'input_field';
    props: Overwrite<InputFieldPropsType, {
        keyWay?: string[];
        ownerInputComponent?: ReactElement;
        onBlurValidation?: InputFieldOnBlurValidationType;
        onChangeValidation?: InputFieldOnBlurValidationType;
        required?: boolean;
        defaultValue?: any;
        serializeValue?: (data: any) => any;
        deserializeValue?: (data: any) => any;
    }> & {
        [key: string]: any;
    };
};
type REACT_NODE_SCHEMA = {
    type: 'react_node_component';
    react_node_comp?: ReactNode;
};
type FORM_WRAPPER_SCHEMA = {
    type: 'form_wrapper';
    form_wrapper?: ReactElement;
    props: Overwrite<React$1.HTMLProps<HTMLDivElement>, {
        name?: string;
        children?: FORM_BUILDER_SCHEMA;
    }>;
};
type ARRAY_FIELDS_SCHEMA = {
    type: 'array_fields';
    array_comp?: ReactElement;
    props: Overwrite<React$1.HTMLProps<HTMLDivElement>, {
        name: string;
        children?: FORM_BUILDER_SCHEMA;
    }>;
};
type BLOCK_WRAPPER_SCHEMA<T = HTMLDivElement> = {
    type: 'block_wrapper';
    block_wrapper?: ReactElement;
    props?: Overwrite<React$1.HTMLProps<T>, {
        children?: FORM_BUILDER_SCHEMA;
    }>;
};
type FORM_BUILDER_SCHEMA = (FORM_WRAPPER_SCHEMA | REACT_NODE_SCHEMA | INPUT_FIELD_SCHEMA | BLOCK_SCHEMA | ADDITION_PROPS | CUSTOM_FIELD_WRAPPER_SCHEMA | ARRAY_FIELDS_SCHEMA | BLOCK_WRAPPER_SCHEMA)[];

type FormBuilderPropsType<T> = {
    schema: FORM_BUILDER_SCHEMA;
    formDataDefault?: T;
    onChange?: (formData: T) => void;
    onChangeIsError?: (isError: UseIsErrorFieldIsErrorType) => void;
    onChangeValidateIsError?: (isError: UseIsErrorFieldIsErrorType) => void;
    inputFieldClassName?: InputFieldClassNameType;
    additionIsErrorFields?: UseIsErrorFieldIsErrorType;
    formDataDefaultListener?: T;
    sensitiveErrorSearch?: boolean;
    inputFieldAdditionProps?: InputFieldAdditionPropsType;
};
type GetStoreValueType = (key: string) => any;
type AddStoreValueType = (value: any, key: string) => void;
type RemoveStoreValueType = (key: string) => void;
type ValidateFunction = {
    validateFun: (data: any) => boolean;
    keyWay: DictDeepActionKeyWayType;
    errorMessage?: string;
};
type CustomCompAdditionPropsType = {
    deletearrayitem?: () => void;
    getvalue?: () => any;
};
type StandardCompAdditionPropsType = {
    [key: string]: any;
};
type InputFieldAdditionPropsType = {
    [key: string]: any;
};
type AdditionPropsType = {
    keyWay: DictDeepActionKeyWayType;
    arrayKeyWayItemName?: string;
    getCurArrayIndex?: () => number;
    incrementCurArrayIndex?: () => void;
    getValue: UseFormDataGetValueType;
    setValue: UseFormDataSetValueType;
    deleteArrayItemHook: UseFormDataDeleteArrayItemType;
    isErrorField: UseIsErrorFieldIsErrorFieldType;
    getErrorMessage: UseIsErrorFieldGetErrorMessageType;
    addErrorField: UseIsErrorFieldAddErrorFieldType;
    removeErrorField: UseIsErrorFieldRemoveErrorFieldType;
    addOnChangeErrorField: UseIsErrorFieldAddErrorFieldType;
    removeOnChangeErrorField: UseIsErrorFieldRemoveErrorFieldType;
    inputFieldClassName?: InputFieldClassNameType;
    standardCompAdditionProps?: StandardCompAdditionPropsType;
    customCompAdditionProps?: CustomCompAdditionPropsType;
    inputFieldAdditionProps?: InputFieldAdditionPropsType;
    getPrivateRefStoreValue: GetStoreValueType;
    addPrivateRefStoreValue: AddStoreValueType;
    removePrivateRefStoreValue: RemoveStoreValueType;
};

declare function FormBuilder<T extends {
    [key: string]: any;
}>({ schema, formDataDefault, onChange, onChangeIsError, inputFieldClassName, additionIsErrorFields, onChangeValidateIsError, formDataDefaultListener, inputFieldAdditionProps, sensitiveErrorSearch, }: FormBuilderPropsType<T>): React$1.JSX.Element;

export { type ADDITION_PROPS, type ARRAY_FIELDS_SCHEMA, type AddStoreValueType, type AdditionPropsType, type BLOCK_SCHEMA, type BLOCK_WRAPPER_SCHEMA, type CUSTOM_FIELD_WRAPPER_SCHEMA, type CustomCompAdditionPropsType, type DictDeepActionKeyWayItemDictType, type DictDeepActionKeyWayItemStringType, type DictDeepActionKeyWayItemType, type DictDeepActionKeyWayType, type FORM_BUILDER_SCHEMA, type FORM_WRAPPER_SCHEMA, FlexField, type FlexFieldClassNameType, type FlexFieldPropsType, FormBuilder, type FormBuilderPropsType, type GetStoreValueType, type INPUT_FIELD_SCHEMA, InputField, type InputFieldAdditionPropsType, type InputFieldClassNameType, type InputFieldOnBlurValidationType, type InputFieldPropsType, type InputFieldTypes, type InputFieldValidationFunObjectReturnType, type InputFieldValidationFunReturnType, type InputFieldValidationFunType, InputFieldWrapper, type InputFieldWrapperClassNameType, type InputFieldWrapperHelperLinkType, type InputFieldWrapperPropsType, type Overwrite, type REACT_NODE_SCHEMA, RadioField, type RadioFieldClassNameType, type RadioFieldItemClassNameType, type RadioFieldItemPropsType, type RadioFieldOptionsItemType, type RadioFieldOptionsType, type RadioFieldOwnerItemPropsType, type RadioFieldPropsType, type RadioFieldValueType, type RemoveStoreValueType, SelectField, type SelectFieldClassNameType, type SelectFieldLoadMoreOptionsType, type SelectFieldOptionsItemClassNameType, type SelectFieldOptionsItemPropsType, type SelectFieldOptionsItemType, type SelectFieldOptionsOwnerItemPropsType, type SelectFieldOptionsType, type SelectFieldPropsType, type SelectFieldValueType, type SelectModalWindowClassNameType, type SelectModalWindowPropsType, type StandardCompAdditionPropsType, SwitcherField, type SwitcherFieldClassNameType, type SwitcherFieldPropsType, TextareaField, type TextareaFieldClassNameType, type TextareaFieldPropsType, type UseFormDataDeleteArrayItemType, type UseFormDataGetValueType, type UseFormDataReturnType, type UseFormDataSetValueType, type UseIsErrorFieldAddErrorFieldType, type UseIsErrorFieldGetErrorMessageType, type UseIsErrorFieldIsErrorFieldType, type UseIsErrorFieldIsErrorItemType, type UseIsErrorFieldIsErrorType, type UseIsErrorFieldNameType, type UseIsErrorFieldRemoveErrorFieldType, type UseIsErrorFieldReturnType, type ValidateFunction, getDeepValue, getUniqueArray, handleScrollEnd, isArray, isCustomComponent, isDict, isEqualArrays, setDeepValue, useFormData, useIsErrorField };