import * as React from 'react';
import { Comparer, Selector } from 'use-optimized-selector';
import { TypedField } from './Field.types';
import { TypedFieldArray } from './FieldArray.types';
import { PathMatchingValue, PathOf, PathLikeValue } from './helpers/path-helpers';
export declare type ParseFn<Value> = (value: unknown, name: string) => Value;
export declare type FormatFn<Value> = (value: Value, name: string) => any;
export declare type SingleValue<Value> = Value extends (infer SingleValue)[] ? SingleValue : Value;
export declare type InputElements = "input" | "textarea" | "select";
/**
 * Values of fields in the form
 */
export interface FormikValues {
    [field: string]: any;
}
/**
 * An object containing error messages whose keys correspond to FormikValues.
 * Should always be an object of strings, but any is allowed to support i18n libraries.
 */
export declare type FormikErrors<Values> = {
    [K in keyof Values]?: Values[K] extends any[] ? Values[K][number] extends object ? FormikErrors<Values[K][number]>[] | string | string[] : string | string[] : Values[K] extends object ? FormikErrors<Values[K]> : string;
};
/**
 * An object containing touched state of the form whose keys correspond to FormikValues.
 */
export declare type FormikTouched<Values> = {
    [K in keyof Values]?: Values[K] extends any[] ? Values[K][number] extends object ? FormikTouched<Values[K][number]>[] : boolean : Values[K] extends object ? FormikTouched<Values[K]> : boolean;
};
/**
 * Formik state tree
 */
export interface FormikCurrentState<Values> {
    /** Form values */
    values: Values;
    /** map of field names to specific error for that field */
    errors: FormikErrors<Values>;
    /** map of field names to whether the field has been touched */
    touched: FormikTouched<Values>;
    /** whether the form is currently submitting */
    isSubmitting: boolean;
    /** whether the form is currently validating (prior to submission) */
    isValidating: boolean;
    /** Top level status state, in case you need it */
    status?: any;
    /** Number of times user tried to submit the form */
    submitCount: number;
}
export interface FormikInitialState<Values> {
    initialValues: FormikConfig<Values>['initialValues'];
    initialErrors: FormikConfig<Values>['initialErrors'];
    initialTouched: FormikConfig<Values>['initialTouched'];
    initialStatus: FormikConfig<Values>['initialStatus'];
}
export declare type FormikReducerState<Values> = FormikInitialState<Values> & FormikCurrentState<Values>;
export declare type FormikMessage<Values> = {
    type: 'SUBMIT_ATTEMPT';
} | {
    type: 'SUBMIT_FAILURE';
} | {
    type: 'SUBMIT_SUCCESS';
} | {
    type: 'SET_ISVALIDATING';
    payload: boolean;
} | {
    type: 'SET_ISSUBMITTING';
    payload: boolean;
} | {
    type: 'SET_VALUES';
    payload: Values;
} | {
    type: 'SET_FIELD_VALUE';
    payload: {
        field: string;
        value?: any;
    };
} | {
    type: 'SET_FIELD_TOUCHED';
    payload: {
        field: string;
        value?: boolean;
    };
} | {
    type: 'SET_FIELD_ERROR';
    payload: {
        field: string;
        value?: string;
    };
} | {
    type: 'SET_TOUCHED';
    payload: FormikTouched<Values>;
} | {
    type: 'SET_ERRORS';
    payload: FormikErrors<Values>;
} | {
    type: 'SET_STATUS';
    payload: any;
} | {
    type: 'SET_FORMIK_STATE';
    payload: (s: FormikReducerState<Values>) => FormikReducerState<Values>;
} | {
    type: 'RESET_FORM';
    payload: Partial<FormikReducerState<Values>>;
};
/**
 * Formik computed state. These are read-only and
 * result from updates to FormikState but do not live there.
 */
export interface FormikComputedState {
    /**
     * True if `!isEqual(initialValues, state.values)`
     */
    readonly dirty: boolean;
    /**
     * True if one of:
     * `dirty && state.errors is empty` or
     * `!dirty && isInitialValid`
     */
    readonly isValid: boolean;
}
/**
 * @deprecated use FormikComputedState
 */
