import { VueConstructor } from 'vue';

declare type Validator = (value: any, props?: Record<string, any>, ...args: any[]) => string | boolean | Promise<string | boolean>;
interface RuleSchema<N = string> {
    validator?: Validator;
    name?: N;
    message?: string;
}
interface ValidationOptions {
    bails?: boolean;
}
declare type ValidationRuleSchema<N = string> = Validator | (RuleSchema<N> & {
    for?: string[];
    cascade?: boolean;
    inherit?: boolean;
});

declare type SchemaValidation = {
    valid: boolean;
    reason?: string;
    infos?: Record<string, string>;
};

declare type EventHandler = (...args: any[]) => any;
declare type EventOptions = {
    noOff?: boolean;
};
declare type EventElement = {
    handlers: EventHandler[];
    options?: EventOptions;
};
declare class Evento {
    events: Record<string, EventElement>;
    constructor();
    emit(name: string, ...args: any[]): Evento;
    once(name: string, handler: EventHandler): Evento;
    on(name: string, handler: EventHandler, options?: EventOptions): Evento;
    off(name: string, handler?: EventHandler): Evento;
}

interface Plugs {
}

declare class Objeto extends Evento {
    protected _d: Record<string, any>;
    protected readonly _config?: Record<string, any>;
    readonly plugs?: Plugs;
}

declare type RuleData = {
    error: string | null;
    valid: boolean;
};
declare class Rule extends Objeto {
    readonly name: string;
    protected _d: RuleData;
    message: string | null;
    validator?: Validator | null;
    constructor(rule: Rule | RuleSchema | Validator);
    get valid(): boolean;
    get error(): string;
    setMessage(message?: string | null): void;
    reset(): void;
    validate(value: any, props?: Record<string, any>, ...args: any[]): Promise<Rule>;
}

declare type ValitionRuleSchema = Validator | RuleSchema;
declare type Options = {
    from?: number;
};
declare class Validation extends Objeto {
    rules: Rule[];
    constructor(rules?: ValitionRuleSchema[]);
    get valid(): boolean;
    get errors(): string[];
    addRules(rulesOrSchemas: (Rule | ValitionRuleSchema)[], { from }?: Options): Rule[];
    removeRules(removes: (Rule | string)[]): Rule[];
    addRule(ruleOrSchema: Rule | ValitionRuleSchema, { from }?: Options): Rule;
    removeRule(remove: Rule | string): Rule;
    reset(): void;
    validate(value: any, options?: {
        excluded?: string[];
        get?: string[];
    }, ...args: any[]): Promise<Validation>;
}

declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
declare type Primitive = string | number | boolean | bigint | symbol | undefined | null;
declare type Builtin = Primitive | FunctionConstructor | Date | Error | RegExp;

declare type ElementOptions = {
    silent?: boolean;
};
interface ElementSchema<I = string> {
    formId?: I;
    model?: I;
    props?: Record<string, any>;
    on?: Record<string, EventHandler>;
    options?: ElementOptions;
    rules?: ValidationRuleSchema<I>[];
}
interface ElementData {
    ancestors: any[] | null;
    schema: any;
    validation: Validation;
    options: ElementOptions;
}
declare type ElementsSchemas<I = string> = FieldSchema<I> | GroupSchema<I> | CollectionSchema<I>;
interface GroupSchema<I = string> extends ElementSchema<I> {
    fields: ElementsSchemas<I>[];
}
interface CollectionSchema<I = string> extends ElementSchema<I> {
    group: Omit<GroupSchema<I>, 'formId'>;
}
declare type FormSchema<I = string> = GroupSchema<I>;
declare type FieldType = 'string' | 'number' | 'boolean' | 'date';
declare type FieldValue = string | number | boolean | Date | null;
declare type Format = string | ((field: any) => string);
interface FieldSchema<I = string> extends ElementSchema<I> {
    type?: FieldType;
    format?: Format;
    default?: any;
    value?: any;
    checkedValue?: any;
}
declare type ReadonlySchema<T> = T extends Builtin ? T : T extends Array<any> ? Readonly<T> : T extends Record<string, any> ? {
    readonly [K in keyof T]: ReadonlySchema<T[K]>;
} : Readonly<T>;

