/// <reference types="node" />
/// <reference types="react" />
import * as react from 'react';
import { FormEvent, ReactElement, ReactNode, FC, ComponentClass, FormHTMLAttributes, Ref } from 'react';
import { EventEmitter } from 'events';

/**
 *
 */
declare enum PathNodeType {
    OBJECT_KEY = 0,
    ARRAY_INDEX = 1
}
/**
 *
 */
declare type PathNode = [PathNodeType.OBJECT_KEY, string] | [PathNodeType.ARRAY_INDEX, number];
/**
 *
 */
declare type UnparsedPathNode = PathNode | string;
/**
 *
 */
declare type UnparsedPath = Path | PathNode[] | UnparsedPathNode[] | string | null | undefined;
/**
 *
 */
declare class Path {
    static readonly ROOT: Path;
    readonly nodes: PathNode[];
    constructor(nodes: PathNode[]);
    /**
     * True if this path is root (contains no nodes).
     */
    get isRoot(): boolean;
    /**
     * Returns a string
     */
    get pathString(): string;
    /**
     *
     * @param other
     */
    parentOf(other: Path): boolean;
    /**
     *
     * @param other
     */
    equals(other: Path): boolean;
    /**
     *
     * @param nodes
     */
    add(...nodes: PathNode[]): Path;
    /**
     *
     * @param other
     */
    concat(other: Path): Path;
    /**
     *
     * @param start
     * @param end
     */
    slice(start?: number, end?: number): Path;
    /**
     *
     */
    toString(): string;
    /**
     *
     * @param path
     */
    static parse(path: UnparsedPath): Path;
}

declare class Change {
    readonly path: Path;
    readonly value: any;
    constructor(path: Path, value: any);
    static subChanges(changes: Change[], path: Path): Change[];
}

declare type ValidationError = string;
declare type FieldError = [Path, ValidationError[]];
interface ValidationResult<ValueType> {
    valid: boolean;
    value: ValueType;
    errors: FieldError[];
    path: Path;
}
interface IValidator<Values> {
    validateSubmission(values: Values): Promise<ValidationResult<Values>>;
    validateChange<FieldType>(path: Path, value: FieldType, values: Values): Promise<ValidationResult<FieldType>>;
    validateOnBlur<FieldType>(path: Path, value: FieldType, values: Values): Promise<ValidationResult<FieldType>>;
}

declare const CHANGE_EVENT: "change";
declare const ERROR_EVENT: "formerror";
declare const FOCUS_EVENT: "focus";
declare const BLUR_EVENT: "blur";
declare const DO_SUBMIT_EVENT: "dosubmit";
declare const SUBMITTING_EVENT: "submitting";
declare type FormoramaEvents = {
    [CHANGE_EVENT]: [changes: Change[]];
    [ERROR_EVENT]: [errors: FieldError[]];
    [FOCUS_EVENT]: [focusedPath: Path];
    [BLUR_EVENT]: [oldFocus: Path];
    [DO_SUBMIT_EVENT]: [event?: FormEvent<HTMLFormElement>];
    [SUBMITTING_EVENT]: [submitting: boolean];
};
declare type FormEventListener<Event extends keyof Events, Events extends Record<string, any[]> = FormoramaEvents> = (...args: Events[Event]) => void;

declare type ArrayItem<T> = T extends Array<infer S> ? S : never;
declare type NullableValues<T extends Record<any, any>> = {
    [K in keyof T]?: NullableField<T[K]>;
};
declare type NullableField<T> = T extends Record<any, any> ? NullableValues<T> | null : T | null;
declare type ErrorObject<T> = {
    [K in keyof T]?: ErrorField<T[K]>;
} & ({
    [key: string]: ErrorField<unknown>;
} | {});
declare type ErrorField<T> = T extends Record<any, any> ? ErrorObject<T> | string | null : string | null;

interface SubFormProps {
    children?: ReactNode;
    name: string;
}
declare function SubForm<RootValues = any>({ children, name }: SubFormProps): ReactElement;

interface ArrayFormItemProps {
    children?: ReactNode;
    index: number;
}
declare function ArrayFormItem<RootValues = any>({ children, index }: ArrayFormItemProps): ReactElement;

