import type { ComponentType, ReactElement, ReactNode } from 'react';
import type { FemoModel } from 'femo';
export interface ExtendProps<P = any> {
    extendProps?: P;
}
export declare enum NodeValueType {
    string = "string",
    number = "number",
    boolean = "boolean",
    object = "object",
    array = "array",
    void = "void"
}
declare type NodeValueTypeBak = typeof NodeValueType;
declare type NodeValueTypeObj = {
    [key in NodeValueTypeBak[keyof NodeValueTypeBak]]: any;
};
export declare type NodeValueTypeString = `${keyof NodeValueTypeObj}`;
export interface CommonState<V = any, P = any> extends ExtendProps<P> {
    className?: string;
    initialValue?: V;
    value?: V;
    valueType?: NodeValueTypeString;
    name?: string;
    label?: ReactElement | ReactNode;
    visible?: boolean;
    preserve?: boolean;
    disabled?: boolean;
}
export declare enum ValidateStatus {
    validating = "validating",
    error = "error",
    warn = "warn",
    success = "success",
    default = "default"
}
export interface ErrorInfo<V> {
    node?: FNode;
    message?: ReactNode;
    value?: V;
    validateStatus?: ValidateStatus;
}
export interface SerpentRule<V> {
    required?: boolean;
    message?: string | ReactNode;
    validator?: (value: V, field: FieldInstance<V>, form: FormInstance<any>) => ReactNode | Promise<ReactNode>;
}
export interface FieldState<V = any, P = any> extends CommonState<V, P> {
    errors?: ErrorInfo<V>[];
    validateStatus?: ValidateStatus;
    rules?: SerpentRule<V>[];
    description?: ReactElement | ReactNode;
    [index: string]: any;
}
export interface FormState<V = any, P = any> extends Omit<CommonState<V, P>, 'label'> {
    errors?: ErrorInfo<V>[];
    validateStatus?: ValidateStatus;
    [index: string]: any;
}
export interface SerpentFormItemProps<F extends FieldState = FieldState> {
    children: ReactElement | ReactNode;
    onChange: <A = any>(arg: A) => void;
    fieldState: F;
    id: string;
}
export interface SerpentContextInterface {
    decorator: ComponentType<SerpentFormItemProps>;
    prefix: string;
}
export interface FormContextValue<V = any, S extends FormState<V> = FormState<V>> {
    state: S;
    node: FNode<S>;
}
export interface NodeInstance<P, V = any> {
    state?: P;
    node?: FNode<P>;
    model: FemoModel<P>;
    validate: () => Promise<V>;
    query?: <T = V>(path?: FPath, options?: Omit<QueryFieldInstanceOptions, 'watch'>) => null | FieldInstance<T>;
}
export declare type FormInstance<V = any, S extends FormState<V> = FormState<V>> = NodeInstance<S, V>;
export declare type FieldInstance<V = any, S extends FieldState<V> = FieldState<V>> = NodeInstance<S, V>;
export interface FieldProps<V = any, P = any> extends FieldState<V, P> {
    decorator?: SerpentContextInterface['decorator'];
    onFieldChange?: (state: FieldState<V, P>, prevState: FieldState<V, P>, field: FieldInstance<V, P>) => void;
    onChange?: (value: V) => void;
    [index: string]: any;
}
export interface FormProps<V = any, P = any> extends FormState<V, P> {
    children: any;
    [index: string]: any;
}
export declare type NodeType = 'form' | 'field';
export declare type FPath = string;
export declare enum NodeStatusEnum {
    mount = "mount",
    unmount = "unmount",
    init = "init"
}
export declare type NodeStatus = NodeStatusEnum.mount | NodeStatusEnum.unmount | NodeStatusEnum.init;
export declare enum SearchAction {
    node_change = "node_change",
    node_position_change = "node_position_change",
    node_name_change = "node_name_change",
    node_visible_change = "node_visible_change"
}
export interface FNode<P = any> {
    id?: string;
    type: NodeType;
    valueType: NodeValueTypeString;
    name?: string;
    status?: FemoModel<NodeStatus>;
    searchingPath?: Map<(node: FNode, str: string, action: SearchAction) => void, Set<string>>;
    mountedBy?: number;
    instance?: NodeInstance<P>;
    parent?: FNode<P> | null;
    sibling?: FNode<P> | null;
    child?: FNode<P> | null;
    pushChild?: (field: FNode<P>) => void;
    detach?: () => void;
    validateModel?: FemoModel<any>;
    scrollToField?: (fieldId: string) => void;
}
export interface NodeStateMap<V> {
    form: FormState<V>;
    field: FieldState<V>;
}
export interface NodeInstanceMap<V> {
    form: FormInstance<V>;
    field: FieldInstance<V>;
}
export interface QueryFieldInstanceOptions {
    context?: FNode;
    watch?: boolean;
    watchedKeys?: string | string[];
}
export {};