declare abstract class Element extends Objeto {
    static register(options: ElementOptions): void;
    readonly parent: Element | null;
    readonly model: string;
    protected _d: ElementData;
    props: Record<string, any>;
    data: WeakMap<object, any>;
    shaked: boolean;
    abstract isValid(): boolean;
    constructor(schema: ElementSchema, parent?: Element | null);
    get options(): ElementOptions;
    get validation(): Validation;
    get error(): string;
    getProps(path: string, options?: {
        up?: boolean;
    }): any;
    addProps(props: Record<string, any>, ...args: any[]): void;
    get formId(): string;
    get htmlName(): string;
    get valid(): boolean;
    getHtmlName(): string;
    shake(): void;
    cleanUp(): void;
}

declare type GroupData = ElementData & {
    value: Record<string, any> | null;
    pending: boolean;
};
declare class Group extends Element {
    static FORM_TYPE: string;
    static accept(schema: any): SchemaValidation;
    static create(schema: GroupSchema, parent?: Element | null): Group;
    readonly formType: string;
    readonly type: 'enum';
    protected _d: GroupData;
    fields: Element[];
    constructor(schema: GroupSchema, parent?: Element | null);
    get pending(): boolean;
    get value(): Record<string, any>;
    setValue(obj: Record<string, any>): Promise<Record<string, any>>;
    shake({ cascade }?: {
        cascade?: boolean;
    }): void;
    isValid(): boolean;
    reset(): void;
    clear(): Promise<void>;
    validate({ cascade }?: {
        cascade?: boolean;
    }): Promise<void>;
}

declare class Form extends Group {
}

declare type FieldData = ElementData & {
    error: string | null;
    raw: string;
    typed: FieldValue;
    checkedValue: any;
    formatted: string | null;
    pending: boolean;
};
declare class Field extends Element {
    static FORM_TYPE: string;
    static FIELD_TYPE_STRING: string;
    static FIELD_TYPE_NUMBER: string;
    static FIELD_TYPE_BOOLEAN: string;
    static FIELD_TYPE_DATE: string;
    static accept(schema: any): SchemaValidation;
    static create(schema: FieldSchema, parent?: Element | null): Field;
    readonly formType: string;
    readonly type: FieldType;
    readonly default: any;
    protected _d: FieldData;
    constructor(schema: FieldSchema, parent?: Element | null);
    get pending(): boolean;
    get formatted(): string;
    get raw(): any;
    set raw(value: any);
    setRaw(value: any): Promise<void>;
    get value(): any;
    set value(value: any);
    setValue(value: any): Promise<any>;
    setCheckedValue(checkedValue: any): void;
    get checked(): any;
    isValid(): boolean;
    reset(): void;
    clear(): Promise<void>;
    validate(): Promise<void>;
}

declare class CollectionItem extends Group {
    get index(): number;
    get formId(): string;
}
declare type CollectionData = Omit<ElementData, 'schema'> & {
    schema: CollectionSchema;
    value: any[] | null;
    pending: boolean;
};
declare class Collection extends Element {
    static FORM_TYPE: string;
    static accept(schema: any): SchemaValidation;
    static create(schema: CollectionSchema, parent?: Element | null): Collection;
    readonly formType: string;
    readonly type: 'set';
    protected _d: CollectionData;
    groups: CollectionItem[] | null;
    constructor(schema: CollectionSchema, parent?: Element | null);
    get pending(): boolean;
    get value(): any[];
    setValue(value: any[], { from, autoAdd }?: {
        from?: number;
        autoAdd?: boolean;
    }): Promise<any[]>;
    shake({ cascade }?: {
        cascade?: boolean;
    }): void;
    isValid(): boolean;
    reset(): void;
    clear(): Promise<void>;
    addGroup(): CollectionItem;
    removeGroup(itemOrIndex: CollectionItem | number): void;
    validate({ cascade }?: {
        cascade?: boolean;
    }): Promise<void>;
}

