import React from 'react';
import { FormPathPattern } from '@formily/shared';
import { IFieldState, IVirtualFieldState, IMutators, IFormProps, IForm, IFormActions, IFormAsyncActions, IFormEffect } from '@formily/react';
import { ValidatePatternRules } from '@formily/validator';
import { Schema } from './shared/schema';
export * from '@formily/react';
declare global {
    namespace FormilyCore {
        interface FieldProps extends ISchema {
        }
        interface VirtualFieldProps extends ISchema {
        }
    }
}
export interface ISchemaFieldProps {
    path?: FormPathPattern;
    schema?: Schema;
    onlyRenderProperties?: boolean;
}
export declare type ComponentWithStyleComponent<ComponentProps> = React.JSXElementConstructor<ComponentProps> & {
    styledComponentId?: string;
    displayName?: string;
};
export interface ISchemaFieldComponentProps extends IFieldState {
    schema: Schema;
    mutators: IMutators;
    form: IForm;
    renderField: (addtionKey: string | number, reactKey?: string | number) => React.ReactElement;
}
export declare type ISchemaFieldContextProps = Partial<ISchemaFieldComponentProps>;
export interface ISchemaVirtualFieldComponentProps extends IVirtualFieldState {
    schema: Schema;
    form: IForm;
    children: React.ReactElement[];
    renderField: (addtionKey: string | number, reactKey?: string | number) => React.ReactElement;
}
export declare type IVirtualBoxProps<Props> = Props & {
    name?: string;
    visible?: boolean;
    display?: boolean;
};
export interface ISchemaFieldWrapper<Props = any> {
    (Traget: ISchemaFieldComponent): React.FC<Props> | React.ClassicComponent<Props>;
}
export declare type ISchemaFieldComponent = ComponentWithStyleComponent<ISchemaFieldComponentProps> & {
    __WRAPPERS__?: ISchemaFieldWrapper[];
};
export declare type ISchemaVirtualFieldComponent = ComponentWithStyleComponent<ISchemaVirtualFieldComponentProps> & {
    __WRAPPERS__?: ISchemaFieldWrapper[];
};
export declare type ISchemaLinkageHandler = (spec: any, context: any) => IFormEffect<any, ISchemaFormActions>;
export interface ISchemaFormRegistry {
    fields: {
        [key: string]: ISchemaFieldComponent;
    };
    virtualFields: {
        [key: string]: ISchemaVirtualFieldComponent;
    };
    wrappers?: ISchemaFieldWrapper[];
    componentPropsInterceptor?: (schema: ISchema) => any;
    formItemComponent: React.JSXElementConstructor<any>;
    formComponent: string | React.JSXElementConstructor<any>;
    previewText?: React.JSXElementConstructor<any>;
}
export declare type SchemaMessage = React.ReactNode;
export interface ISchema {
    title?: SchemaMessage;
    description?: SchemaMessage;
    default?: any;
    readOnly?: boolean;
    writeOnly?: boolean;
    type?: 'string' | 'object' | 'array' | 'number' | 'boolean' | string;
    enum?: Array<string | number | {
        label: SchemaMessage;
        value: any;
        [key: string]: any;
    } | {
        key: any;
        title: SchemaMessage;
        [key: string]: any;
    }>;
    const?: any;
    multipleOf?: number;
    maximum?: number;
    exclusiveMaximum?: number;
    minimum?: number;
    exclusiveMinimum?: number;
    maxLength?: number;
    minLength?: number;
    pattern?: string | RegExp;
    maxItems?: number;
    minItems?: number;
    uniqueItems?: boolean;
    maxProperties?: number;
    minProperties?: number;
    required?: string[] | boolean | string;
    format?: string;
    properties?: {
        [key: string]: ISchema;
    };
    items?: ISchema | ISchema[];
    additionalItems?: ISchema;
    patternProperties?: {
        [key: string]: ISchema;
    };
    additionalProperties?: ISchema;
    editable?: boolean;
    visible?: boolean | string;
    display?: boolean | string;
    triggerType?: 'onBlur' | 'onChange';
    ['x-props']?: {
        [name: string]: any;
    };
    ['x-index']?: number;
    ['x-rules']?: ValidatePatternRules;
    ['x-linkages']?: Array<{
        target: FormPathPattern;
        type: string;
        [key: string]: any;
    }>;
    ['x-mega-props']?: {
        [name: string]: any;
    };
    ['x-item-props']?: {
        [name: string]: any;
    };
    ['x-component']?: string;
    ['x-component-props']?: {
        [name: string]: any;
    };
    ['x-render']?: <T = ISchemaFieldComponentProps>(props: T & {
        renderComponent: () => React.ReactElement;
    }) => React.ReactElement;
    ['x-effect']?: (dispatch: (type: string, payload: any) => void, option?: object) => {
        [key: string]: any;
    };
}
export interface ISchemaFormProps<Value = any, DefaultValue = any, FormEffectPayload = any, FormActions = ISchemaFormActions | ISchemaFormAsyncActions> extends IFormProps<Value, DefaultValue, FormEffectPayload, FormActions> {
    schema?: ISchema;
    fields?: ISchemaFormRegistry['fields'];
    components?: {
        [key: string]: React.JSXElementConstructor<any>;
    };
    virtualFields?: ISchemaFormRegistry['virtualFields'];
    formComponent?: ISchemaFormRegistry['formComponent'];
    formItemComponent?: ISchemaFormRegistry['formItemComponent'];
    componentPropsInterceptor?: ISchemaFormRegistry['componentPropsInterceptor'];
    expressionScope?: {
        [key: string]: any;
    };
}
export interface IMarkupSchemaFieldProps extends ISchema {
    name?: string;
}
export declare type MergedFieldComponentProps = Partial<ISchemaFieldComponentProps & ISchemaVirtualFieldComponentProps>;
export interface IConnectOptions {
    valueName?: string;
    eventName?: string;
    defaultProps?: {};
    getValueFromEvent?: (event?: any, value?: any) => any;
    getProps?: (componentProps: {}, fieldProps: MergedFieldComponentProps) => {} | void;
    getComponent?: (Target: any, componentProps: {}, fieldProps: MergedFieldComponentProps) => React.JSXElementConstructor<any>;
}
export interface IConnectProps {
    [key: string]: any;
}
export interface ISchemaFormActions extends IFormActions {
    getSchema(): Schema;
    getFormSchema(): Schema;
}
export interface ISchemaFormAsyncActions extends IFormAsyncActions {
    getSchema(): Promise<Schema>;
    getFormSchema(): Promise<Schema>;
}
export declare type MixinConnectedComponent<T extends string> = React.FC<ISchemaFieldComponentProps> & {
    [key in T]: React.FC<ISchemaFieldComponentProps>;
};