import * as React from 'react';
import { ValidatorData, ValueMap } from '../../types';
import { BoundComponent } from '../bind';
export declare const FormContext: React.Context<FormApi>;
export interface FormApi {
    clear: Form<any>['clear'];
    reset: Form<any>['reset'];
    validate: Form<any>['validate'];
    isValid: Form<any>['isValid'];
    isPristine: Form<any>['isPristine'];
    getValidatorData: Form<any>['getValidatorData'];
    getValue: Form<any>['getValue'];
    getValues: Form<any>['getValues'];
    setValidatorData: Form<any>['setValidatorData'];
    setValue: Form<any>['setValue'];
    setValues: Form<any>['setValues'];
    onComponentMount: Form<any>['handleComponentMount'];
    onComponentUnmount: Form<any>['handleComponentUnmount'];
    onComponentUpdate: Form<any>['handleComponentUpdate'];
    onComponentBlur: Form<any>['handleComponentBlur'];
    onComponentFocus: Form<any>['handleComponentFocus'];
    registerMirror: Form<any>['registerMirror'];
    unregisterMirror: Form<any>['unregisterMirror'];
    initialValues: FormProps<any>['initialValues'];
    debug?: FormProps<any>['debug'];
}
export interface FormProps<FormFields extends ValueMap> {
    /**
     * Called when the value of a bound form component has been changed.
     * @param {string} componentName name of the component
     * @param {object} value new value
     */
    onChange?: (componentName: keyof FormFields, value: any) => void;
    /**
     * Called when a bound form component has been blurred.
     * @param {string} componentName name of the component
     * @param {object} value current value
     */
    onBlur?: (componentName: keyof FormFields, value: any, event: any) => void;
    /**
     * Called when a bound form component has been focused.
     * @param {string} componentName name of the component
     * @param {object} value current value
     */
    onFocus?: (componentName: keyof FormFields, value: any, event: any) => void;
    /**
     * Called when a component updates
     * @param {string} componentName name of the component
     */
    onUpdate?: (componentName: keyof FormFields) => void;
    /**
     * 	Called when the form is programmatically submitted, or a button with type="submit" is clicked.
     * @param {object} values name/value pairs for all bound form components.
     */
    onSubmit?: (values: FormFields) => void;
    /**
     * 	Called after onSubmit if all bound form components are valid.
     * @param {object} values name/value pairs for all bound form components.
     */
    onValidSubmit?: (values: FormFields) => void;
    /**
     * Called after onSubmit at least 1 bound form component is invalid.x
     * @param {object} values name/value pairs for all bound form components.
     */
    onInvalidSubmit?: (values: FormFields) => void;
    /**
     * A transformer func which allows the final form value to be manipulated.
     * The calculated value that `getValue` would normally return is provided
     * as an argument to this transformer.
     *
     * The returned value will take precedence over the value normally returned
     * by `getValue`. It will also be use for form validation and provided to
     * bound components.  If it is not necessary to modify the value, simply
     * return the provided value and `getValue` will behave as normal.
     */
    valueTransformer?: (componentName: keyof FormFields, value: any) => any;
    /**
     * If you don't want to modify the values, simply return the provided values.
     *
     * A transformer func which is used to manipulate the entire form values to
     * be manipulated. It is calculated after any individual `valueTransformer`'s
     * have been applied.
     *
     * The returned value will take precedence over the value normally returned by
     * `getValues`. If it is not necessary to modify the value, simply return the
     * provided value and `getValue` will behave as normal
     *
     */
    valuesTransformer?: (values: FormFields) => FormFields;
    /**
     * Whether a hidden submit should be rendered within the form. The existence of a
     * `<button type="submit"/>` allows forms to be submitted when the enter key is pressed.
     * However, if you a form which is being submitted programmatically, or it doesn't
     * make sense to show a submit button, setting this to true will allow submit on enter
     * to work.
     * @note this prop has no effect when using `react-native`.
     */
    withHiddenSubmit?: boolean;
    /**
     * If true, a the html form element will not be rendered.
     * @note this prop has no effect when using `react-native`.
     */
    virtual?: boolean;
    /**
     * Whether the form component values should be sticky and retain their value in
     * between component unmounts and mounts. By default, form component state is
     * lost when a component is unmounted.
     */
    sticky?: boolean;
    /**
     * Initial values to be provided to the bound form components. This is useful for
     * populating the form without having to manage all form values. It can be provided
     * asynchronously. The values will be applied if the form components have not been
     * modified. If you need to apply new values to the form, call reset on the form after
     * updating the initialValues.
     */
    initialValues?: FormFields;
    /**
     * Whether the form and its descendent components should log debug messages.
     */
    debug?: boolean;
}
export interface FormComponentState {
    name: string;
    pristine: boolean;
    value?: any;
    validatorData?: ValidatorData;
    instance?: BoundComponent;
}
export declare class Form<FormComponents extends ValueMap = {}> extends React.Component<FormProps<FormComponents>> {
    static defaultProps: FormProps<any>;
    private components;
    private mirrors;
    constructor(props: FormProps<FormComponents>);
    render(): JSX.Element;
    /**
     * programmatically submit the form. If you don't want to manually call this, a button
     * with type submit should be provided to the form. This can be provided in your form
     * implementation, or automatically using the `withHiddenSubmit` prop on the Form.
     * @returns an object with 2 properties:
     *  - isValid: whether the entire form was valid when submitting
     *  - values: all of the form values at the time of submission
     */
    submit: () => {
        isValid: boolean;
        values: FormComponents;
    };
    /**
     * Clears the specified component(s) by setting their value to null. If no component
     * names are provided, all components within the form will be cleared.
     * @param {string|string[]} componentName component name(s) to be cleared
     * @returns a promise which is resolved once the react components have been re-rendered
     */
    clear: (componentName?: keyof FormComponents | (keyof FormComponents)[]) => Promise<void[]>;
    /**
     * Resets the specified component(s) by unsetting their value, validator and pristine
     * state. If no component names are provided, all components within the form will be
     * reset.
     * @param {string|string[]} componentName component name(s) to be reset
     * @returns a promise which is resolved once the react components have been re-rendered
     */
    reset: (componentName?: keyof FormComponents | (keyof FormComponents)[]) => Promise<void[]>;
    /**
     * Validates specified component(s) by executing the validator and updating the
     * components to reflect their validator state. If no component names are provided,
     * all components within the form will be validated.
     * @param {string|string[]} componentName component name(s) to be validated.
     * @returns a promise which is resolved once the react components have been re-rendered.
     */
    validate: (componentName?: keyof FormComponents | (keyof FormComponents)[]) => Promise<void[]>;
    /**
     * Determines if all the specified component(s) are valid by executing the validator
     * using the components current value. If no component names are provided, all
     * components within the form will be tested.
     *
     * Note: if validatorData is being managed, the provided validatorData.context will
     * be used instead of executing the validator.
     *
     * @param {string|string[]} componentName component name(s) to be tested
     * @returns a boolean flag to indicate whether all the components are valid
     */
    isValid: (componentName?: keyof FormComponents | (keyof FormComponents)[]) => boolean;
    /**
     * Determines if all the specified component(s) are pristine - the component has not
     * been modified by the user or by programmatically calling setValue. If no component
     * names are provided, all components within the form will checked.
     * @param {string|string[]} componentName component name(s) to be tested
     * @returns a boolean flag to indicate whether all the components are pristine
     */
    isPristine: (componentName?: keyof FormComponents | (keyof FormComponents)[]) => boolean;
    /**
     * Returns the components current validatorData. There are 2 ways a components
     * validator data can be retrieved (in order of precedence):
     *  1. *externally managed validatorData* prop provided to the component
     *  2. *internally managed validatorData* state when the user changes input
     *
     * **Note**: If the component has no validatorData, then an object with undefined
     * context & message will be returned.
     *
     * @param {string} componentName name of the component to get validator data for
     * @param {object} componentProps component props to extract validator data from.
     *       It's not necessary to provide this prop as its intended to be used by the
     *      form library internally.
     * @returns component validator data
     */
    getValidatorData: (componentName: keyof FormComponents, componentProps?: BoundComponent['props']) => ValidatorData;
    /**
     * Returns the value of the specified component. There are four
     * ways a component value can be provided (in order of precedence):
     *  1. *externally managed* value prop provided to the component
     *  2. *internally managed* state value when the user changes input
     *  3. *initialValues* provided to the form component
     *  4. *defaultValue* specified on individual form component
     *
     * **Note**: the form values should not be mutated
     *
     * @param {string} componentName name of the component to get value for
     * @param {object} componentProps component props to extract value from. It's
     *      not necessary to provide this prop as its intended to be used by the
     *      form library internally.
     * @returns component value
     */
    getValue: (componentName: keyof FormComponents, componentProps?: BoundComponent['props']) => any;
    /**
     * Gets the values of the provided component names using the same logic as
     * `getValue`.
     * @param {string} componentNames component names to retrieve values for
     * @returns an object with componentName:value pairs
     */
    getValues: (componentNames?: (keyof FormComponents)[]) => FormComponents;
    /**
     * Sets the component internally managed validatorData & updates the component
     * to reflect its new state.
     * @param {string} componentName name of the component which should be updated
     * @param {object} validatorData the new validator data to be stored in Form state
     * @returns a promise which is resolved once the react component has been re-rendered.
     */
    setValidatorData: (componentName: keyof FormComponents, data: ValidatorData) => Promise<void>;
    /**
     * Sets the component internally managed state value & updates the component
     * validatorData using the provided value. By default, the components pristine state
     * will be set to `false` to indicate that the component has been modified.
     * @param {string} componentName name of the component to set value for
     * @param {any} value the new value to be stored in Form state
     * @param {boolean} pristine the new pristine state when setting this value (default: false).
     * @param {boolean} internal if true, the handle form change will not be executed
     * @returns a promise which is resolved once the react component has been re-rendered.
     */
    setValue: (componentName: keyof FormComponents, value: any, pristine?: boolean, internal?: boolean) => Promise<void>;
    /**
     * Sets the components internally managed state values & updates their component
     * validatorData using the provided values. By default, the components pristine state
     * will be set to `false` to indicate that the components have been modified.
     * @param {object} values the values to be saved in Form state: componentName:value map
     * @returns a promise which is resolved once the react components have been re-rendered.
     */
    setValues: (values: { [ComponentName in keyof FormComponents]: any; }, pristine?: boolean, internal?: boolean) => Promise<void[]>;
    private isRecursiveComponent;
    /**
     * Registers a component with the form, allowing it to be managed.
     * @param {string} componentName name of the component
     * @param {object} componentRef react component reference to be monitored
     * @returns void
     */
    private registerComponent;
    /**
     * Unregisters a component with the form, so it will no longer be managed
     * @param {string} componentName name of the component
     * @returns void
     */
    private unregisterComponent;
    /**
     * Registers a mirror with the form, allowing it to reflect a component.
     * @param {string} componentName name of the component to mirror
     * @param {object} mirrorRef react mirror reference to be registered
     * @returns void
     */
    private registerMirror;
    /**
     * Unregisters a mirror with the form, so it will no longer reflect
     * @param {string} componentName name of the component to mirror
     * @param {object} mirrorRef react mirror reference to be unregistered
     * @returns void
     */
    private unregisterMirror;
    private handleFormChange;
    private handleFormSubmit;
    private handleFormValidSubmit;
    private handleFormInvalidSubmit;
    private handleComponentMount;
    private handleComponentUnmount;
    private handleComponentUpdate;
    private handleComponentBlur;
    private handleComponentFocus;
    /**
     * Returns an array of mirror instances that are currently reflecting the specified component.
     * @param {string} componentName name of the component
     * @returns array of mirror instances
     */
    private getComponentMirrors;
    /** Helper function for retrieving an array of component names. This is used by
     * functions which can iterate over a single, multiple or all components within
     * the form.
     * * If a singular component name is provided, it will be returned as an array.
     * * If multiple component names are provided, they will be returned unchanged.
     * * If no component names are provided, all component names will be returned.
     * @param {string|string[]} componentName component name(s)
     * @returns array of component names
     */
    private getComponentNames;
    /**
     * Gets the react component instance for the specified component
     * @param {string} componentName name of the component
     * @returns react component instance
     */
    private getComponentInstance;
    /**
     * Gets the react component props for the specified component
     * @param {string} componentName name of the component
     * @returns react component props
     */
    private getComponentProps;
    /**
     * Get an array of component names which should be updated when the
     * specified component is updated..
     * @param {string} componentName name of the component
     * @returns array of component names
     */
    private getComponentValidatorTriggers;
    /**
     * Recursively builds a dependency map for components that are part of the
     * validator trigger tree.
     * @param {string[]} componentNames array of component names to check
     * @param {object} mappedNames while recurseing, a mappedNames object is kept
     * to ensure that a component is not included twice and to ensure that
     * components cannot trigger each other.
     * @returns array of component names which are dependent on the specified
     * component names.
     */
    private getComponentDependencyMap;
    /**
     * Returns an array of component names that should be validated when validating
     * a specific component. Determined using the validator trigger tree.
     * @param {string} componentName name of the component to check
     * @returns array of componentNames
     */
    private getRelatedComponentNames;
    /**
     * Updates the form component state using an update-immutable transform. Once
     * the state has been updated, the react component will be updated to reflect
     * the change.
     * @param {string} componentName name of the component which should be updated
     * @param {object} transform the `update-immutable` transform object
     * @returns a promise which is resolved once the react component has been re-rendered.
     */
    private updateComponent;
    /**
     * Update all the mirrors which are reflecting the specified component
     * @param {string} componentName name of the component which should be reflected
     * @returns a promise which is resolved once all the mirrors have been re-rendered
     */
    private reflectComponentMirrors;
    /**
     * Executes validator for the specified component. If no custom value is provided,
     * the current value will be retrieved from the form component.
     * @param {string} componentName name of the component
     * @param {any} value (optional) custom value to be used when validating
     * @returns validator data: context, message
     */
    private executeValidator;
    logCall: (functionName: string, args?: {
        [argName: string]: any;
    }) => void;
}