declare type VueFormilyConfig = {
    plugs: Plugs;
    elements: any[];
};
interface VueFormilyPlugin {
    install(config: VueFormilyConfig, ...args: any[]): any;
}
declare type Localizer = (value: string, props?: Record<string, any>, data?: Record<string, any>) => string;

declare type ElementInstance = {
    readonly parent: ElementInstance | null;
    readonly model: string;
    props: Record<string, any>;
    data: WeakMap<Record<string, unknown>, any>;
    shaked: boolean;
    readonly options: ElementOptions;
    readonly validation: Validation;
    readonly error: string;
    getProps(path: string, options?: {
        up?: boolean;
    }): any;
    addProps(props: Record<string, any>, ...args: any[]): void;
    readonly formId: string;
    readonly htmlName: string;
    readonly valid: boolean;
    getHtmlName(): string;
    shake(): void;
    cleanUp(): void;
} & {
    plugs: Plugs;
} & Evento;
declare type CustomValidationProperty<R> = R extends Record<string, any> ? {
    [key in R['name']]: Rule;
} : never;
declare type CascadeRule<P, R> = R extends Record<string, unknown> ? R['inherit'] extends false ? R : P extends Record<string, unknown> ? P['cascade'] extends true ? R & P : R : R : P extends Record<string, unknown> ? P['cascade'] extends true ? P : never : never;
declare type CustomVariationProperties<R, E = undefined> = UnionToIntersection<CustomValidationProperty<R extends any[] ? CascadeRule<E extends any[] ? E[number] : E, R[number]> : CascadeRule<E extends any[] ? E[number] : E, R>>> & Validation;
declare type CustomGroupProperty<F, R extends any[]> = F extends Record<string, any> ? {
    [key in F['formId']]: F['fields'] extends Readonly<unknown[]> ? GroupInstance<F, R> : F['group'] extends Readonly<Record<string, unknown>> ? CollectionInstance<F, R> : F extends FieldSchema ? FieldInstance<F, R> : never;
} : never;
declare type CustomGroupProperties<T extends Record<string, any>, R extends any[] = T['rules']> = UnionToIntersection<CustomGroupProperty<T['fields'][number], R>>;
declare type FieldInstance<T extends Readonly<Record<string, any>> = Readonly<Record<string, any>>, R extends Readonly<any[]> = T['rules']> = {
    validation: CustomVariationProperties<T['rules'], R>;
    readonly formType: string;
    readonly type: FieldType;
    readonly default: any;
    readonly pending: boolean;
    readonly formatted: string;
    raw: any;
    setRaw(value: any): Promise<void>;
    value: FieldValue;
    setValue(value: any): Promise<any>;
    setCheckedValue(checkedValue: any): void;
    readonly checked: any;
    isValid(): boolean;
    reset(): void;
    clear(): Promise<void>;
    validate(): Promise<void>;
} & ElementInstance;
declare type GroupInstance<T extends Readonly<Record<string, any>> = Readonly<Record<string, any>>, R extends Readonly<any[]> = T['rules']> = UnionToIntersection<CustomGroupProperties<T>> & {
    validation: CustomVariationProperties<T['rules'], R>;
    fields: T['fields'];
    readonly formType: string;
    readonly type: 'enum';
    readonly pending: boolean;
    readonly value: Record<string, any>;
    setValue(obj: Record<string, any>): Promise<Record<string, any>>;
    shake(options?: {
        cascade?: boolean;
    }): void;
    isValid(): boolean;
    reset(): void;
    clear(): Promise<void>;
    validate(options?: {
        cascade?: boolean;
    }): Promise<void>;
} & ElementInstance;
declare type FormInstance<T extends Readonly<Record<string, any>> = Readonly<Record<string, any>>, R extends Readonly<any[]> = T['rules']> = UnionToIntersection<CustomGroupProperties<T>> & {
    validation: CustomVariationProperties<T['rules'], R>;
    readonly formType: string;
    fields: T['fields'];
    readonly type: 'enum';
    readonly pending: boolean;
    readonly value: Record<string, any>;
    setValue(obj: Record<string, any>): Promise<Record<string, any>>;
    shake(options?: {
        cascade?: boolean;
    }): void;
    isValid(): boolean;
    reset(): void;
    clear(): Promise<void>;
    validate(options?: {
        cascade?: boolean;
    }): Promise<void>;
} & ElementInstance;
declare type CollectionInstance<T extends Readonly<Record<string, any>> = Readonly<Record<string, any>>, R extends Readonly<any[]> = T['rules']> = {
    groups: Array<CollectionItemInstance<T>>;
    validation: CustomVariationProperties<T['rules'], R>;
    readonly formType: string;
    readonly type: 'set';
    readonly pending: boolean;
    readonly value: any[];
    setValue(value: any[], { from, autoAdd }?: {
        from?: number;
        autoAdd?: boolean;
    }): Promise<any[]>;
    shake(options?: {
        cascade?: boolean;
    }): void;
    isValid(): boolean;
    reset(): void;
    clear(): Promise<void>;
    addGroup(): CollectionItemInstance<T>;
    removeGroup(itemOrIndex: CollectionItemInstance<T> | number): void;
    validate(options?: {
        cascade?: boolean;
    }): Promise<void>;
} & ElementInstance;
declare type CollectionItemInstance<T extends Record<string, any>> = T['group'] extends Readonly<Record<string, unknown>> ? CustomGroupProperties<T['group']> & {
    readonly index: number;
} & GroupInstance : Exclude<T['groups'], null> extends any[] ? Exclude<T['groups'], null>[number] : never;