interface ArrayFormItemsChildrenParams<Values> {
    values: Values;
    index: number;
    remove(): void;
}
declare type Component<Props> = FC<Props> | ComponentClass<Props> | string;
declare type ArrayFormItemsRenderOptions<Values> = {
    component?: Component<ArrayFormItemsChildrenParams<Values>>;
} | {
    children?(props: ArrayFormItemsChildrenParams<Values>): ReactNode;
} | {
    renderItem?(props: ArrayFormItemsChildrenParams<Values>): ReactNode;
};
interface ArrayFormItemsProps<ParentValues extends unknown[]> {
    keyExtractor?(values: ArrayItem<ParentValues>, index: number): any;
    getKey?(values: ArrayItem<ParentValues>, index: number): any;
}
declare function ArrayFormItems<ParentValues extends any[] = any[], RootValues = any>({ getKey, keyExtractor: _keyExtractor, ...props }: ArrayFormItemsProps<ParentValues> & ArrayFormItemsRenderOptions<ArrayItem<ParentValues>>): ReactElement;

declare class FormErrors {
    static readonly EMPTY: FormErrors;
    private readonly errors;
    constructor(errors: FieldError[]);
    get(path: Path): ValidationError[];
    subErrors(path: Path): FormErrors;
    compare(nextErrors: FormErrors): FieldError[];
    applyValidationResults(results: ValidationResult<any>[]): FormErrors;
    set(path: Path, errors: ValidationError[]): FormErrors;
    private static errorsEqual;
    private static changeError;
    private static applyResult;
}

interface NormalFormControllerParams {
    maxListeners?: number;
}
interface FormControllerParamsWithLegacyValidate<Values> extends NormalFormControllerParams {
    validate(values: Values): any | Promise<any>;
}
interface FormControllerParamsWithValidator<Values> extends NormalFormControllerParams {
    validator: IValidator<Values>;
}
declare type FormControllerParams<Values> = NormalFormControllerParams | FormControllerParamsWithLegacyValidate<Values> | FormControllerParamsWithValidator<Values>;
declare class FormController<Values = any> extends EventEmitter {
    private values;
    private touched;
    private validator;
    constructor(params?: FormControllerParams<Values>);
    private _errors;
    set errors(errors: FormErrors);
    set params(params: FormControllerParams<Values>);
    private _submitting;
    get submitting(): boolean;
    set submitting(submitting: boolean);
    private _focusing;
    private get focusing();
    private set focusing(value);
    change(path: Path, value: any): Promise<void>;
    changeErrors(path: Path, errors: ValidationError[]): void;
    modify<T>(modifier: (values: T) => T, path?: Path): void;
    focus(path: Path): void;
    blur(path: Path): void;
    submit(): void;
    getValue<T>(path: Path): T;
    getErrors(path: Path): ValidationError[];
    hasTouched(path: Path): boolean;
    isFocusing(path: Path | null): boolean;
    validateSubmission(): Promise<boolean>;
    private validateChanges;
    private validateBlur;
}

interface FormMethods {
    change<T>(uPath: UnparsedPath, value: T): void;
    getValue<T>(uPath: UnparsedPath): T;
    getError(uPath: UnparsedPath): any;
    hasTouched(uPath: UnparsedPath): boolean;
    isFocusing(uPath: UnparsedPath): boolean;
    modify<T>(modifier: (values: NullableField<T>) => NullableField<T>, uPath?: UnparsedPath): void;
    submit(): void;
}

interface FormContextValue<RootValues = any> {
    controller: FormController<RootValues>;
    path: Path;
}
declare const FormContext: react.Context<FormContextValue<any>>;
declare const FormConsumer: react.Consumer<FormContextValue<any>>;

interface UseForm<RootValues = any> extends FormMethods {
    ctx: FormContextValue<RootValues>;
}
declare function useForm<RootValues>(params?: FormControllerParams<RootValues>): UseForm<RootValues>;