export declare type FormikComputedProps = FormikComputedState;
export declare type FormikState<Values> = FormikReducerState<Values> & FormikComputedState;
export declare type GetStateFn<Values> = () => FormikState<Values>;
export declare type FormikSubscribeFn = (callback: Function) => () => void;
export declare type RegisterFieldFn<Values> = <Value>(name: PathMatchingValue<Value, Values>, args: {
    validate?: FieldValidator<SingleValue<Value>>;
}) => void;
export declare type UnregisterFieldFn<Values> = <Path extends PathOf<Values>>(name: Path) => void;
/**
 * Formik state helpers
 */
export declare type SetStatusFn = (status: any) => void;
export declare type SetErrorsFn<Values extends FormikValues> = (errors: FormikErrors<Values>) => void;
export declare type SetSubmittingFn = (isSubmitting: boolean) => void;
export declare type SetTouchedFn<Values extends FormikValues> = (touched: FormikTouched<Values>, shouldValidate?: boolean | undefined) => Promise<void | FormikErrors<Values>>;
export declare type SetValuesFn<Values extends FormikValues> = (values: React.SetStateAction<Values>, shouldValidate?: boolean | undefined) => Promise<void | FormikErrors<Values>>;
export declare type SetFieldValueFn<Values extends FormikValues> = <Value>(field: PathLikeValue<Value, Values> | PathMatchingValue<Value, Values>, value: Value, shouldValidate?: boolean | undefined) => Promise<void | FormikErrors<Values>>;
export declare type SetFieldErrorFn<Values> = <Path extends PathOf<Values>>(field: Path, error: string | undefined) => void;
export declare type SetFieldTouchedFn<Values extends FormikValues> = <Path extends PathOf<Values>>(field: Path, touched?: boolean | undefined, shouldValidate?: boolean | undefined) => Promise<void | FormikErrors<Values>>;
export declare type ValidateFormFn<Values extends FormikValues> = (values?: Values) => Promise<FormikErrors<Values>>;
export declare type ValidateFieldFn<Values> = <Path extends PathOf<Values>>(name: Path) => Promise<void | string | undefined>;
export declare type ResetFormFn<Values extends FormikValues> = (nextState?: Partial<FormikReducerState<Values>> | undefined) => void;
export declare type SetFormikStateFn<Values extends FormikValues> = (stateOrCb: FormikReducerState<Values> | ((state: FormikReducerState<Values>) => FormikReducerState<Values>)) => void;
export declare type SubmitFormFn = () => Promise<any>;
export interface FormikHelpers<Values> {
    /** Manually set top level status. */
    setStatus: SetStatusFn;
    /** Manually set errors object */
    setErrors: SetErrorsFn<Values>;
    /** Manually set isSubmitting */
    setSubmitting: SetSubmittingFn;
    /** Manually set touched object */
    setTouched: SetTouchedFn<Values>;
    /** Manually set values object  */
    setValues: SetValuesFn<Values>;
    /** Set value of form field directly */
    setFieldValue: SetFieldValueFn<Values>;
    /** Set error message of a form field directly */
    setFieldError: SetFieldErrorFn<Values>;
    /** Set whether field has been touched directly */
    setFieldTouched: SetFieldTouchedFn<Values>;
    /** Validate form values */
    validateForm: ValidateFormFn<Values>;
    /** Validate field value */
    validateField: ValidateFieldFn<Values>;
    /** Reset form */
    resetForm: ResetFormFn<Values>;
    /** Submit the form imperatively */
    submitForm: SubmitFormFn;
    /** Set Formik state, careful! */
    setFormikState: SetFormikStateFn<Values>;
}
export interface FormikStateHelpers<Values> {
    /** Get Formik State from outside of Render. */
    getState: GetStateFn<Values>;
    /**
     * Subscribe to changes when Formik updates.
     *
     * Probably avoid using this, instead use `useFormikSubscriptionByRef(formikRef.current, initialValues, selector, comparer)`
     */
    subscribe: FormikSubscribeFn;
    /** Use Formik State from within Render. */
    useState: <Return = FormikState<Values>>(selector?: Selector<FormikState<Values>, Return>, comparer?: Comparer<Return>, shouldSubscribe?: boolean) => Return;
}
export declare type HandleSubmitFn = (e?: React.FormEvent<HTMLFormElement> | undefined) => void;
export declare type HandleResetFn = (e?: any) => void;
/**
 * Event callback returned by `formik.handleBlur`.
 */