declare type VueFormilyOptions = ElementOptions & {
    rules?: ValidationRuleSchema[];
    alias?: string;
};
declare class Formily {
    options: VueFormilyOptions;
    $root: any;
    constructor(options: VueFormilyOptions, $root: any);
    addForm<F extends ReadonlySchema<FormSchema>>(schema: F): FormInstance<F, F["rules"]>;
    removeForm(formId: string): void;
    getForm<F>(formId: string): F;
}

declare function defineSchema<V extends string, F extends ReadonlySchema<ElementsSchemas<V> | ValidationRuleSchema<V>>>(schema: F): F;

declare module 'vue/types/vue' {
    interface Vue {
        readonly $formily: Formily;
        forms: Record<string, FormInstance>;
    }
}
declare function createFormily(): {
    install(app: VueConstructor, options?: VueFormilyOptions): void;
    plug(plugin: VueFormilyPlugin, ...args: any[]): void;
    register(F: any, ...args: any[]): void;
};
declare const VueFormily: {
    createFormily: typeof createFormily;
};

export default VueFormily;
export { CascadeRule, Collection, CollectionInstance, CollectionItemInstance, CollectionSchema, CustomGroupProperties, CustomGroupProperty, CustomValidationProperty, CustomVariationProperties, ElementData, ElementInstance, ElementOptions, ElementSchema, ElementsSchemas, EventElement, EventHandler, EventOptions, Evento, Field, FieldInstance, FieldSchema, FieldType, FieldValue, Form, FormInstance, FormSchema, Format, Formily, Group, GroupInstance, GroupSchema, Localizer, Objeto, ReadonlySchema, Rule, RuleSchema, Validation, ValidationOptions, ValidationRuleSchema, Validator, VueFormily, VueFormilyConfig, VueFormilyOptions, VueFormilyPlugin, createFormily, defineSchema };