@qin-ui/antd-vue-pro/es/index.d.ts

二次封装antd vue组件

import { AllowedComponentProps } from 'vue';
import { App } from 'vue';
import { CascaderProps } from 'ant-design-vue';
import { CheckboxGroupProps } from 'ant-design-vue';
import type { ColProps } from 'ant-design-vue';
import { ColSize } from 'ant-design-vue/es/grid';
import { ColumnType } from 'ant-design-vue/es/table';
import { ColumnType as ColumnType_2 } from 'ant-design-vue/es/vc-table/interface';
import { Component } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentOptionsBase } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { CreateComponentPublicInstanceWithMixins } from 'vue';
import type { CSSProperties } from 'vue';
import { DatePickerProps } from 'ant-design-vue';
import type { DeepReadonly } from 'vue';
import { DefineComponent } from 'vue';
import { ExpandedRowRender } from 'ant-design-vue/es/vc-table/interface';
import { ExtractPropTypes } from 'vue';
import { FieldData } from 'ant-design-vue/es/form/interface';
import { FilterValue } from 'ant-design-vue/es/table/interface';
import type { FormItemInstance } from 'ant-design-vue';
import type { FormItemProps } from 'ant-design-vue';
import { FormLabelAlign } from 'ant-design-vue/es/form/interface';
import { FormProps as FormProps_2 } from 'ant-design-vue';
import { GetComponentProps } from 'ant-design-vue/es/vc-table/interface';
import { GetPopupContainer } from 'ant-design-vue/es/table/interface';
import { GetRowKey } from 'ant-design-vue/es/vc-table/interface';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { HTMLAttributes } from 'vue';
import { InjectionKey } from 'vue';
import { InputNumberProps } from 'ant-design-vue';
import { InputProps } from 'ant-design-vue';
import { InternalNamePath } from 'ant-design-vue/es/form/interface';
import { Key } from 'ant-design-vue/es/vc-table/interface';
import { NamePath } from 'ant-design-vue/es/form/interface';
import { PaginationProps } from 'ant-design-vue';
import { PanelRender } from 'ant-design-vue/es/vc-table/interface';
import { Plugin as Plugin_2 } from 'vue';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { RadioGroupProps } from 'ant-design-vue';
import { RangePickerProps } from 'ant-design-vue/es/date-picker';
import { Raw } from 'vue';
import { Ref } from 'vue';
import { RendererElement } from 'vue';
import { RendererNode } from 'vue';
import { RenderExpandIcon } from 'ant-design-vue/es/vc-table/interface';
import { RenderExpandIconProps } from 'ant-design-vue/es/vc-table/interface';
import { RequiredMark } from 'ant-design-vue/es/form/Form';
import { RowClassName } from 'ant-design-vue/es/vc-table/interface';
import type { RowProps } from 'ant-design-vue';
import { RuleObject } from 'ant-design-vue/es/form';
import type { Select } from 'ant-design-vue';
import { SelectProps } from 'ant-design-vue';
import { SliderProps } from 'ant-design-vue';
import { Slot } from 'vue';
import { SorterResult } from 'ant-design-vue/es/table/interface';
import { SortOrder } from 'ant-design-vue/es/table/interface';
import { SwitchProps } from 'ant-design-vue';
import { TableColumnsType } from 'ant-design-vue';
import { TableColumnType } from 'ant-design-vue';
import { TableComponents } from 'ant-design-vue/es/vc-table/interface';
import { TableCurrentDataSource } from 'ant-design-vue/es/table/interface';
import { TableLayout } from 'ant-design-vue/es/vc-table/interface';
import { TableLocale } from 'ant-design-vue/es/table/interface';
import { TablePaginationConfig } from 'ant-design-vue';
import { TableProps } from 'ant-design-vue';
import { TableRowSelection } from 'ant-design-vue/es/table/interface';
import { TableSticky } from 'ant-design-vue/es/vc-table/interface';
import { TextAreaProps } from 'ant-design-vue';
import { TimePickerProps } from 'ant-design-vue';
import { TransferProps } from 'ant-design-vue';
import { TransformCellText } from 'ant-design-vue/es/vc-table/interface';
import { TreeSelectProps } from 'ant-design-vue';
import { ValidateErrorEntity } from 'ant-design-vue/es/form/interface';
import { ValidateMessages } from 'ant-design-vue/es/form/interface';
import { ValidateOptions } from 'ant-design-vue/es/form/interface';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';

declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_2<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_3<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_4<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_5<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_6<T> = T extends undefined ? never : T;