export declare type HandleBlurEventFn = (event: React.FocusEvent<any>) => void;
/**
 * Type of `formik.handleBlur`.
 * May be an event callback, or accept a field name and return an event callback.
 */
export declare type HandleBlurFn = {
    (eventOrString: string): HandleBlurEventFn;
    (event: React.FocusEvent<any>): void;
};
/**
 * Event callback returned by `formik.handleChange`.
 */
export declare type HandleChangeEventFn = (event: React.ChangeEvent<any> | string) => void;
/**
 * Type of `formik.handleChange`.
 * May be an event callback, or accept a field name and return an event callback.
 */
export declare type HandleChangeFn = {
    (event: React.ChangeEvent<any>): void;
    (name: string): HandleChangeEventFn;
};
/**
 * Formik form event handlers
 */
export interface FormikHandlers {
    handleSubmit: HandleSubmitFn;
    handleReset: HandleResetFn;
    handleBlur: HandleBlurFn;
    handleChange: HandleChangeFn;
}
export declare type ValidateFn<Values extends FormikValues> = (values?: Values | undefined) => Promise<void | FormikErrors<Values>>;
/** Internal Formik registration methods that get passed down as props */
export interface FormikRegistration<Values> {
    unregisterField: UnregisterFieldFn<Values>;
    registerField: RegisterFieldFn<Values>;
}
export interface FormikFieldHelpers<Values> {
    TypedField: TypedField<Values>;
    TypedFieldArray: TypedFieldArray<Values>;
}
export declare type FormikApi<Values extends FormikValues> = FormikHelpers<Values> & FormikStateHelpers<Values> & FormikHandlers & FormikRegistration<Values> & FormikFieldHelpers<Values>;
export declare type FormValidator<Values extends FormikValues> = (values: Values) => void | FormikErrors<Values> | Promise<FormikErrors<Values> | void>;
export interface FormikValidationConfig<Values> {
    /** Tells Formik to validate the form on each input's onChange event */
    validateOnChange?: boolean;
    /** Tells Formik to validate the form on each input's onBlur event */
    validateOnBlur?: boolean;
    /** Tells Formik to validate upon mount */
    validateOnMount?: boolean;
    /**
     * A Yup Schema or a function that returns a Yup schema
     */
    validationSchema?: any | (() => any);
    /**
     * Validation function. Must return an error object or promise that
     * throws an error object where that object keys map to corresponding value.
     */
    validate?: FormValidator<Values>;
}
/**
 * Base formik configuration/props shared between the HoC and Component.
 */
export declare type FormikSharedConfig<Props = {}, Values = any> = FormikValidationConfig<Values> & {
    /** Tell Formik if initial form values are valid or not on first render */
    isInitialValid?: boolean | ((props: Props) => boolean);
    /** Should Formik reset the form when new initialValues change */
    enableReinitialize?: boolean;
};
/**
 * State, handlers, and helpers made available to form component or render prop
 * of <Formik/>.
 */
export declare type FormikProps<Values> = FormikSharedConfig<Values> & FormikReducerState<Values> & FormikInitialState<Values> & FormikHelpers<Values> & FormikStateHelpers<Values> & FormikFieldHelpers<Values> & FormikHandlers & FormikComputedState & FormikRegistration<Values>;
export declare type FormikResetHandler<Values> = (values: Values, formikHelpers: FormikHelpers<Values>) => void | Promise<any>;
export declare type FormikSubmitHandler<Values> = (values: Values, formikHelpers: FormikHelpers<Values>) => void | Promise<any>;
/**
 * <Formik /> props
 */