interface ErrorExtraResult<Values> {
    values: Values;
    event?: FormEvent<HTMLFormElement>;
}
interface SubmitExtraResult {
    event?: FormEvent<HTMLFormElement>;
}
interface FormTagProps extends Omit<FormHTMLAttributes<HTMLFormElement>, "onSubmit" | "onError" | "form"> {
    noFormTag?: false;
    formRef?: Ref<HTMLFormElement>;
}
interface NoFormTagProps {
    noFormTag: true;
}
declare type FormProps<Values> = {
    form: UseForm<Values>;
    onSubmit?: (values: Values, extra: SubmitExtraResult) => Promise<void> | void;
    onError?: (errors: any, extra: ErrorExtraResult<Values>) => Promise<void> | void;
    children?: ReactNode;
} & (FormTagProps | NoFormTagProps);
declare function Form<Values = any>({ children, form, onSubmit, onError, ...props }: FormProps<Values>): ReactElement;

declare class ImmutableValuesTree<T = any> {
    static readonly EMPTY_OBJECT: ImmutableValuesTree<{}>;
    static readonly EMPTY_ARRAY: ImmutableValuesTree<[]>;
    readonly raw: T;
    constructor(values: T);
    /**
     *
     * @param path
     */
    get(path: Path): any;
    /**
     *
     * @param path
     */
    has(path: Path): boolean;
    /**
     *
     * @param path
     */
    follow<T = any>(path: Path): ImmutableValuesTree<T>;
    /**
     *
     * @param path
     * @param value
     */
    set<T = any>(path: Path, value: any): ImmutableValuesTree<T>;
    /**
     *
     */
    entries(): [Path, any][];
    /**
     *
     * @param other
     */
    compare(other: ImmutableValuesTree): [Path, any][];
    /**
     *
     */
    clean(): ImmutableValuesTree;
    /**
     *
     * @param entries
     * @param tree
     */
    static fromEntries(entries: [Path, any][], tree?: ImmutableValuesTree): ImmutableValuesTree;
    private static getValue;
    private static setValue;
    private static isArray;
    private static isObject;
    private static getEntries;
    private static clean;
    private static cleanFilter;
}

declare class SubmissionError implements Error {
    readonly message = "An error occurred while during the form submission";
    readonly name: string;
    readonly errors: ImmutableValuesTree;
    constructor(errors: any);
}

declare function useFormContext<RootValues = any>(path?: UnparsedPath): UseForm<RootValues>;

interface ChangeListeners {
    onChange(eventOrValue: any): void;
}
interface FocusListeners {
    onFocus(event: any): void;
    onBlur(event: any): void;
}
interface UseInput<ValueType> {
    value: ValueType;
    error: ValidationError | null;
    errors: ValidationError[];
    focused: boolean;
    touched: boolean;
    submitting: boolean;
    listeners: ChangeListeners & FocusListeners;
    changeListeners: ChangeListeners;
    focusListeners: FocusListeners;
    handleChange(eventOrValue: any): void;
    handleError(error: any): void;
    handleFocus(): void;
    handleBlur(): void;
}
declare function useInput<ValueType>(name: string, defaultValue: ValueType): UseInput<ValueType>;

declare type NullableArray<T> = T extends unknown[] ? {
    [K in keyof T]: T[K] | null;
} : never;
declare function useInputValue<Values extends any[] = any[]>(fields: {
    [K in keyof Values]: UnparsedPath;
}, form?: UseForm, uPath?: UnparsedPath): NullableArray<Values>;

declare function useSubmitting(form?: UseForm): boolean;

declare class FormValues<Values = any> {
    readonly values: ImmutableValuesTree<Values>;
    constructor(values: Values);
    change(path: Path, value: any): Change[];
    compare(otherValues: FormValues): Change[];
    apply<T = any>(changes: Change[]): FormValues<T>;
    get<T = any>(path: Path): T;
}

declare const events: {
    CHANGE_EVENT: "change";
    ERROR_EVENT: "formerror";
    FOCUS_EVENT: "focus";
    BLUR_EVENT: "blur";
    DO_SUBMIT_EVENT: "dosubmit";
    SUBMITTING_EVENT: "submitting";
};

export { SubForm as ArrayForm, ArrayFormItem, ArrayFormItems, Change, ErrorField, ErrorObject, Form, FormConsumer, FormContext, FormController, FormControllerParams, FormErrors, FormEventListener, FormValues, FormoramaEvents, IValidator, ImmutableValuesTree, NullableField, NullableValues, Path, SubForm, SubmissionError, UseForm, UseInput, ValidationResult, events, useForm, useFormContext, useInput, useInputValue, useSubmitting };