declare type __VLS_Prettify<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_2<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_3<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_4<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_TypePropsToRuntimeProps<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_2<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_2<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_3<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_3<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_4<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_4<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_5<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_5<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_6<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_6<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_WithDefaults<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_2<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_2<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_3<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_3<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_4<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_4<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_3<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type AllowKey<D extends FormData_2> = FlattenKeys<D> | (string & Record<never, never>);

declare type AnyProps<T extends Record<string, any>> = Record<keyof T, any> & Common;

export declare type AppendField<D extends FormData_2 = FormData_2> = (path: Path<D> | undefined, field: Field<D>) => void;

export declare type BaseComponentStringName = Exclude<Field['component'], RenderComponentType | undefined>;

export declare const BaseField: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_3<__VLS_TypePropsToRuntimeProps_3<Props_3>, {
    component: () => VNode<RendererNode, RendererElement, {
        [key: string]: any;
    }>;
    path: string;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    setComponentRef: (el: any) => void;
    fieldChange: () => void;
    fieldBlur: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_3<__VLS_TypePropsToRuntimeProps_3<Props_3>, {
    component: () => VNode<RendererNode, RendererElement, {
        [key: string]: any;
    }>;
    path: string;
}>>> & Readonly<{
    onSetComponentRef?: ((el: any) => any) | undefined;
    onFieldChange?: (() => any) | undefined;
    onFieldBlur?: (() => any) | undefined;
}>, {
    component: "input" | "textarea" | "input-password" | "input-search" | "input-number" | "select" | "cascader" | "date-picker" | "range-picker" | "time-picker" | "checkbox-group" | "radio-group" | "switch" | "slider" | "tree-select" | "transfer" | RenderComponentType | Raw<RenderComponentType>;
    path: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare type BaseFieldAttrs = FieldAttrsType[keyof FieldAttrsType];

export declare const BaseFormItem: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<Props_2>, {
    grid: undefined;
    path: undefined;
    disabled: undefined;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<Props_2>, {
    grid: undefined;
    path: undefined;
    disabled: undefined;
}>>> & Readonly<{}>, {
    disabled: boolean;
    path: string;
    grid: Grid;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare type CascaderSlots = FieldSlot<'clearIcon' | 'expandIcon' | 'maxTagPlaceholder' | 'notFoundContent' | 'removeIcon' | 'suffixIcon' | 'tagRender'>;

declare interface Column<D extends Data = Data> extends Omit<ColumnType, 'dataIndex'> {
    dataIndex: Exclude<keyof D | (string & Record<never, never>), number | symbol>;
}

export declare type Columns<D extends Data = Data> = Array<Column<D>>;

/**
 * @type {Object} Common - 公共字段类型
 */
export declare interface Common<D extends FormData_2 = FormData_2> {
    /** 标识key */
    key?: AllowKey<D>;
    /** 中文名称 */
    label?: SlotComponentType;
    /** 插槽，可包含formItem插槽和component插槽 */
    slots?: Partial<Record<(typeof FORM_ITEM_SLOT_KEYS)[number], SlotComponentType>>;
    /** 网格布局属性 */
    grid?: Grid;
    /** 子字段 */
    fields?: Fields<D>;
    /** 是否隐藏 */
    hidden?: boolean;
    /** formItem样式属性 */
    style?: CSSProperties;
    /** formItem样式类名 */
    className?: string;
    /** formItem容器包裹组件 */
    container?: ContainerComponent;
    /** component样式属性 */
    componentStyle?: CSSProperties;
    /** component样式类名 */
    componentClassName?: string;
    /** component容器包裹组件 */
    componentContainer?: ContainerComponent;
    /**
     * 值处理函数，onUpdateValue前执行，函数返回值将作为更新值, 例如
     * @example (val) => val?.trim()
     */
    valueFormatter?: (val: any) => any;
    /** 是否隐藏校验错误信息（需要浏览器支持has选择器） */
    hideFeedback?: boolean;
    /** 以data-form-item-开头的属性将会被渲染至formItem的dom节点 */
    [key: `data-form-item-${string}`]: string;
    /** 以data-component-开头的属性将会被渲染至component的dom节点 */
    [key: `data-component-${string}`]: string;
}

export declare const COMPONENT_MAP: Map<BaseComponentStringName, Component>;

export declare type ComponentVars = Partial<{
    'pro-table': Partial<TableProps & Pick<ProTableProps, 'showControl' | 'searchFormConfig' | 'paramCache'>>;
    'pro-form': Partial<ProFormProps>;
    'pro-form-item': Partial<ProFormItemProps>;
    'input': Partial<AnyProps<InputProps>>;
    'textarea': Partial<AnyProps<TextAreaProps>>;
    'input-password': Partial<AnyProps<InputProps>>;
    'input-search': Partial<AnyProps<InputProps>>;
    'input-number': Partial<AnyProps<InputNumberProps>>;
    'select': Partial<AnyProps<SelectProps>>;
    'cascader': Partial<AnyProps<CascaderProps>>;
    'date-picker': Partial<AnyProps<DatePickerProps>>;
    'date-picker.date': Partial<AnyProps<DatePickerProps>>;
    'date-picker.week': Partial<AnyProps</* WeekPickerProps */ DatePickerProps>>;
    'date-picker.month': Partial<AnyProps</* MonthPickerProps */ DatePickerProps>>;
    'date-picker.year': Partial<AnyProps<DatePickerProps>>;
    'date-picker.quarter': Partial<AnyProps<DatePickerProps>>;
    'range-picker': Partial<AnyProps<RangePickerProps>>;
    'time-picker': Partial<AnyProps<TimePickerProps>>;
    'checkbox-group': Partial<AnyProps<CheckboxGroupProps>>;
    'radio-group': Partial<AnyProps<RadioGroupProps>>;
    'switch': Partial<AnyProps<SwitchProps>>;
    'slider': Partial<AnyProps<SliderProps>>;
    'tree-select': Partial<AnyProps<TreeSelectProps>>;
    'transfer': Partial<AnyProps<TransferProps>>;
}>;

export declare type ContainerComponent = Component<DefaultProps> | null;

export declare const ContainerFragment: __VLS_WithTemplateSlots_2<DefineComponent<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_4<Props_4>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_4<Props_4>>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    default?(_: {}): any;
}>;

declare type CustomSlots = {
    search(): any;
    buttons(): any;
    table(): any;
};

declare type Data = {
    [key: string]: any;
};

declare type DatePickerSlots = FieldSlot<'dateRender' | 'renderExtraFooter' | 'separator' | 'monthCellRender'>;

declare const _default: {
    install(app: App): void;
};
export default _default;

declare const _default_2: __VLS_WithTemplateSlots<DefineComponent<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
    form: () => {};
    grid: boolean;
}>>, {
    resetFields: (name?: NamePath | undefined) => void;
    clearValidate: (name?: NamePath | undefined) => void;
    validateFields: (nameList?: string | NamePath[] | undefined, options?: ValidateOptions | undefined) => Promise<{
        [key: string]: any;
    }>;
    getFieldsValue: (nameList?: true | InternalNamePath[] | undefined) => {
        [key: string]: any;
    };
    validate: (nameList?: string | NamePath[] | undefined, options?: ValidateOptions | undefined) => Promise<{
        [key: string]: any;
    }>;
    scrollToField: (name: NamePath, options?: {} | undefined) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
    form: () => {};
    grid: boolean;
}>>> & Readonly<{}>, {
    grid: Grid;
    form: Partial<Form>;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
    default?(_: {}): any;
}>;

declare const _default_3: __VLS_WithTemplateSlots_3<DefineComponent<ExtractPropTypes<__VLS_WithDefaults_4<__VLS_TypePropsToRuntimeProps_6<Props_6>, {
    table: undefined;
    addIndexColumn: boolean;
    showControl: boolean;
    searchContainer: {
        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
        $slots: {
            default?(_: {}): any;
        };
    });
    controlContainer: {
        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
        $slots: {
            default?(_: {}): any;
        };
    });
    tableContainer: {
        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
        $slots: {
            default?(_: {}): any;
        };
    });
    paramCache: undefined;
    immediateSearch: boolean;
    searchFormConfig: undefined;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
    search: (param: Partial<{
        [key: string]: any;
    } & Record<string, any>> & Pick<Partial<ExtractPropTypes<{
        total: NumberConstructor;
        defaultCurrent: NumberConstructor;
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        current: NumberConstructor;
        defaultPageSize: NumberConstructor;
        pageSize: NumberConstructor;
        hideOnSinglePage: {
            type: BooleanConstructor;
            default: boolean;
        };
        showSizeChanger: {
            type: BooleanConstructor;
            default: boolean;
        };
        pageSizeOptions: {
            type: PropType<(string | number)[]>;
            default: (string | number)[];
        };
        buildOptionText: {
            type: PropType<(opt: {
                value: any;
            }) => any>;
            default: (opt: {
                value: any;
            }) => any;
        };
        showQuickJumper: {
            type: PropType<boolean | {
                goButton?: any;
            }>;
            default: boolean | {
                goButton?: any;
            };
        };
        showTotal: {
            type: PropType<(total: number, range: [number, number]) => any>;
            default: (total: number, range: [number, number]) => any;
        };
        size: {
            type: PropType<"small" | "default">;
            default: "small" | "default";
        };
        simple: {
            type: BooleanConstructor;
            default: boolean;
        };
        locale: ObjectConstructor;
        prefixCls: StringConstructor;
        selectPrefixCls: StringConstructor;
        totalBoundaryShowSizeChanger: NumberConstructor;
        selectComponentClass: StringConstructor;
        itemRender: {
            type: PropType<(opt: {
                page: number;
                type: "page" | "prev" | "next" | "jump-prev" | "jump-next";
                originalElement: any;
            }) => any>;
            default: (opt: {
                page: number;
                type: "page" | "prev" | "next" | "jump-prev" | "jump-next";
                originalElement: any;
            }) => any;
        };
        role: StringConstructor;
        responsive: BooleanConstructor;
        showLessItems: {
            type: BooleanConstructor;
            default: boolean;
        };
        onChange: {
            type: PropType<(page: number, pageSize: number) => void>;
            default: (page: number, pageSize: number) => void;
        };
        onShowSizeChange: {
            type: PropType<(current: number, size: number) => void>;
            default: (current: number, size: number) => void;
        };
        'onUpdate:current': {
            type: PropType<(current: number) => void>;
            default: (current: number) => void;
        };
        'onUpdate:pageSize': {
            type: PropType<(size: number) => void>;
            default: (size: number) => void;
        };
    }>>, "current" | "pageSize">) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_4<__VLS_TypePropsToRuntimeProps_6<Props_6>, {
    table: undefined;
    addIndexColumn: boolean;
    showControl: boolean;
    searchContainer: {
        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
        $slots: {
            default?(_: {}): any;
        };
    });
    controlContainer: {
        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
        $slots: {
            default?(_: {}): any;
        };
    });
    tableContainer: {
        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
        $slots: {
            default?(_: {}): any;
        };
    });
    paramCache: undefined;
    immediateSearch: boolean;
    searchFormConfig: undefined;
}>>> & Readonly<{
    onSearch?: ((param: Partial<{
        [key: string]: any;
    } & Record<string, any>> & Pick<Partial<ExtractPropTypes<{
        total: NumberConstructor;
        defaultCurrent: NumberConstructor;
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        current: NumberConstructor;
        defaultPageSize: NumberConstructor;
        pageSize: NumberConstructor;
        hideOnSinglePage: {
            type: BooleanConstructor;
            default: boolean;
        };
        showSizeChanger: {
            type: BooleanConstructor;
            default: boolean;
        };
        pageSizeOptions: {
            type: PropType<(string | number)[]>;
            default: (string | number)[];
        };
        buildOptionText: {
            type: PropType<(opt: {
                value: any;
            }) => any>;
            default: (opt: {
                value: any;
            }) => any;
        };
        showQuickJumper: {
            type: PropType<boolean | {
                goButton?: any;
            }>;
            default: boolean | {
                goButton?: any;
            };
        };
        showTotal: {
            type: PropType<(total: number, range: [number, number]) => any>;
            default: (total: number, range: [number, number]) => any;
        };
        size: {
            type: PropType<"small" | "default">;
            default: "small" | "default";
        };
        simple: {
            type: BooleanConstructor;
            default: boolean;
        };
        locale: ObjectConstructor;
        prefixCls: StringConstructor;
        selectPrefixCls: StringConstructor;
        totalBoundaryShowSizeChanger: NumberConstructor;
        selectComponentClass: StringConstructor;
        itemRender: {
            type: PropType<(opt: {
                page: number;
                type: "page" | "prev" | "next" | "jump-prev" | "jump-next";
                originalElement: any;
            }) => any>;
            default: (opt: {
                page: number;
                type: "page" | "prev" | "next" | "jump-prev" | "jump-next";
                originalElement: any;
            }) => any;
        };
        role: StringConstructor;
        responsive: BooleanConstructor;
        showLessItems: {
            type: BooleanConstructor;
            default: boolean;
        };
        onChange: {
            type: PropType<(page: number, pageSize: number) => void>;
            default: (page: number, pageSize: number) => void;
        };
        onShowSizeChange: {
            type: PropType<(current: number, size: number) => void>;
            default: (current: number, size: number) => void;
        };
        'onUpdate:current': {
            type: PropType<(current: number) => void>;
            default: (current: number) => void;
        };
        'onUpdate:pageSize': {
            type: PropType<(size: number) => void>;
            default: (size: number) => void;
        };
    }>>, "current" | "pageSize">) => any) | undefined;
}>, {
    table: {
        dataSource: Ref<{
            [key: string]: any;
        }[], {
            [key: string]: any;
        }[]>;
        columns: Ref<Columns<{
            [key: string]: any;
        }>, Columns<{
            [key: string]: any;
        }>>;
        showColumnKeys: Ref<string[], string[]>;
        searchParam: Ref<Partial<{
            [key: string]: any;
        } & Record<string, any>>, Partial<{
            [key: string]: any;
        } & Record<string, any>>>;
        searchFields: Ref<Fields<Partial<{
            [key: string]: any;
        }>>, Fields<Partial<{
            [key: string]: any;
        }>>>;
        pagination: Ref<Partial<ExtractPropTypes<{
            total: NumberConstructor;
            defaultCurrent: NumberConstructor;
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            current: NumberConstructor;
            defaultPageSize: NumberConstructor;
            pageSize: NumberConstructor;
            hideOnSinglePage: {
                type: BooleanConstructor;
                default: boolean;
            };
            showSizeChanger: {
                type: BooleanConstructor;
                default: boolean;
            };
            pageSizeOptions: {
                type: PropType<(string | number)[]>;
                default: (string | number)[];
            };
            buildOptionText: {
                type: PropType<(opt: {
                    value: any;
                }) => any>;
                default: (opt: {
                    value: any;
                }) => any;
            };
            showQuickJumper: {
                type: PropType<boolean | {
                    goButton?: any;
                }>;
                default: boolean | {
                    goButton?: any;
                };
            };
            showTotal: {
                type: PropType<(total: number, range: [number, number]) => any>;
                default: (total: number, range: [number, number]) => any;
            };
            size: {
                type: PropType<"small" | "default">;
                default: "small" | "default";
            };
            simple: {
                type: BooleanConstructor;
                default: boolean;
            };
            locale: ObjectConstructor;
            prefixCls: StringConstructor;
            selectPrefixCls: StringConstructor;
            totalBoundaryShowSizeChanger: NumberConstructor;
            selectComponentClass: StringConstructor;
            itemRender: {
                type: PropType<(opt: {
                    page: number;
                    type: "page" | "prev" | "next" | "jump-prev" | "jump-next";
                    originalElement: any;
                }) => any>;
                default: (opt: {
                    page: number;
                    type: "page" | "prev" | "next" | "jump-prev" | "jump-next";
                    originalElement: any;
                }) => any;
            };
            role: StringConstructor;
            responsive: BooleanConstructor;
            showLessItems: {
                type: BooleanConstructor;
                default: boolean;
            };
            onChange: {
                type: PropType<(page: number, pageSize: number) => void>;
                default: (page: number, pageSize: number) => void;
            };
            onShowSizeChange: {
                type: PropType<(current: number, size: number) => void>;
                default: (current: number, size: number) => void;
            };
            'onUpdate:current': {
                type: PropType<(current: number) => void>;
                default: (current: number) => void;
            };
            'onUpdate:pageSize': {
                type: PropType<(size: number) => void>;
                default: (size: number) => void;
            };
        }>>, Partial<ExtractPropTypes<{
            total: NumberConstructor;
            defaultCurrent: NumberConstructor;
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            current: NumberConstructor;
            defaultPageSize: NumberConstructor;
            pageSize: NumberConstructor;
            hideOnSinglePage: {
                type: BooleanConstructor;
                default: boolean;
            };
            showSizeChanger: {
                type: BooleanConstructor;
                default: boolean;
            };
            pageSizeOptions: {
                type: PropType<(string | number)[]>;
                default: (string | number)[];
            };
            buildOptionText: {
                type: PropType<(opt: {
                    value: any;
                }) => any>;
                default: (opt: {
                    value: any;
                }) => any;
            };
            showQuickJumper: {
                type: PropType<boolean | {
                    goButton?: any;
                }>;
                default: boolean | {
                    goButton?: any;
                };
            };
            showTotal: {
                type: PropType<(total: number, range: [number, number]) => any>;
                default: (total: number, range: [number, number]) => any;
            };
            size: {
                type: PropType<"small" | "default">;
                default: "small" | "default";
            };
            simple: {
                type: BooleanConstructor;
                default: boolean;
            };
            locale: ObjectConstructor;
            prefixCls: StringConstructor;
            selectPrefixCls: StringConstructor;
            totalBoundaryShowSizeChanger: NumberConstructor;
            selectComponentClass: StringConstructor;
            itemRender: {
                type: PropType<(opt: {
                    page: number;
                    type: "page" | "prev" | "next" | "jump-prev" | "jump-next";
                    originalElement: any;
                }) => any>;
                default: (opt: {
                    page: number;
                    type: "page" | "prev" | "next" | "jump-prev" | "jump-next";
                    originalElement: any;
                }) => any;
            };
            role: StringConstructor;
            responsive: BooleanConstructor;
            showLessItems: {
                type: BooleanConstructor;
                default: boolean;
            };
            onChange: {
                type: PropType<(page: number, pageSize: number) => void>;
                default: (page: number, pageSize: number) => void;
            };
            onShowSizeChange: {
                type: PropType<(current: number, size: number) => void>;
                default: (current: number, size: number) => void;
            };
            'onUpdate:current': {
                type: PropType<(current: number) => void>;
                default: (current: number) => void;
            };
            'onUpdate:pageSize': {
                type: PropType<(size: number) => void>;
                default: (size: number) => void;
            };
        }>>>;
    } & {
        setSearchParam: SetFormData;
        setSearchField: SetField;
        getSearchField: GetField;
        setShowColumnKeys: (val: string[]) => void;
        setPagination: (val: Partial<ExtractPropTypes<{
            total: NumberConstructor;
            defaultCurrent: NumberConstructor;
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            current: NumberConstructor;
            defaultPageSize: NumberConstructor;
            pageSize: NumberConstructor;
            hideOnSinglePage: {
                type: BooleanConstructor;
                default: boolean;
            };
            showSizeChanger: {
                type: BooleanConstructor;
                default: boolean;
            };
            pageSizeOptions: {
                type: PropType<(string | number)[]>;
                default: (string | number)[];
            };
            buildOptionText: {
                type: PropType<(opt: {
                    value: any;
                }) => any>;
                default: (opt: {
                    value: any;
                }) => any;
            };
            showQuickJumper: {
                type: PropType<boolean | {
                    goButton?: any;
                }>;
                default: boolean | {
                    goButton?: any;
                };
            };
            showTotal: {
                type: PropType<(total: number, range: [number, number]) => any>;
                default: (total: number, range: [number, number]) => any;
            };
            size: {
                type: PropType<"small" | "default">;
                default: "small" | "default";
            };
            simple: {
                type: BooleanConstructor;
                default: boolean;
            };
            locale: ObjectConstructor;
            prefixCls: StringConstructor;
            selectPrefixCls: StringConstructor;
            totalBoundaryShowSizeChanger: NumberConstructor;
            selectComponentClass: StringConstructor;
            itemRender: {
                type: PropType<(opt: {
                    page: number;
                    type: "page" | "prev" | "next" | "jump-prev" | "jump-next";
                    originalElement: any;
                }) => any>;
                default: (opt: {
                    page: number;
                    type: "page" | "prev" | "next" | "jump-prev" | "jump-next";
                    originalElement: any;
                }) => any;
            };
            role: StringConstructor;
            responsive: BooleanConstructor;
            showLessItems: {
                type: BooleanConstructor;
                default: boolean;
            };
            onChange: {
                type: PropType<(page: number, pageSize: number) => void>;
                default: (page: number, pageSize: number) => void;
            };
            onShowSizeChange: {
                type: PropType<(current: number, size: number) => void>;
                default: (current: number, size: number) => void;
            };
            'onUpdate:current': {
                type: PropType<(current: number) => void>;
                default: (current: number) => void;
            };
            'onUpdate:pageSize': {
                type: PropType<(size: number) => void>;
                default: (size: number) => void;
            };
        }>>) => void;
        resetQueryParams: () => void;
    };
    addIndexColumn: boolean;
    showControl: boolean;
    searchContainer: ContainerComponent;
    controlContainer: ContainerComponent;
    tableContainer: ContainerComponent;
    paramCache: ParamCache | null;
    immediateSearch: boolean;
    searchFormConfig: {
        layout?: "grid" | "inline" | undefined;
        minExpandRows?: number | undefined;
        defaultExpandStatus?: boolean | undefined;
    };
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, Readonly<CustomSlots & Readonly<{
    emptyText?: any;
    expandIcon?: Slot<RenderExpandIconProps<any> | undefined> | undefined;
    title?: any;
    footer?: any;
    summary?: any;
    expandedRowRender?: any;
    expandColumnTitle?: any;
    bodyCell?: ((props: {
        text: any;
        value: any;
        record: Record<string, any>;
        index: number;
        column: ColumnType<any>;
    }) => void) | undefined;
    headerCell?: ((props: {
        title: any;
        column: ColumnType<any>;
    }) => void) | undefined;
    customFilterIcon?: any;
    customFilterDropdown?: any;
    default: any;
}>> & CustomSlots & Readonly<{
    emptyText?: any;
    expandIcon?: Slot<RenderExpandIconProps<any> | undefined> | undefined;
    title?: any;
    footer?: any;
    summary?: any;
    expandedRowRender?: any;
    expandColumnTitle?: any;
    bodyCell?: ((props: {
        text: any;
        value: any;
        record: Record<string, any>;
        index: number;
        column: ColumnType<any>;
    }) => void) | undefined;
    headerCell?: ((props: {
        title: any;
        column: ColumnType<any>;
    }) => void) | undefined;
    customFilterIcon?: any;
    customFilterDropdown?: any;
    default: any;
}>>;

declare type DefaultProps = {
    path?: string;
    [key: string]: any;
};

export declare type DeleteField<D extends FormData_2 = FormData_2> = (path: Path<D>, options?: UpdateFieldOptions) => void;

declare type ExtendWithAny<D> = D extends object ? {
    [K in keyof D]: ExtendWithAny<D[K]>;
} & {
    [key: string]: any;
} : D;

export declare type Field<D extends FormData_2 = FormData_2> = FieldType[keyof FieldType] & Omit<FormItemProps, 'label'> & ColProps & Common<D>;

declare type FieldAttrsType = {
    [key in keyof FieldType]: FieldType[key] & Pick<Common, 'slots' | 'componentStyle' | 'componentClassName' | 'componentContainer'>;
};

export declare type Fields<D extends FormData_2 = FormData_2> = Array<Field<D>>;

declare type FieldSlot<T extends string> = Partial<Record<T, SlotComponentType>>;

/**
 * @type {FieldType} 字段类型集合
 */
export declare type FieldType = {
    /** 文本框 */
    'input': {
        component: 'input';
        slots?: InputSlots;
    } & InputProps;
    /** 文本域 */
    'textarea': {
        component: 'textarea';
        slots?: InputSlots;
    } & TextAreaProps;
    /** 文本框-密码 */
    'input-password': {
        component: 'input-password';
        slots?: InputSlots;
    } & InputProps;
    /** 文本框-搜索 */
    'input-search': {
        component: 'input-search';
        slots?: InputSlots;
    } & InputProps;
    /** 数字文本框 */
    'input-number': {
        component: 'input-number';
        slots?: InputNumberSlots;
    } & InputNumberProps;
    /** 下拉选择器 */
    'select': {
        component: 'select';
        slots?: SelectSlots;
    } & SelectProps;
    /** 级联选择器 */
    'cascader': {
        component: 'cascader';
        slots?: CascaderSlots;
    } & CascaderProps;
    /** 日期选择器 */
    'date-picker': {
        component: 'date-picker';
        slots?: DatePickerSlots;
    } & DatePickerProps;
    /** 日期选择器-范围 */
    'range-picker': {
        component: 'range-picker';
        slots?: RangePickerSlots;
    } & RangePickerProps;
    /** 时间选择器 */
    'time-picker': {
        component: 'time-picker';
        slots?: TimePickerSlots;
    } & TimePickerProps;
    /** 复选框组 */
    'checkbox-group': {
        component: 'checkbox-group';
    } & CheckboxGroupProps;
    /** 单选框组 */
    'radio-group': {
        component: 'radio-group';
    } & RadioGroupProps;
    /** 开关 */
    'switch': {
        component: 'switch';
        slots?: SwitchSlots;
    } & SwitchProps;
    /** 滑块 */
    'slider': {
        component: 'slider';
        slots?: SliderSlots;
    } & SliderProps;
    /** 树形选择器 */
    'tree-select': {
        component: 'tree-select';
        slots?: TreeSelectSlots;
    } & TreeSelectProps;
    /** 穿梭框 */
    'transfer': {
        component: 'transfer';
        slots?: TransferSlots;
    } & TransferProps;
    /** 自定义组件 */
    'custom': {
        component?: RenderComponentType | Raw<RenderComponentType>;
        slots?: Slots;
    } & Record<string, any>;
};

export declare type FindBy<D extends FormData_2 = FormData_2> = (field: Readonly<Field<D>>) => boolean;

declare type FlattenKeys<T, P extends string = ''> = T extends FormData_2 ? {
    [K in keyof KnownKeys<T>]: K extends string ? KnownKeys<T>[K] extends any[] ? `${P}${K}` | K : `${P}${K}` | K | FlattenKeys<T[K], `${P}${K}.`> extends infer U ? U extends `${infer V}.` ? V : U : never : never;
}[keyof KnownKeys<T>] : P;

export declare type Form<D extends FormData_2 = FormData_2> = ReturnType<UseFormData<D>> & ReturnType<UseFields<D>> & ReturnType<UseFormRef>;

export declare const FORM_DATA: InjectionKey<Record<string, any>>;

export declare const FORM_ITEM_SLOT_KEYS: readonly ["label", "extra", "help", "tooltip"];

declare type FormData_2 = {
    [key: string]: any;
};
export { FormData_2 as FormData }

declare interface FormProps extends FormProps_2 {
    scrollToFirstError?: boolean | Record<string, any>;
}

export declare type GetField<D extends FormData_2 = FormData_2> = (path?: Path<D>) => Readonly<WithRefGetter<Field<D>>> | undefined;

export declare type GetFieldPath<D extends FormData_2 = FormData_2> = (path: Path<D>) => string | undefined;

export declare type GetFormData<D extends FormData_2 = FormData_2> = (path?: Path<D>) => DeepReadonly<any>;

export declare type GetParentFields<D extends FormData_2 = FormData_2> = (path: Path<D>) => Fields<D> | undefined;

export declare type Grid = boolean | RowProps;

export declare const INIT_PROPS_MAP: Map<symbol, {
    maxlength?: undefined;
    allowClear?: undefined;
    placeholder?: undefined;
    autoSize?: undefined;
    showCount?: undefined;
    max?: undefined;
    min?: undefined;
    controls?: undefined;
    getPopupContainer?: undefined;
} | {
    maxlength: number;
    allowClear: boolean;
    placeholder: string;
    autoSize?: undefined;
    showCount?: undefined;
    max?: undefined;
    min?: undefined;
    controls?: undefined;
    getPopupContainer?: undefined;
} | {
    maxlength: number;
    autoSize: {
        minRows: number;
        maxRows: number;
    };
    showCount: boolean;
    allowClear: boolean;
    placeholder: string;
    max?: undefined;
    min?: undefined;
    controls?: undefined;
    getPopupContainer?: undefined;
} | {
    max: number;
    min: number;
    controls: boolean;
    allowClear: boolean;
    placeholder: string;
    maxlength?: undefined;
    autoSize?: undefined;
    showCount?: undefined;
    getPopupContainer?: undefined;
} | {
    allowClear: boolean;
    placeholder: string;
    getPopupContainer: (triggerNode: any) => any;
    maxlength?: undefined;
    autoSize?: undefined;
    showCount?: undefined;
    max?: undefined;
    min?: undefined;
    controls?: undefined;
} | {
    allowClear: boolean;
    getPopupContainer: (triggerNode: any) => any;
    maxlength?: undefined;
    placeholder?: undefined;
    autoSize?: undefined;
    showCount?: undefined;
    max?: undefined;
    min?: undefined;
    controls?: undefined;
}>;

export declare const INJECT_KEYS: Record<keyof ComponentVars, symbol>;

declare type InputNumberSlots = FieldSlot<'addonAfter' | 'addonBefore' | 'prefix' | 'upIcon' | 'downIcon'>;

declare type InputSlots = FieldSlot<'addonAfter' | 'addonBefore' | 'clearIcon' | 'prefix' | 'suffix'>;

declare type KnownKeys<T> = {
    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
};

declare type Option_2 = {
    label: string;
    value: any;
    [x: string]: any;
};

export declare type Options = Array<Option_2>;

export declare type ParamCache = {
    get(): any;
    set(val: Data | ((v: Data) => Data)): void;
};

declare type Path<D extends FormData_2 = FormData_2> = AllowKey<D>;

export declare type PrependField<D extends FormData_2 = FormData_2> = (path: Path<D> | undefined, field: Field<D>) => void;

export declare const ProComponentProvider: SFCWithInstall<{
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
        componentVars: {
            type: PropType<Partial<{
                'pro-table': Partial<TableProps<any> & Pick<Partial<{
                    table: {
                        dataSource: Ref<{
                            [key: string]: any;
                        }[], {
                            [key: string]: any;
                        }[]>;
                        columns: Ref<Columns<{
                            [key: string]: any;
                        }>, Columns<{
                            [key: string]: any;
                        }>>;
                        showColumnKeys: Ref<string[], string[]>;
                        searchParam: Ref<Partial<{
                            [key: string]: any;
                        } & Record<string, any>>, Partial<{
                            [key: string]: any;
                        } & Record<string, any>>>;
                        searchFields: Ref<Fields<Partial<{
                            [key: string]: any;
                        }>>, Fields<Partial<{
                            [key: string]: any;
                        }>>>;
                        pagination: Ref<Partial<ExtractPropTypes<{
                            total: NumberConstructor;
                            defaultCurrent: NumberConstructor;
                            disabled: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            current: NumberConstructor;
                            defaultPageSize: NumberConstructor;
                            pageSize: NumberConstructor;
                            hideOnSinglePage: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            showSizeChanger: {
                                type: BooleanConstructor;
                                d