export interface FormikConfig<Values> extends FormikSharedConfig {
    /**
     * Form component to render
     */
    component?: React.ComponentType<FormikProps<Values>>;
    /**
     * Render prop (works like React router's <Route render={props =>} />)
     * @deprecated
     */
    render?: (props: FormikProps<Values>) => React.ReactNode;
    /**
     * React children or child render callback
     */
    children?: ((props: FormikProps<Values>) => React.ReactNode) | React.ReactNode;
    /**
     * Initial values of the form
     */
    initialValues: Values;
    /**
     * Initial status
     */
    initialStatus?: any;
    /** Initial object map of field names to specific error for that field */
    initialErrors?: FormikErrors<Values>;
    /** Initial object map of field names to whether the field has been touched */
    initialTouched?: FormikTouched<Values>;
    /**
     * Reset handler
     */
    onReset?: FormikResetHandler<Values>;
    /**
     * Submission handler
     */
    onSubmit: FormikSubmitHandler<Values>;
    /** Inner ref */
    innerRef?: React.Ref<FormikProps<Values>>;
}
/**
 * State, handlers, and helpers made available to Formik's primitive components through context.
 */
export declare type FormikContextType<Values> = FormikApi<Values> & Pick<FormikConfig<Values>, 'validate' | 'validationSchema'>;
export declare type FormikConnectedType<Values> = FormikContextType<Values> & FormikSharedConfig<Values> & FormikState<Values>;
export declare type GenericFieldHTMLAttributes = JSX.IntrinsicElements['input'] | JSX.IntrinsicElements['select'] | JSX.IntrinsicElements['textarea'];
/** Field metadata */
export interface FieldMetaProps<Value> {
    /** Value of the field */
    value: Value;
    /** Error message of the field */
    error?: string;
    /** Has the field been visited? */
    touched: boolean;
    /** Initial value of the field */
    initialValue?: Value;
    /** Initial touched state of the field */
    initialTouched: boolean;
    /** Initial error message of the field */
    initialError?: string;
}
/**
 * @deprecated use `SetFieldTouchedFn`
 */
export declare type SetFieldTouched<Values> = SetFieldTouchedFn<Values>;
/** Imperative handles to change a field's value, error and touched */
export interface FieldHelperProps<Value> {
    /** Set the field's value */
    setValue: (value: Value, shouldValidate?: boolean) => void;
    /** Set the field's touched value */
    setTouched: (value: boolean, shouldValidate?: boolean) => void;
    /** Set the field's error value */
    setError: (value: string | undefined) => void;
}
export declare type FieldOnChangeProp<Value> = (eventOrValue: React.ChangeEvent<any> | Value) => void;
export declare type FieldOnBlurProp = (eventOrValue: React.ChangeEvent<any> | any) => void;
/** Field input value, name, and event handlers */
export declare type FieldInputProps<Value, Values> = {
    /** Value of the field */
    value: SingleValue<Value>;
    /** Name of the field */
    name: PathMatchingValue<Value, Values>;
    /** Multiple select? */
    multiple?: boolean;
    /** Is the field checked? */
    checked?: boolean;
    /** Change event handler */
    onChange: FieldOnChangeProp<Value>;
    /** Blur event handler */
    onBlur: FieldOnBlurProp;
};
export declare type FieldValidationResult = string | void | Promise<string | void>;
export declare type FieldValidator<Value> = (value: Value) => FieldValidationResult | Promise<FieldValidationResult>;
export interface FieldRegistry {
    [field: string]: {
        validate?: FieldValidator<any>;
    };
}
/**
 * If an object has optional properties, force passing undefined.
 * This helps us make sure we are passing back all possible props.
 */
export declare type NotOptional<T> = {
    [Key in keyof Required<T>]: T[Key] extends Required<T[Key]> ? T[Key] : T[Key] | undefined;
};