import type { App } from 'vue';
import type { ArcoOptions } from './_utils/types';
declare const ArcoVue: {
    AnchorLink: import("vue").DefineComponent<{
        title: StringConstructor;
        href: StringConstructor;
    }, {
        prefixCls: string;
        linkCls: string;
        cls: import("vue").ComputedRef<(string | {
            [x: string]: boolean;
        })[]>;
        linkRef: import("vue").Ref<HTMLElement | undefined>;
        handleClick: (e: MouseEvent) => void | undefined;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        title?: unknown;
        href?: unknown;
    } & {} & {
        title?: string | undefined;
        href?: string | undefined;
    }>, {}>;
    AvatarGroup: import("vue").DefineComponent<{
        shape: {
            type: import("vue").PropType<import("./avatar/interface").AvatarShape>;
            default: string;
        };
        size: NumberConstructor;
        autoFixFontSize: {
            type: BooleanConstructor;
            default: boolean;
        };
        maxCount: {
            type: NumberConstructor;
            default: number;
        };
        zIndexAscend: {
            type: BooleanConstructor;
            default: boolean;
        };
        maxStyle: {
            type: import("vue").PropType<import("vue").CSSProperties>;
        };
        maxPopoverTriggerProps: {
            type: import("vue").PropType<import("./trigger").TriggerProps>;
        };
    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        shape?: unknown;
        size?: unknown;
        autoFixFontSize?: unknown;
        maxCount?: unknown;
        zIndexAscend?: unknown;
        maxStyle?: unknown;
        maxPopoverTriggerProps?: unknown;
    } & {
        shape: import("./avatar/interface").AvatarShape;
        autoFixFontSize: boolean;
        maxCount: number;
        zIndexAscend: boolean;
    } & {
        size?: number | undefined;
        maxStyle?: import("vue").CSSProperties | undefined;
        maxPopoverTriggerProps?: import("./trigger").TriggerProps | undefined;
    }>, {
        shape: import("./avatar/interface").AvatarShape;
        autoFixFontSize: boolean;
        maxCount: number;
        zIndexAscend: boolean;
    }>;
    BreadcrumbItem: import("vue").DefineComponent<{
        separator: {
            type: (StringConstructor | NumberConstructor)[];
        };
        droplist: {
            type: import("vue").PropType<{
                label: string;
                path: string;
            }[] | undefined>;
        };
        dropdownProps: {
            type: import("vue").PropType<import("./dropdown").DropDownProps>;
        };
        index: {
            type: NumberConstructor;
            default: number;
        };
    }, () => JSX.Element | null, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        separator?: unknown;
        droplist?: unknown;
        dropdownProps?: unknown;
        index?: unknown;
    } & {
        index: number;
    } & {
        separator?: string | number | undefined;
        droplist?: {
            label: string;
            path: string;
        }[] | undefined;
        dropdownProps?: import("./dropdown").DropDownProps | undefined;
    }>, {
        index: number;
    }>;
    ButtonGroup: import("vue").DefineComponent<{
        type: {
            type: import("vue").PropType<"dashed" | "text" | "outline" | "primary" | "secondary">;
        };
        status: {
            type: import("vue").PropType<"normal" | "success" | "warning" | "danger">;
        };
        shape: {
            type: import("vue").PropType<"round" | "circle" | "square">;
        };
        size: {
            type: import("vue").PropType<"mini" | "medium" | "large" | "small">;
        };
        disabled: {
            type: BooleanConstructor;
        };
    }, {
        prefixCls: string;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        type?: unknown;
        status?: unknown;
        shape?: unknown;
        size?: unknown;
        disabled?: unknown;
    } & {
        disabled: boolean;
    } & {
        size?: "mini" | "medium" | "large" | "small" | undefined;
        type?: "dashed" | "text" | "outline" | "primary" | "secondary" | undefined;
        shape?: "round" | "circle" | "square" | undefined;
        status?: "normal" | "success" | "warning" | "danger" | undefined;
    }>, {
        disabled: boolean;
    }>;
    Calendar: {
        new (...args: any[]): {
            $: import("vue").ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                modelValue: Date;
                defaultMode: "year" | "month";
                modes: ("year" | "month")[];
                allowSelect: boolean;
                panel: boolean;
                panelTodayBtn: boolean;
                dayStartOfWeek: 0 | 1;
                isWeek: boolean;
            }> & Omit<Readonly<{
                modelValue?: unknown;
                defaultValue?: unknown;
                mode?: unknown;
                defaultMode?: unknown;
                modes?: unknown;
                allowSelect?: unknown;
                panel?: unknown;
                panelWidth?: unknown;
                panelTodayBtn?: unknown;
                dayStartOfWeek?: unknown;
                isWeek?: unknown;
            } & {
                defaultMode: "year" | "month";
                modes: ("year" | "month")[];
                allowSelect: boolean;
                panel: boolean;
                panelTodayBtn: boolean;
                dayStartOfWeek: 0 | 1;
                isWeek: boolean;
            } & {
                mode?: "year" | "month" | undefined;
                modelValue?: Date | undefined;
                defaultValue?: Date | undefined;
                panelWidth?: number | undefined;
            }> & {
                onChange?: ((date: Date) => any) | undefined;
                "onUpdate:modelValue"?: ((date: Date) => any) | undefined;
                onPanelChange?: ((date: Date) => any) | undefined;
            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "modelValue" | "defaultMode" | "modes" | "allowSelect" | "panel" | "panelTodayBtn" | "dayStartOfWeek" | "isWeek">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: import("vue").Slot | undefined;
            }>;
            $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
            $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
            $emit: ((event: "update:modelValue", date: Date) => void) & ((event: "change", date: Date) => void) & ((event: "panelChange", date: Date) => void);
            $el: any;
            $options: import("vue").ComponentOptionsBase<Readonly<{
                modelValue?: unknown;
                defaultValue?: unknown;
                mode?: unknown;
                defaultMode?: unknown;
                modes?: unknown;
                allowSelect?: unknown;
                panel?: unknown;
                panelWidth?: unknown;
                panelTodayBtn?: unknown;
                dayStartOfWeek?: unknown;
                isWeek?: unknown;
            } & {
                defaultMode: "year" | "month";
                modes: ("year" | "month")[];
                allowSelect: boolean;
                panel: boolean;
                panelTodayBtn: boolean;
                dayStartOfWeek: 0 | 1;
                isWeek: boolean;
            } & {
                mode?: "year" | "month" | undefined;
                modelValue?: Date | undefined;
                defaultValue?: Date | undefined;
                panelWidth?: number | undefined;
            }> & {
                onChange?: ((date: Date) => any) | undefined;
                "onUpdate:modelValue"?: ((date: Date) => any) | undefined;
                onPanelChange?: ((date: Date) => any) | undefined;
            }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                'update:modelValue': (date: Date) => true;
                change: (date: Date) => true;
                panelChange: (date: Date) => true;
            }, string, {
                modelValue: Date;
                defaultMode: "year" | "month";
                modes: ("year" | "month")[];
                allowSelect: boolean;
                panel: boolean;
                panelTodayBtn: boolean;
                dayStartOfWeek: 0 | 1;
                isWeek: boolean;
            }> & {
                beforeCreate?: ((() => void) | (() => void)[]) | undefined;
                created?: ((() => void) | (() => void)[]) | undefined;
                beforeMount?: ((() => void) | (() => void)[]) | undefined;
                mounted?: ((() => void) | (() => void)[]) | undefined;
                beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
                updated?: ((() => void) | (() => void)[]) | undefined;
                activated?: ((() => void) | (() => void)[]) | undefined;
                deactivated?: ((() => void) | (() => void)[]) | undefined;
                beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
                beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
                destroyed?: ((() => void) | (() => void)[]) | undefined;
                unmounted?: ((() => void) | (() => void)[]) | undefined;
                renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
                renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
                errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void)[]) | undefined;
            };
            $forceUpdate: () => void;
            $nextTick: typeof import("vue").nextTick;
            $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
        } & Readonly<{
            modelValue?: unknown;
            defaultValue?: unknown;
            mode?: unknown;
            defaultMode?: unknown;
            modes?: unknown;
            allowSelect?: unknown;
            panel?: unknown;
            panelWidth?: unknown;
            panelTodayBtn?: unknown;
            dayStartOfWeek?: unknown;
            isWeek?: unknown;
        } & {
            defaultMode: "year" | "month";
            modes: ("year" | "month")[];
            allowSelect: boolean;
            panel: boolean;
            panelTodayBtn: boolean;
            dayStartOfWeek: 0 | 1;
            isWeek: boolean;
        } & {
            mode?: "year" | "month" | undefined;
            modelValue?: Date | undefined;
            defaultValue?: Date | undefined;
            panelWidth?: number | undefined;
        }> & {
            onChange?: ((date: Date) => any) | undefined;
            "onUpdate:modelValue"?: ((date: Date) => any) | undefined;
            onPanelChange?: ((date: Date) => any) | undefined;
        } & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & {} & import("vue").ComponentCustomProperties;
        __isFragment?: undefined;
        __isTeleport?: undefined;
        __isSuspense?: undefined;
    } & import("vue").ComponentOptionsBase<Readonly<{
        modelValue?: unknown;
        defaultValue?: unknown;
        mode?: unknown;
        defaultMode?: unknown;
        modes?: unknown;
        allowSelect?: unknown;
        panel?: unknown;
        panelWidth?: unknown;
        panelTodayBtn?: unknown;
        dayStartOfWeek?: unknown;
        isWeek?: unknown;
    } & {
        defaultMode: "year" | "month";
        modes: ("year" | "month")[];
        allowSelect: boolean;
        panel: boolean;
        panelTodayBtn: boolean;
        dayStartOfWeek: 0 | 1;
        isWeek: boolean;
    } & {
        mode?: "year" | "month" | undefined;
        modelValue?: Date | undefined;
        defaultValue?: Date | undefined;
        panelWidth?: number | undefined;
    }> & {
        onChange?: ((date: Date) => any) | undefined;
        "onUpdate:modelValue"?: ((date: Date) => any) | undefined;
        onPanelChange?: ((date: Date) => any) | undefined;
    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        'update:modelValue': (date: Date) => true;
        change: (date: Date) => true;
        panelChange: (date: Date) => true;
    }, string, {
        modelValue: Date;
        defaultMode: "year" | "month";
        modes: ("year" | "month")[];
        allowSelect: boolean;
        panel: boolean;
        panelTodayBtn: boolean;
        dayStartOfWeek: 0 | 1;
        isWeek: boolean;
    }> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
        install: (app: App<any>, options?: ArcoOptions | undefined) => void;
    };
    CardMeta: import("vue").DefineComponent<{
        title: {
            type: StringConstructor;
        };
        description: {
            type: StringConstructor;
        };
    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        title?: unknown;
        description?: unknown;
    } & {} & {
        title?: string | undefined;
        description?: string | undefined;
    }>, {}>;
    CardGrid: import("vue").DefineComponent<{
        hoverable: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        cls: import("vue").ComputedRef<(string | {
            [x: string]: boolean;
        })[]>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        hoverable?: unknown;
    } & {
        hoverable: boolean;
    } & {}>, {
        hoverable: boolean;
    }>;
    CarouselItem: import("vue").DefineComponent<{}, {
        cls: import("vue").ComputedRef<{
            [x: string]: boolean | "" | undefined;
        }>;
        animationStyle: import("vue").ComputedRef<{
            transitionTimingFunction: string | undefined;
            transitionDuration: string;
            animationTimingFunction: string | undefined;
            animationDuration: string;
        }>;
        isCurrent: import("vue").ComputedRef<boolean>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
    CascaderPanel: import("vue").DefineComponent<{
        pathMode: {
            type: BooleanConstructor;
            default: boolean;
        };
        multiple: {
            type: BooleanConstructor;
            default: boolean;
        };
        modelValue: {
            type: import("vue").PropType<string | number | Record<string, any> | (string | number | Record<string, any> | (string | number | Record<string, any>)[])[] | undefined>;
        };
        defaultValue: {
            type: import("vue").PropType<string | number | Record<string, any> | (string | number | Record<string, any> | (string | number | Record<string, any>)[])[] | undefined>;
            default: (props: import("./_utils/types").Data) => "" | never[] | undefined;
        };
        options: {
            type: import("vue").PropType<import("./cascader").CascaderOption[]>;
            default: () => never[];
        };
        expandTrigger: {
            type: StringConstructor;
            default: string;
        };
        checkStrictly: {
            type: BooleanConstructor;
            default: boolean;
        };
        loadMore: {
            type: import("vue").PropType<(option: import("./cascader").CascaderOption, done: (children?: import("./cascader").CascaderOption[] | undefined) => void) => void>;
        };
        fieldNames: {
            type: import("vue").PropType<import("./_utils/types").FieldString<import("./cascader").CascaderOption>>;
        };
        valueKey: {
            type: StringConstructor;
            default: string;
        };
        expandChild: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        optionInfos: import("vue").Ref<{
            [x: string]: any;
            raw: {
                [x: string]: unknown;
            };
            key: string;
            valueKey: string;
            level: number;
            index: number;
            value: string | number;
            label: string;
            disabled: boolean;
            selectionDisabled: boolean;
            isLeaf: boolean;
            parent?: any | undefined;
            children?: any[] | undefined;
            path: any[];
            pathValue: any[];
            totalLeafOptions?: number | undefined;
            render?: import("vue").RenderFunction | undefined;
            tagProps?: {
                color?: string | undefined;
                size?: "medium" | "large" | "small" | undefined;
                visible?: boolean | undefined;
                defaultVisible?: boolean | undefined;
                loading?: boolean | undefined;
                closable?: boolean | undefined;
                checkable?: boolean | undefined;
                checked?: boolean | undefined;
                defaultChecked?: boolean | undefined;
            } | undefined;
        }[]>;
        filteredLeafOptions: import("vue").ComputedRef<import("./cascader/interface").CascaderOptionInfo[]>;
        selectedPath: import("vue").Ref<string[]>;
        activeKey: import("vue").Ref<string | undefined>;
        displayColumns: import("vue").ComputedRef<import("./cascader/interface").CascaderOptionInfo[][]>;
        handleKeyDown: (event: KeyboardEvent) => void;
        totalLevel: import("vue").Ref<number>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        'update:modelValue': (value: string | number | Record<string, any> | (string | number | Record<string, any> | (string | number | Record<string, any>)[])[] | undefined) => true;
        change: (value: string | number | Record<string, any> | (string | number | Record<string, any> | (string | number | Record<string, any>)[])[] | undefined) => true;
    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        pathMode?: unknown;
        multiple?: unknown;
        modelValue?: unknown;
        defaultValue?: unknown;
        options?: unknown;
        expandTrigger?: unknown;
        checkStrictly?: unknown;
        loadMore?: unknown;
        fieldNames?: unknown;
        valueKey?: unknown;
        expandChild?: unknown;
    } & {
        multiple: boolean;
        defaultValue: string | number | Record<string, any> | (string | number | Record<string, any> | (string | number | Record<string, any>)[])[] | undefined;
        checkStrictly: boolean;
        options: import("./cascader").CascaderOption[];
        pathMode: boolean;
        expandTrigger: string;
        valueKey: string;
        expandChild: boolean;
    } & {
        modelValue?: string | number | Record<string, any> | (string | number | Record<string, any> | (string | number | Record<string, any>)[])[] | undefined;
        fieldNames?: import("./_utils/types").FieldString<import("./cascader").CascaderOption> | undefined;
        loadMore?: ((option: import("./cascader").CascaderOption, done: (children?: import("./cascader").CascaderOption[] | undefined) => void) => void) | undefined;
    }> & {
        onChange?: ((value: string | number | Record<string, any> | (string | number | Record<string, any> | (string | number | Record<string, any>)[])[] | undefined) => any) | undefined;
        "onUpdate:modelValue"?: ((value: string | number | Record<string, any> | (string | number | Record<string, any> | (string | number | Record<string, any>)[])[] | undefined) => any) | undefined;
    }, {
        multiple: boolean;
        defaultValue: string | number | Record<string, any> | (string | number | Record<string, any> | (string | number | Record<string, any>)[])[] | undefined;
        checkStrictly: boolean;
        options: import("./cascader").CascaderOption[];
        pathMode: boolean;
        expandTrigger: string;
        valueKey: string;
        expandChild: boolean;
    }>;
    CheckboxGroup: import("vue").DefineComponent<{
        modelValue: {
            type: import("vue").PropType<(string | number | boolean)[]>;
            default: undefined;
        };
        defaultValue: {
            type: import("vue").PropType<(string | number | boolean)[]>;
            default: () => never[];
        };
        max: {
            type: NumberConstructor;
        };
        options: {
            type: import("vue").PropType<(string | number | import("./checkbox").CheckboxOption)[]>;
        };
        direction: {
            type: import("vue").PropType<"horizontal" | "vertical">;
            default: string;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        'update:modelValue': (value: (string | number | boolean)[]) => true;
        change: (value: (string | number | boolean)[], ev: Event) => true;
    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        modelValue?: unknown;
        defaultValue?: unknown;
        max?: unknown;
        options?: unknown;
        direction?: unknown;
        disabled?: unknown;
    } & {
        disabled: boolean;
        defaultValue: (string | number | boolean)[];
        direction: "horizontal" | "vertical";
    } & {
        modelValue?: (string | number | boolean)[] | undefined;
        max?: number | undefined;
        options?: (string | number | import("./checkbox").CheckboxOption)[] | undefined;
    }> & {
        onChange?: ((value: (string | number | boolean)[], ev: Event) => any) | undefined;
        "onUpdate:modelValue"?: ((value: (string | number | boolean)[]) => any) | undefined;
    }, {
        disabled: boolean;
        modelValue: (string | number | boolean)[];
        defaultValue: (string | number | boolean)[];
        direction: "horizontal" | "vertical";
    }>;
    CollapseItem: import("vue").DefineComponent<{
        key: (StringConstructor | NumberConstructor)[];
        header: StringConstructor;
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        showExpandIcon: {
            type: BooleanConstructor;
            default: boolean;
        };
        destroyOnHide: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        key?: unknown;
        header?: unknown;
        disabled?: unknown;
        showExpandIcon?: unknown;
        destroyOnHide?: unknown;
    } & {
        disabled: boolean;
        showExpandIcon: boolean;
        destroyOnHide: boolean;
    } & {
        key?: string | number | undefined;
        header?: string | undefined;
    }>, {
        disabled: boolean;
        showExpandIcon: boolean;
        destroyOnHide: boolean;
    }>;
    DescriptionsItem: import("vue").DefineComponent<{
        span: {
            type: NumberConstructor;
            default: number;
        };
        label: StringConstructor;
    }, {
        prefixCls: string;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        span?: unknown;
        label?: unknown;
    } & {
        span: number;
    } & {
        label?: string | undefined;
    }>, {
        span: number;
    }>;
    WeekPicker: import("vue").DefineComponent<{
        modelValue: {
            type: import("vue").PropType<string | number | Date>;
        };
        defaultValue: {
            type: import("vue").PropType<string | number | Date>;
        };
        format: {
            type: StringConstructor;
            default: string;
        };
        valueFormat: {
            type: StringConstructor;
            default: string;
        };
        dayStartOfWeek: {
            type: import("vue").PropType<import("./date-picker/interface").WeekStart>;
            default: number;
        };
    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        modelValue?: unknown;
        defaultValue?: unknown;
        format?: unknown;
        valueFormat?: unknown;
        dayStartOfWeek?: unknown;
    } & {
        format: string;
        dayStartOfWeek: import("./date-picker/interface").WeekStart;
        valueFormat: string;
    } & {
        modelValue?: string | number | Date | undefined;
        defaultValue?: string | number | Date | undefined;
    }>, {
        format: string;
        dayStartOfWeek: import("./date-picker/interface").WeekStart;
        valueFormat: string;
    }>;
    MonthPicker: import("vue").DefineComponent<{
        modelValue: {
            type: import("vue").PropType<string | number | Date>;
        };
        defaultValue: {
            type: import("vue").PropType<string | number | Date>;
        };
        format: {
            type: StringConstructor;
            default: string;
        };
    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        modelValue?: unknown;
        defaultValue?: unknown;
        format?: unknown;
    } & {
        format: string;
    } & {
        modelValue?: string | number | Date | undefined;
        defaultValue?: string | number | Date | undefined;
    }>, {
        format: string;
    }>;
    YearPicker: import("vue").DefineComponent<{
        modelValue: {
            type: import("vue").PropType<string | number | Date>;
        };
        defaultValue: {
            type: import("vue").PropType<string | number | Date>;
        };
        format: {
            type: StringConstructor;
            default: string;
        };
    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        modelValue?: unknown;
        defaultValue?: unknown;
        format?: unknown;
    } & {
        format: string;
    } & {
        modelValue?: string | number | Date | undefined;
        defaultValue?: string | number | Date | undefined;
    }>, {
        format: string;
    }>;
    QuarterPicker: import("vue").DefineComponent<{
        modelValue: {
            type: import("vue").PropType<string | number | Date>;
        };
        defaultValue: {
            type: import("vue").PropType<string | number | Date>;
        };
        format: {
            type: StringConstructor;
            default: string;
        };
        valueFormat: {
            type: StringConstructor;
            default: string;
        };
    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        modelValue?: unknown;
        defaultValue?: unknown;
        format?: unknown;
        valueFormat?: unknown;
    } & {
        format: string;
        valueFormat: string;
    } & {
        modelValue?: string | number | Date | undefined;
        defaultValue?: string | number | Date | undefined;
    }>, {
        format: string;
        valueFormat: string;
    }>;
    RangePicker: import("vue").DefineComponent<{
        mode: {
            type: import("vue").PropType<"year" | "month" | "date" | "week" | "quarter">;
            default: string;
        };
        modelValue: {
            type: import("vue").PropType<(string | number | Date)[]>;
        };
        defaultValue: {
            type: import("vue").PropType<(string | number | Date)[]>;
        };
        pickerValue: {
            type: import("vue").PropType<(string | number | Date)[]>;
        };
        defaultPickerValue: {
            type: import("vue").PropType<(string | number | Date)[]>;
        };
        disabled: {
            type: import("vue").PropType<boolean | boolean[]>;
            default: boolean;
        };
        dayStartOfWeek: {
            type: import("vue").PropType<import("./date-picker/interface").WeekStart>;
            default: number;
        };
        format: {
            type: StringConstructor;
        };
        valueFormat: {
            type: import("vue").PropType<string>;
        };
        showTime: {
            type: BooleanConstructor;
        };
        timePickerProps: {
            type: import("vue").PropType<Partial<import("./time-picker/interface").TimePickerProps>>;
        };
        placeholder: {
            type: import("vue").PropType<string[]>;
        };
        disabledDate: {
            type: import("vue").PropType<(current: Date, type: "end" | "start") => boolean>;
        };
        disabledTime: {
            type: import("vue").PropType<(current: Date, type: "end" | "start") => import("./date-picker/interface").DisabledTimeProps>;
        };
        separator: {
            type: StringConstructor;
        };
        exchangeTime: {
            type: BooleanConstructor;
            default: boolean;
        };
        popupContainer: {
            type: import("vue").PropType<string | HTMLElement | null | undefined>;
        };
        locale: {
            type: import("vue").PropType<Record<string, any>>;
        };
        hideTrigger: {
            type: BooleanConstructor;
        };
        allowClear: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly: {
            type: BooleanConstructor;
        };
        error: {
            type: BooleanConstructor;
        };
        size: {
            type: import("vue").PropType<"mini" | "medium" | "large" | "small">;
        };
        shortcuts: {
            type: import("vue").PropType<import("./date-picker").ShortcutType[]>;
            default: () => never[];
        };
        shortcutsPosition: {
            type: import("vue").PropType<"bottom" | "left" | "right">;
            default: string;
        };
        position: {
            type: import("vue").PropType<"top" | "tl" | "tr" | "bottom" | "bl" | "br">;
            default: string;
        };
        popupVisible: {
            type: BooleanConstructor;
            default: undefined;
        };
        defaultPopupVisible: {
            type: BooleanConstructor;
        };
        triggerProps: {
            type: import("vue").PropType<import("./trigger").TriggerProps>;
        };
        unmountOnClose: {
            type: BooleanConstructor;
        };
        previewShortcut: {
            type: BooleanConstructor;
            default: boolean;
        };
        showConfirmBtn: {
            type: BooleanConstructor;
        };
        disabledInput: {
            type: BooleanConstructor;
            default: boolean;
        };
        abbreviation: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        prefixCls: string;
        refInput: import("vue").Ref<any>;
        computedFormat: import("vue").ComputedRef<string>;
        computedPlaceholder: import("vue").ComputedRef<string[]>;
        panelVisible: import("vue").ComputedRef<boolean>;
        panelValue: import("vue").ComputedRef<(import("dayjs").Dayjs | undefined)[]>;
        inputValue: import("vue").Ref<(string | undefined)[] | undefined>;
        focusedIndex: import("vue").Ref<number>;
        triggerDisabled: import("vue").ComputedRef<boolean>;
        mergedSize: import("vue").ComputedRef<"mini" | "medium" | "large" | "small" | undefined>;
        mergedError: import("vue").ComputedRef<boolean>;
        onPanelVisibleChange: (visible: boolean) => void;
        onInputClear: (e: Event) => void;
        onInputChange: (e: any) => void;
        onInputPressEnter: () => void;
        rangePanelProps: import("vue").ComputedRef<{
            prefixCls: string;
            format: string;
            value: (import("dayjs").Dayjs | undefined)[];
            showConfirmBtn: boolean;
            confirmBtnDisabled: boolean | undefined;
            timePickerValue: import("dayjs").Dayjs[];
            timePickerProps: {
                visible: boolean;
                popupVisible?: boolean | undefined;
                defaultPopupVisible?: boolean | undefined;
                position?: "top" | "tl" | "tr" | "bottom" | "bl" | "br" | undefined;
                disabled?: boolean | undefined;
                unmountOnClose?: boolean | undefined;
                size?: "mini" | "medium" | "large" | "small" | undefined;
                modelValue?: string | number | {
                    toString: () => string;
                    toDateString: () => string;
                    toTimeString: () => string;
                    toLocaleString: {
                        (): string;
                        (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
                    };
                    toLocaleDateString: {
                        (): string;
                        (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
                    };
                    toLocaleTimeString: {
                        (): string;
                        (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
                    };
                    valueOf: () => number;
                    getTime: () => number;
                    getFullYear: () => number;
                    getUTCFullYear: () => number;
                    getMonth: () => number;
                    getUTCMonth: () => number;
                    getDate: () => number;
                    getUTCDate: () => number;
                    getDay: () => number;
                    getUTCDay: () => number;
                    getHours: () => number;
                    getUTCHours: () => number;
                    getMinutes: () => number;
                    getUTCMinutes: () => number;
                    getSeconds: () => number;
                    getUTCSeconds: () => number;
                    getMilliseconds: () => number;
                    getUTCMilliseconds: () => number;
                    getTimezoneOffset: () => number;
                    setTime: (time: number) => number;
                    setMilliseconds: (ms: number) => number;
                    setUTCMilliseconds: (ms: number) => number;
                    setSeconds: (sec: number, ms?: number | undefined) => number;
                    setUTCSeconds: (sec: number, ms?: number | undefined) => number;
                    setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
                    setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
                    setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
                    setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
                    setDate: (date: number) => number;
                    setUTCDate: (date: number) => number;
                    setMonth: (month: number, date?: number | undefined) => number;
                    setUTCMonth: (month: number, date?: number | undefined) => number;
                    setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
                    setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
                    toUTCString: () => string;
                    toISOString: () => string;
                    toJSON: (key?: any) => string;
                    getVarDate: () => VarDate;
                    [Symbol.toPrimitive]: {
                        (hint: "default"): string;
                        (hint: "string"): string;
                        (hint: "number"): number;
                        (hint: string): string | number;
                    };
                } | (string | number | {
                    toString: () => string;
                    toDateString: () => string;
                    toTimeString: () => string;
                    toLocaleString: {
                        (): string;
                        (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
                    };
                    toLocaleDateString: {
                        (): string;
                        (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
                    };
                    toLocaleTimeString: {
                        (): string;
                        (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
                    };
                    valueOf: () => number;
                    getTime: () => number;
                    getFullYear: () => number;
                    getUTCFullYear: () => number;
                    getMonth: () => number;
                    getUTCMonth: () => number;
                    getDate: () => number;
                    getUTCDate: () => number;
                    getDay: () => number;
                    getUTCDay: () => number;
                    getHours: () => number;
                    getUTCHours: () => number;
                    getMinutes: () => number;
                    getUTCMinutes: () => number;
                    getSeconds: () => number;
                    getUTCSeconds: () => number;
                    getMilliseconds: () => number;
                    getUTCMilliseconds: () => number;
                    getTimezoneOffset: () => number;
                    setTime: (time: number) => number;
                    setMilliseconds: (ms: number) => number;
                    setUTCMilliseconds: (ms: number) => number;
                    setSeconds: (sec: number, ms?: number | undefined) => number;
                    setUTCSeconds: (sec: number, ms?: number | undefined) => number;
                    setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
                    setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
                    setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
                    setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
                    setDate: (date: number) => number;
                    setUTCDate: (date: number) => number;
                    setMonth: (month: number, date?: number | undefined) => number;
                    setUTCMonth: (month: number, date?: number | undefined) => number;
                    setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
                    setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
                    toUTCString: () => string;
                    toISOString: () => string;
                    toJSON: (key?: any) => string;
                    getVarDate: () => VarDate;
                    [Symbol.toPrimitive]: {
                        (hint: "default"): string;
                        (hint: "string"): string;
                        (hint: "number"): number;
                        (hint: string): string | number;
                    };
                })[] | undefined;
                placeholder?: string | string[] | undefined;
                error?: boolean | undefined;
                readonly?: boolean | undefined;
                type?: "time" | "time-range" | undefined;
                allowClear?: boolean | undefined;
                format: string;
                triggerProps?: {
                    [x: string]: unknown;
                } | undefined;
                disableConfirm?: boolean | undefined;
                use12Hours?: boolean | undefined;
                step?: {
                    hour?: number | undefined;
                    minute?: number | undefined;
                    second?: number | undefined;
                } | undefined;
                disabledHours?: (() => number[]) | undefined;
                disabledMinutes?: ((selectedHour?: number | undefined) => number[]) | undefined;
                disabledSeconds?: ((selectedHour?: number | undefined, selectedMinute?: number | undefined) => number[]) | undefined;
                hideDisabledOptions?: boolean | undefined;
            };
            extra: import("vue").Slot | undefined;
            dateRender: import("vue").Slot | undefined;
            startHeaderProps: {
                headerValue: import("dayjs").Dayjs;
                headerOperations: Pick<any, string>;
                headerIcons: {
                    prev: import("vue").Slot | undefined;
                    prevDouble: import("vue").Slot | undefined;
                    next: import("vue").Slot | undefined;
                    nextDouble: import("vue").Slot | undefined;
                };
            };
            endHeaderProps: {
                headerValue: import("dayjs").Dayjs;
                headerOperations: Pick<any, string>;
                headerIcons: {
                    prev: import("vue").Slot | undefined;
                    prevDouble: import("vue").Slot | undefined;
                    next: import("vue").Slot | undefined;
                    nextDouble: import("vue").Slot | undefined;
                };
            };
            footerValue: {
                clone: () => import("dayjs").Dayjs;
                isValid: () => boolean;
                year: {
                    (): number;
                    (value: number): import("dayjs").Dayjs;
                };
                month: {
                    (): number;
                    (value: number): import("dayjs").Dayjs;
                };
                date: {
                    (): number;
                    (value: number): import("dayjs").Dayjs;
                };
                day: {
                    (): number;
                    (value: number): import("dayjs").Dayjs;
                };
                hour: {
                    (): number;
                    (value: number): import("dayjs").Dayjs;
                };
                minute: {
                    (): number;
                    (value: number): import("dayjs").Dayjs;
                };
                second: {
                    (): number;
                    (value: number): import("dayjs").Dayjs;
                };
                millisecond: {
                    (): number;
                    (value: number): import("dayjs").Dayjs;
                };
                set: (unit: import("dayjs").UnitType, value: number) => import("dayjs").Dayjs;
                get: (unit: import("dayjs").UnitType) => number;
                add: {
                    (value: number, unit?: import("dayjs").ManipulateType | undefined): import("dayjs").Dayjs;
                    (value: number, unit: import("dayjs").QUnitType): import("dayjs").Dayjs;
                };
                subtract: {
                    (value: number, unit?: import("dayjs").ManipulateType | undefined): import("dayjs").Dayjs;
                    (value: number, unit: import("dayjs").QUnitType): import("dayjs").Dayjs;
                };
                startOf: {
                    (unit: import("dayjs").OpUnitType): import("dayjs").Dayjs;
                    (unit: import("dayjs").QUnitType): import("dayjs").Dayjs;
                };
                endOf: {
                    (unit: import("dayjs").OpUnitType): import("dayjs").Dayjs;
                    (unit: import("dayjs").QUnitType): import("dayjs").Dayjs;
                };
                format: (template?: string | undefined) => string;
                diff: (date?: string | number | Date | import("dayjs").Dayjs | null | undefined, unit?: "M" | "y" | "s" | "year" | "month" | "date" | "day" | "hour" | "minute" | "second" | "millisecond" | "week" | "quarter" | "milliseconds" | "seconds" | "minutes" | "hours" | "days" | "months" | "years" | "dates" | "d" | "h" | "m" | "ms" | "weeks" | "w" | "quarters" | "Q" | undefined, float?: boolean | undefined) => number;
                valueOf: () => number;
                unix: () => number;
                daysInMonth: () => number;
                toDate: () => Date;
                toJSON: () => string;
                toISOString: () => string;
                toString: () => string;
                utcOffset: () => number;
                isBefore: {
                    (date: string | number | Date | import("dayjs").Dayjs | null | undefined, unit?: import("dayjs").OpUnitType | undefined): boolean;
                    (date: string | number | Date | import("dayjs").Dayjs | null | undefined, unit?: import("dayjs").QUnitType | undefined): boolean;
                };
                isSame: {
                    (date: string | number | Date | import("dayjs").Dayjs | null | undefined, unit?: import("dayjs").OpUnitType | undefined): boolean;
                    (date: string | number | Date | import("dayjs").Dayjs | null | undefined, unit?: import("dayjs").QUnitType | undefined): boolean;
                };
                isAfter: {
                    (date: string | number | Date | import("dayjs").Dayjs | null | undefined, unit?: import("dayjs").OpUnitType | undefined): boolean;
                    (date: string | number | Date | import("dayjs").Dayjs | null | undefined, unit?: import("dayjs").QUnitType | undefined): boolean;
                };
                locale: {
                    (): string;
                    (preset: string | ILocale, object?: Partial<ILocale> | undefined): import("dayjs").Dayjs;
                };
                isBetween: (a: string | number | Date | import("dayjs").Dayjs | null | undefined, b: string | number | Date | import("dayjs").Dayjs | null | undefined, c?: import("dayjs").OpUnitType | null | undefined, d?: "()" | "[]" | "[)" | "(]" | undefined) => boolean;
                week: {
                    (): number;
                    (value: number): import("dayjs").Dayjs;
                };
                weekYear: () => number;
                quarter: {
                    (): number;
                    (quarter: number): import("dayjs").Dayjs;
                };
            }[];
            disabled: boolean[];
            visible: boolean;
            onCellClick: (date: import("dayjs").Dayjs) => void;
            onCellMouseEnter: (date: import("dayjs").Dayjs) => void;
            onShortcutClick: (value: (import("dayjs").Dayjs | undefined)[], shortcut: import("./date-picker").ShortcutType) => void;
            onShortcutMouseEnter: ((value: (import("dayjs").Dayjs | undefined)[]) => void) | undefined;
            onShortcutMouseLeave: (() => void) | undefined;
            onConfirm: () => void;
            onTimePickerSelect: (time: import("dayjs").Dayjs, type: "end" | "start") => void;
            startHeaderMode: "year" | "month" | undefined;
            endHeaderMode: "year" | "month" | undefined;
            onStartHeaderLabelClick: (type: "year" | "month") => void;
            onEndHeaderLabelClick: (type: "year" | "month") => void;
            onStartHeaderSelect: (date: import("dayjs").Dayjs) => void;
            onEndHeaderSelect: (date: import("dayjs").Dayjs) => void;
            mode: "year" | "month" | "date" | "week" | "quarter";
            hideTrigger: boolean;
            dayStartOfWeek: import("./date-picker/interface").WeekStart;
            showTime: boolean;
            disabledTime: ((current: Date, type: "end" | "start") => import("./date-picker/interface").DisabledTimeProps) | undefined;
            shortcuts: import("./date-picker").ShortcutType[];
            disabledDate: ((current: Date, type: "end" | "start") => boolean) | undefined;
            abbreviation: boolean;
            shortcutsPosition: "bottom" | "left" | "right";
        }>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        change: (value: (import("./date-picker/interface").CalendarValue | undefined)[] | undefined, date: (Date | undefined)[] | undefined, dateString: (string | undefined)[] | undefined) => true;
        'update:modelValue': (value: (import("./date-picker/interface").CalendarValue | undefined)[] | undefined) => true;
        select: (value: (import("./date-picker/interface").CalendarValue | undefined)[], date: (Date | undefined)[], dateString: (string | undefined)[]) => true;
        'popup-visible-change': (visible: boolean) => true;
        'update:popupVisible': (visible: boolean) => true;
        ok: (value: import("./date-picker/interface").CalendarValue[], date: Date[], dateString: string[]) => true;
        clear: () => true;
        'select-shortcut': (shortcut: import("./date-picker").ShortcutType) => true;
        'picker-value-change': (value: import("./date-picker/interface").CalendarValue[], date: Date[], dateString: string[]) => true;
        'update:pickerValue': (value: import("./date-picker/interface").CalendarValue[]) => true;
    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        mode?: unknown;
        modelValue?: unknown;
        defaultValue?: unknown;
        pickerValue?: unknown;
        defaultPickerValue?: unknown;
        disabled?: unknown;
        dayStartOfWeek?: unknown;
        format?: unknown;
        valueFormat?: unknown;
        showTime?: unknown;
        timePickerProps?: unknown;
        placeholder?: unknown;
        disabledDate?: unknown;
        disabledTime?: unknown;
        separator?: unknown;
        exchangeTime?: unknown;
        popupContainer?: unknown;
        locale?: unknown;
        hideTrigger?: unknown;
        allowClear?: unknown;
        readonly?: unknown;
        error?: unknown;
        size?: unknown;
        shortcuts?: unknown;
        shortcutsPosition?: unknown;
        position?: unknown;
        popupVisible?: unknown;
        defaultPopupVisible?: unknown;
        triggerProps?: unknown;
        unmountOnClose?: unknown;
        previewShortcut?: unknown;
        showConfirmBtn?: unknown;
        disabledInput?: unknown;
        abbreviation?: unknown;
    } & {
        defaultPopupVisible: boolean;
        position: "top" | "tl" | "tr" | "bottom" | "bl" | "br";
        disabled: boolean | boolean[];
        unmountOnClose: boolean;
        mode: "year" | "month" | "date" | "week" | "quarter";
        error: boolean;
        readonly: boolean;
        allowClear: boolean;
        disabledInput: boolean;
        hideTrigger: boolean;
        dayStartOfWeek: import("./date-picker/interface").WeekStart;
        showTime: boolean;
        shortcuts: import("./date-picker").ShortcutType[];
        showConfirmBtn: boolean;
        abbreviation: boolean;
        shortcutsPosition: "bottom" | "left" | "right";
        exchangeTime: boolean;
        previewShortcut: boolean;
    } & {
        popupVisible?: boolean | undefined;
        popupContainer?: string | HTMLElement | null | undefined;
        size?: "mini" | "medium" | "large" | "small" | undefined;
        separator?: string | undefined;
        modelValue?: (string | number | Date)[] | undefined;
        placeholder?: string[] | undefined;
        defaultValue?: (string | number | Date)[] | undefined;
        format?: string | undefined;
        locale?: Record<string, any> | undefined;
        triggerProps?: import("./trigger").TriggerProps | undefined;
        timePickerProps?: Partial<import("./time-picker/interface").TimePickerProps> | undefined;
        disabledTime?: ((current: Date, type: "end" | "start") => import("./date-picker/interface").DisabledTimeProps) | undefined;
        valueFormat?: string | undefined;
        disabledDate?: ((current: Date, type: "end" | "start") => boolean) | undefined;
        pickerValue?: (string | number | Date)[] | undefined;
        defaultPickerValue?: (string | number | Date)[] | undefined;
    }> & {
        "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
        onChange?: ((value: (import("./date-picker/interface").CalendarValue | undefined)[] | undefined, date: (Date | undefined)[] | undefined, dateString: (string | undefined)[] | undefined) => any) | undefined;
        onSelect?: ((value: (import("./date-picker/interface").CalendarValue | undefined)[], date: (Date | undefined)[], dateString: (string | undefined)[]) => any) | undefined;
        onClear?: (() => any) | undefined;
        "onUpdate:modelValue"?: ((value: (import("./date-picker/interface").CalendarValue | undefined)[] | undefined) => any) | undefined;
        onOk?: ((value: import("./date-picker/interface").CalendarValue[], date: Date[], dateString: string[]) => any) | undefined;
        "onPopup-visible-change"?: ((visible: boolean) => any) | undefined;
        "onSelect-shortcut"?: ((shortcut: import("./date-picker").ShortcutType) => any) | undefined;
        "onPicker-value-change"?: ((value: import("./date-picker/interface").CalendarValue[], date: Date[], dateString: string[]) => any) | undefined;
        "onUpdate:pickerValue"?: ((value: import("./date-picker/interface").CalendarValue[]) => any) | undefined;
    }, {
        popupVisible: boolean;
        defaultPopupVisible: boolean;
        position: "top" | "tl" | "tr" | "bottom" | "bl" | "br";
        disabled: boolean | boolean[];
        unmountOnClose: boolean;
        mode: "year" | "month" | "date" | "week" | "quarter";
        error: boolean;
        readonly: boolean;
        allowClear: boolean;
        disabledInput: boolean;
        hideTrigger: boolean;
        dayStartOfWeek: import("./date-picker/interface").WeekStart;
        showTime: boolean;
        shortcuts: import("./date-picker").ShortcutType[];
        showConfirmBtn: boolean;
        abbreviation: boolean;
        shortcutsPosition: "bottom" | "left" | "right";
        exchangeTime: boolean;
        previewShortcut: boolean;
    }>;
    Doption: import("vue").DefineComponent<{
        value: {
            type: (ObjectConstructor | StringConstructor | NumberConstructor)[];
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        active: BooleanConstructor;
        uninjectContext: BooleanConstructor;
    }, {
        prefixCls: string;
        cls: import("vue").ComputedRef<(string | {
            [x: string]: boolean;
        })[]>;
        liRef: import("vue").Ref<HTMLElement | undefined>;
        handleClick: (ev: MouseEvent) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        click: (ev: MouseEvent) => true;
    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        value?: unknown;
        disabled?: unknown;
        active?: unknown;
        uninjectContext?: unknown;
    } & {
        disabled: boolean;
        active: boolean;
        uninjectContext: boolean;
    } & {
        value?: string | number | Record<string, any> | undefined;
    }> & {
        onClick?: ((ev: MouseEvent) => any) | undefined;
    }, {
        disabled: boolean;
        active: boolean;
        uninjectContext: boolean;
    }>;
    Dgroup: import("vue").DefineComponent<{
        title: StringConstructor;
    }, {
        prefixCls: string;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        title?: unknown;
    } & {} & {
        title?: string | undefined;
    }>, {}>;
    Dsubmenu: import("vue").DefineComponent<{
        value: {
            type: (StringConstructor | NumberConstructor)[];
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        trigger: {
            type: import("vue").PropType<"hover" | "click" | ("hover" | "click")[]>;
            default: string;
        };
        position: {
            type: import("vue").PropType<"lt" | "rt">;
            default: string;
        };
        popupVisible: {
            type: BooleanConstructor;
            default: undefined;
        };
        defaultPopupVisible: {
            type: BooleanConstructor;
            default: boolean;
        };
        optionProps: {
            type: ObjectConstructor;
        };
    }, {
        prefixCls: string;
        computedPopupVisible: import("vue").ComputedRef<boolean>;
        handlePopupVisibleChange: (visible: boolean) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        'update:popupVisible': (visible: boolean) => true;
        popupVisibleChange: (visible: boolean) => true;
    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        value?: unknown;
        disabled?: unknown;
        trigger?: unknown;
        position?: unknown;
        popupVisible?: unknown;
        defaultPopupVisible?: unknown;
        optionProps?: unknown;
    } & {
        defaultPopupVisible: boolean;
        trigger: "hover" | "click" | ("hover" | "click")[];
        position: "lt" | "rt";
        disabled: boolean;
    } & {
        popupVisible?: boolean | undefined;
        value?: string | number | undefined;
        optionProps?: Record<string, any> | undefined;
    }> & {
        "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
        onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
    }, {
        popupVisible: boolean;
        defaultPopupVisible: boolean;
        trigger: "hover" | "click" | ("hover" | "click")[];
        position: "lt" | "rt";
        disabled: boolean;
    }>;
    DropdownButton: import("vue").DefineComponent<{
        popupVisible: {
            type: BooleanConstructor;
            default: undefined;
        };
        defaultPopupVisible: {
            type: BooleanConstructor;
            default: boolean;
        };
        trigger: {
            type: import("vue").PropType<"hover" | "click" | "focus" | "contextMenu" | ("hover" | "click" | "focus" | "contextMenu")[]>;
            default: string;
        };
        position: {
            type: import("vue").PropType<"top" | "tl" | "tr" | "bottom" | "bl" | "br">;
            default: string;
        };
        popupContainer: {
            type: import("vue").PropType<string | HTMLElement | null | undefined>;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        type: {
            type: StringConstructor;
        };
        size: {
            type: StringConstructor;
        };
        buttonProps: {
            type: import("vue").PropType<import("./button").ButtonProps>;
        };
        hideOnSelect: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        prefixCls: string;
        computedPopupVisible: import("vue").ComputedRef<boolean>;
        handleClick: (ev: MouseEvent) => void;
        handleSelect: (value: string | number | Record<string, unknown> | undefined, ev: Event) => void;
        handlePopupVisibleChange: (visible: boolean) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        'update:popupVisible': (visible: boolean) => true;
        popupVisibleChange: (visible: boolean) => true;
        click: (ev: MouseEvent) => true;
        select: (value: string | number | Record<string, any> | undefined, ev: Event) => true;
    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        popupVisible?: unknown;
        defaultPopupVisible?: unknown;
        trigger?: unknown;
        position?: unknown;
        popupContainer?: unknown;
        disabled?: unknown;
        type?: unknown;
        size?: unknown;
        buttonProps?: unknown;
        hideOnSelect?: unknown;
    } & {
        defaultPopupVisible: boolean;
        trigger: "hover" | "click" | "focus" | "contextMenu" | ("hover" | "click" | "focus" | "contextMenu")[];
        position: "top" | "tl" | "tr" | "bottom" | "bl" | "br";
        disabled: boolean;
        hideOnSelect: boolean;
    } & {
        popupVisible?: boolean | undefined;
        popupContainer?: string | HTMLElement | null | undefined;
        size?: string | undefined;
        type?: string | undefined;
        buttonProps?: import("./button").ButtonProps | undefined;
    }> & {
        "onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
        onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
        onClick?: ((ev: MouseEvent) => any) | undefined;
        onSelect?: ((value: string | number | Record<string, any> | undefined, ev: Event) => any) | undefined;
    }, {
        popupVisible: boolean;
        defaultPopupVisible: boolean;
        trigger: "hover" | "click" | "focus" | "contextMenu" | ("hover" | "click" | "focus" | "contextMenu")[];
        position: "top" | "tl" | "tr" | "bottom" | "bl" | "br";
        disabled: boolean;
        hideOnSelect: boolean;
    }>;
    FormItem: import("vue").DefineComponent<{
        field: {
            type: StringConstructor;
            default: string;
        };
        label: StringConstructor;
        tooltip: {
            type: StringConstructor;
        };
        showColon: {
            type: BooleanConstructor;
            default: boolean;
        };
        noStyle: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: undefined;
        };
        help: StringConstructor;
        extra: StringConstructor;
        required: {
            type: BooleanConstructor;
            default: boolean;
        };
        asteriskPosition: {
            type: StringConstructor;
            default: string;
        };
        rules: {
            type: import("vue").PropType<import("./form").FieldRule<any> | import("./form").FieldRule<any>[]>;
        };
        validateStatus: {
            type: import("vue").PropType<"error" | "success" | "warning" | "validating">;
        };
        validateTrigger: {
            type: import("vue").PropType<"focus" | "input" | "blur" | "change" | ("focus" | "input" | "blur" | "change")[]>;
            default: string;
        };
        labelColProps: ObjectConstructor;
        wrapperColProps: ObjectConstructor;
        hideLabel: {
            type: BooleanConstructor;
            default: boolean;
        };
        hideAsterisk: {
            type: BooleanConstructor;
            default: boolean;
        };
        labelColStyle: ObjectConstructor;
        wrapperColStyle: ObjectConstructor;
        rowProps: ObjectConstructor;
        rowClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
        contentClass: (ObjectConstructor | StringConstructor | ArrayConstructor)[];
        contentFlex: {
            type: BooleanConstructor;
            default: boolean;
        };
        mergeProps: {
            type: import("vue").PropType<boolean | ((props: Record<string, any>) => Record<string, any>)>;
            default: boolean;
        };
        labelColFlex: {
            type: (StringConstructor | NumberConstructor)[];
        };
        feedback: {
            type: BooleanConstructor;
            default: boolean;
        };
        labelComponent: {
            type: StringConstructor;
            default: string;
        };
        labelAttrs: ObjectConstructor;
    }, {
        prefixCls: string;
        cls: import("vue").ComputedRef<(string | Record<string, any> | undefined)[]>;
        isRequired: import("vue").ComputedRef<boolean>;
        isError: import("vue").ComputedRef<boolean>;
        finalMessage: import("vue").ComputedRef<string[]>;
        mergedLabelCol: import("vue").ComputedRef<any>;
        mergedWrapperCol: import("vue").ComputedRef<any>;
        labelColCls: import("vue").ComputedRef<(string | {
            [x: string]: string | number | boolean | undefined;
        })[]>;
        autoLabelWidth: import("vue").Ref<boolean | undefined> | undefined;
        layout: import("vue").Ref<string | undefined> | undefined;
        mergedLabelStyle: import("vue").ComputedRef<any>;
        wrapperColCls: import("vue").ComputedRef<(string | {
            [x: string]: boolean;
        })[]>;
        mergedWrapperStyle: import("vue").ComputedRef<any>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        field?: unknown;
        label?: unknown;
        tooltip?: unknown;
        showColon?: unknown;
        noStyle?: unknown;
        disabled?: unknown;
        help?: unknown;
        extra?: unknown;
        required?: unknown;
        asteriskPosition?: unknown;
        rules?: unknown;
        validateStatus?: unknown;
        validateTrigger?: unknown;
        labelColProps?: unknown;
        wrapperColProps?: unknown;
        hideLabel?: unknown;
        hideAsterisk?: unknown;
        labelColStyle?: unknown;
        wrapperColStyle?: unknown;
        rowProps?: unknown;
        rowClass?: unknown;
        contentClass?: unknown;
        contentFlex?: unknown;
        mergeProps?: unknown;
        labelColFlex?: unknown;
        feedback?: unknown;
        labelComponent?: unknown;
        labelAttrs?: unknown;
    } & {
        feedback: boolean;
        required: boolean;
        field: string;
        showColon: boolean;
        asteriskPosition: string;
        noStyle: boolean;
        validateTrigger: "focus" | "input" | "blur" | "change" | ("focus" | "input" | "blur" | "change")[];
        hideLabel: boolean;
        hideAsterisk: boolean;
        contentFlex: boolean;
        mergeProps: boolean | ((props: Record<string, any>) => Record<string, any>);
        labelComponent: string;
    } & {
        disabled?: boolean | undefined;
        contentClass?: string | unknown[] | Record<string, any> | undefined;
        help?: string | undefined;
        tooltip?: string | undefined;
        label?: string | undefined;
        extra?: string | undefined;
        rowClass?: string | unknown[] | Record<string, any> | undefined;
        labelColProps?: Record<string, any> | undefined;
        wrapperColProps?: Record<string, any> | undefined;
        labelColStyle?: Record<string, any> | undefined;
        wrapperColStyle?: Record<string, any> | undefined;
        rules?: import("./form").FieldRule<any> | import("./form").FieldRule<any>[] | undefined;
        validateStatus?: "error" | "success" | "warning" | "validating" | undefined;
        rowProps?: Record<string, any> | undefined;
        labelColFlex?: string | number | undefined;
        labelAttrs?: Record<string, any> | undefined;
    }>, {
        disabled: boolean;
        feedback: boolean;
        required: boolean;
        field: string;
        showColon: boolean;
        asteriskPosition: string;
        noStyle: boolean;
        validateTrigger: "focus" | "input" | "blur" | "change" | ("focus" | "input" | "blur" | "change")[];
        hideLabel: boolean;
        hideAsterisk: boolean;
        contentFlex: boolean;
        mergeProps: boolean | ((props: Record<string, any>) => Record<string, any>);
        labelComponent: string;
    }>;
    Row: import("vue").DefineComponent<{
        gutter: {
            type: import("vue").PropType<number | import("./grid").ResponsiveValue | [number | import("./grid").ResponsiveValue, number | import("./grid").ResponsiveValue]>;
            default: number;
        };
        justify: {
            type: import("vue").PropType<"space-around" | "space-between" | "center" | "end" | "start">;
            default: string;
        };
        align: {
            type: import("vue").PropType<"stretch" | "center" | "end" | "start">;
            default: string;
        };
        div: {
            type: BooleanConstructor;
        };
        wrap: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        classNames: import("vue").ComputedRef<{
            [x: string]: boolean | "space-around" | "space-between" | "stretch" | "center" | "end" | "start";
        }>;
        styles: import("vue").ComputedRef<{
            marginTop?: string | undefined;
            marginBottom?: string | undefined;
            marginLeft?: string | undefined;
            marginRight?: string | undefined;
        }>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        gutter?: unknown;
        justify?: unknown;
        align?: unknown;
        div?: unknown;
        wrap?: unknown;
    } & {
        wrap: boolean;
        justify: "space-around" | "space-between" | "center" | "end" | "start";
        div: boolean;
        align: "stretch" | "center" | "end" | "start";
        gutter: number | import("./grid").ResponsiveValue | [number | import("./grid").ResponsiveValue, number | import("./grid").ResponsiveValue];
    } & {}>, {
        wrap: boolean;
        justify: "space-around" | "space-between" | "center" | "end" | "start";
        div: boolean;
        align: "stretch" | "center" | "end" | "start";
        gutter: number | import("./grid").ResponsiveValue | [number | import("./grid").ResponsiveValue, number | import("./grid").ResponsiveValue];
    }>;
    Col: import("vue").DefineComponent<{
        span: {
            type: NumberConstructor;
            default: number;
        };
        offset: {
            type: NumberConstructor;
        };
        order: {
            type: NumberConstructor;
        };
        xs: {
            type: import("vue").PropType<number | {
                [key: string]: any;
            }>;
        };
        sm: {
            type: import("vue").PropType<number | {
                [key: string]: any;
            }>;
        };
        md: {
            type: import("vue").PropType<number | {
                [key: string]: any;
            }>;
        };
        lg: {
            type: import("vue").PropType<number | {
                [key: string]: any;
            }>;
        };
        xl: {
            type: import("vue").PropType<number | {
                [key: string]: any;
            }>;
        };
        xxl: {
            type: import("vue").PropType<number | {
                [key: string]: any;
            }>;
        };
        flex: {
            type: import("vue").PropType<string | number>;
        };
    }, {
        visible: import("vue").ComputedRef<boolean>;
        classNames: import("vue").ComputedRef<string | {
            [x: string]: number | boolean | undefined;
        }>;
        styles: import("vue").ComputedRef<{
            flex?: import("./grid/interface").FlexType | undefined;
            paddingLeft?: string | undefined;
            paddingRight?: string | undefined;
            paddingTop?: string | undefined;
            paddingBottom?: string | undefined;
        }>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        span?: unknown;
        offset?: unknown;
        order?: unknown;
        xs?: unknown;
        sm?: unknown;
        md?: unknown;
        lg?: unknown;
        xl?: unknown;
        xxl?: unknown;
        flex?: unknown;
    } & {
        span: number;
    } & {
        flex?: string | number | undefined;
        offset?: number | undefined;
        order?: number | undefined;
        xxl?: number | {
            [key: string]: any;
        } | undefined;
        xl?: number | {
            [key: string]: any;
        } | undefined;
        lg?: number | {
            [key: string]: any;
        } | undefined;
        md?: number | {
            [key: string]: any;
        } | undefined;
        sm?: number | {
            [key: string]: any;
        } | undefined;
        xs?: number | {
            [key: string]: any;
        } | undefined;
    }>, {
        span: number;
    }>;
    GridItem: import("vue").DefineComponent<{
        span: {
            type: import("vue").PropType<number | import("./grid").ResponsiveValue>;
            default: number;
        };
        offset: {
            type: import("vue").PropType<number | import("./grid").ResponsiveValue>;
            default: number;
        };
        suffix: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        classNames: import("vue").ComputedRef<string[]>;
        style: import("vue").ComputedRef<({
            'margin-left': string;
        } | {
            'margin-left'?: undefined;
        } | {
            'grid-column': string;
            display?: undefined;
        } | {
            display: string;
            'grid-column'?: undefined;
        })[]>;
        domRef: import("vue").Ref<HTMLDivElement | undefined>;
        overflow: import("vue").ComputedRef<boolean>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        span?: unknown;
        offset?: unknown;
        suffix?: unknown;
    } & {
        span: number | import("./grid").ResponsiveValue;
        offset: number | import("./grid").ResponsiveValue;
        suffix: boolean;
    } & {}>, {
        span: number | import("./grid").ResponsiveValue;
        offset: number | import("./grid").ResponsiveValue;
        suffix: boolean;
    }>;
    ImagePreview: import("vue").DefineComponent<{
        renderToBody: {
            type: BooleanConstructor;
            default: boolean;
        };
        src: {
            type: StringConstructor;
        };
        visible: {
            type: BooleanConstructor;
            default: undefined;
        };
        defaultVisible: {
            type: BooleanConstructor;
            default: boolean;
        };
        maskClosable: {
            type: BooleanConstructor;
            default: boolean;
        };
        closable: {
            type: BooleanConstructor;
            default: boolean;
        };
        actionsLayout: {
            type: import("vue").PropType<string[]>;
            default: () => string[];
        };
        popupContainer: {
            type: import("vue").PropType<HTMLElement>;
        };
        inGroup: {
            type: BooleanConstructor;
            default: boolean;
        };
        groupArrowProps: {
            type: ObjectConstructor;
            default: () => {};
        };
    }, {
        prefixCls: string;
        classNames: import("vue").ComputedRef<(string | {
            [x: string]: boolean;
        })[]>;
        container: import("vue").ComputedRef<HTMLElement>;
        wrapperStyles: import("vue").ComputedRef<import("vue").CSSProperties>;
        scale: import("vue").Ref<number>;
        translate: import("vue").Ref<number[]>;
        rotate: import("vue").Ref<number>;
        moving: import("vue").Ref<boolean>;
        mergedVisible: import("vue").ComputedRef<boolean>;
        isLoading: import("vue").ComputedRef<boolean>;
        isLoaded: import("vue").ComputedRef<boolean>;
        scaleValueVisible: import("vue").Ref<boolean>;
        refWrapper: import("vue").Ref<any>;
        refImage: import("vue").Ref<any>;
        onMaskClick: (e: MouseEvent) => void;
        onCloseClick: () => void;
        onImgLoad(): void;
        onImgError(): void;
        actions: import("vue").ComputedRef<({
            key: string;
            name: string;
            content: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>;
            onClick: () => void;
            disabled?: undefined;
        } | {
            key: string;
            name: string;
            content: () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>;
            onClick: () => void;
            disabled: boolean;
        })[]>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "update:visible")[], "close" | "update:visible", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        renderToBody?: unknown;
        src?: unknown;
        visible?: unknown;
        defaultVisible?: unknown;
        maskClosable?: unknown;
        closable?: unknown;
        actionsLayout?: unknown;
        popupContainer?: unknown;
        inGroup?: unknown;
        groupArrowProps?: unknown;
    } & {
        renderToBody: boolean;
        closable: boolean;
        actionsLayout: string[];
        defaultVisible: boolean;
        maskClosable: boolean;
        inGroup: boolean;
        groupArrowProps: Record<string, any>;
    } & {
        popupContainer?: HTMLElement | undefined;
        visible?: boolean | undefined;
        src?: string | undefined;
    }> & {
        onClose?: ((...args: any[]) => any) | undefined;
        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
    }, {
        renderToBody: boolean;
        visible: boolean;
        closable: boolean;
        actionsLayout: string[];
        defaultVisible: boolean;
        maskClosable: boolean;
        inGroup: boolean;
        groupArrowProps: Record<string, any>;
    }>;
    ImagePreviewGroup: import("vue").DefineComponent<{
        renderToBody: {
            type: BooleanConstructor;
            default: boolean;
        };
        srcList: {
            type: import("vue").PropType<string[]>;
        };
        current: {
            type: NumberConstructor;
        };
        defaultCurrent: {
            type: NumberConstructor;
            default: number;
        };
        infinite: {
            type: BooleanConstructor;
            default: boolean;
        };
        visible: {
            type: BooleanConstructor;
            default: undefined;
        };
        defaultVisible: {
            type: BooleanConstructor;
            default: boolean;
        };
        maskClosable: {
            type: BooleanConstructor;
            default: boolean;
        };
        closable: {
            type: BooleanConstructor;
            default: boolean;
        };
        actionsLayout: {
            type: import("vue").PropType<string[]>;
            default: () => string[];
        };
        popupContainer: {
            type: import("vue").PropType<string | HTMLElement>;
        };
    }, {
        mergedVisible: import("vue").ComputedRef<boolean>;
        currentUrl: import("vue").ComputedRef<string | undefined>;
        prevIndex: import("vue").ComputedRef<number | undefined>;
        nextIndex: import("vue").ComputedRef<number | undefined>;
        onClose(): void;
        groupArrowProps: {
            onPrev: (() => void) | undefined;
            onNext: (() => void) | undefined;
        };
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:current" | "update:visible" | "visible-change")[], "change" | "update:current" | "update:visible" | "visible-change", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        renderToBody?: unknown;
        srcList?: unknown;
        current?: unknown;
        defaultCurrent?: unknown;
        infinite?: unknown;
        visible?: unknown;
        defaultVisible?: unknown;
        maskClosable?: unknown;
        closable?: unknown;
        actionsLayout?: unknown;
        popupContainer?: unknown;
    } & {
        renderToBody: boolean;
        infinite: boolean;
        closable: boolean;
        defaultCurrent: number;
        actionsLayout: string[];
        defaultVisible: boolean;
        maskClosable: boolean;
    } & {
        popupContainer?: string | HTMLElement | undefined;
        visible?: boolean | undefined;
        current?: number | undefined;
        srcList?: string[] | undefined;
    }> & {
        onChange?: ((...args: any[]) => any) | undefined;
        "onUpdate:current"?: ((...args: any[]) => any) | undefined;
        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
        "onVisible-change"?: ((...args: any[]) => any) | undefined;
    }, {
        renderToBody: boolean;
        infinite: boolean;
        visible: boolean;
        closable: boolean;
        defaultCurrent: number;
        actionsLayout: string[];
        defaultVisible: boolean;
        maskClosable: boolean;
    }>;
    InputGroup: import("vue").DefineComponent<{}, {
        prefixCls: string;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
    InputSearch: import("vue").DefineComponent<{
        searchButton: {
            type: BooleanConstructor;
            default: boolean;
        };
        loading: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: import("vue").PropType<"mini" | "medium" | "large" | "small">;
        };
        buttonText: {
            type: StringConstructor;
        };
        buttonProps: {
            type: import("vue").PropType<import("./button").ButtonProps>;
        };
    }, {
        inputRef: import("vue").Ref<any>;
        render: () => JSX.Element;
    }, unknown, {}, {
        focus(): void;
        blur(): void;
    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        search: (value: string, ev: MouseEvent) => true;
    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        searchButton?: unknown;
        loading?: unknown;
        disabled?: unknown;
        size?: unknown;
        buttonText?: unknown;
        buttonProps?: unknown;
    } & {
        disabled: boolean;
        loading: boolean;
        searchButton: boolean;
    } & {
        size?: "mini" | "medium" | "large" | "small" | undefined;
        buttonText?: string | undefined;
        buttonProps?: import("./button").ButtonProps | undefined;
    }> & {
        onSearch?: ((value: string, ev: MouseEvent) => any) | undefined;
    }, {
        disabled: boolean;
        loading: boolean;
        searchButton: boolean;
    }>;
    InputPassword: import("vue").DefineComponent<{
        invisibleButton: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        inputRef: import("vue").Ref<any>;
        invisible: import("vue").Ref<boolean>;
        handleInvisible: () => void;
    }, unknown, {}, {
        focus(): void;
        blur(): void;
    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        invisibleButton?: unknown;
    } & {
        invisibleButton: boolean;
    } & {}>, {
        invisibleButton: boolean;
    }>;
    LayoutHeader: import("vue").DefineComponent<{}, {
        classNames: string[];
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
    LayoutContent: import("vue").DefineComponent<{}, {
        classNames: string[];
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
    LayoutFooter: import("vue").DefineComponent<{}, {
        classNames: string[];
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
    LayoutSider: import("vue").DefineComponent<{
        theme: {
            type: import("vue").PropType<"dark" | "light">;
            default: string;
        };
        collapsed: {
            type: BooleanConstructor;
            default: undefined;
        };
        defaultCollapsed: {
            type: BooleanConstructor;
        };
        collapsible: {
            type: BooleanConstructor;
        };
        width: {
            type: NumberConstructor;
            default: number;
        };
        collapsedWidth: {
            type: NumberConstructor;
            default: number;
        };
        reverseArrow: {
            type: BooleanConstructor;
        };
        breakpoint: {
            type: import("vue").PropType<"xxl" | "xl" | "lg" | "md" | "sm" | "xs">;
        };
        resizeDirections: {
            type: import("vue").PropType<("top" | "bottom" | "left" | "right")[]>;
            default: undefined;
        };
        hideTrigger: {
            type: BooleanConstructor;
        };
    }, {
        componentTag: import("vue").ComputedRef<"div" | "ResizeBox">;
        prefixCls: string;
        classNames: import("vue").ComputedRef<(string | {
            [x: string]: boolean | undefined;
        })[]>;
        triggerClassNames: import("vue").ComputedRef<(string | {
            [x: string]: boolean;
        })[]>;
        localCollapsed: import("vue").ComputedRef<boolean>;
        siderWidth: import("vue").ComputedRef<string>;
        showTrigger: import("vue").ComputedRef<boolean>;
        toggleTrigger: () => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("collapse" | "update:collapsed" | "breakpoint")[], "collapse" | "update:collapsed" | "breakpoint", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        theme?: unknown;
        collapsed?: unknown;
        defaultCollapsed?: unknown;
        collapsible?: unknown;
        width?: unknown;
        collapsedWidth?: unknown;
        reverseArrow?: unknown;
        breakpoint?: unknown;
        resizeDirections?: unknown;
        hideTrigger?: unknown;
    } & {
        width: number;
        theme: "dark" | "light";
        defaultCollapsed: boolean;
        collapsible: boolean;
        collapsedWidth: number;
        reverseArrow: boolean;
        hideTrigger: boolean;
    } & {
        collapsed?: boolean | undefined;
        breakpoint?: "xxl" | "xl" | "lg" | "md" | "sm" | "xs" | undefined;
        resizeDirections?: ("top" | "bottom" | "left" | "right")[] | undefined;
    }> & {
        onCollapse?: ((...args: any[]) => any) | undefined;
        "onUpdate:collapsed"?: ((...args: any[]) => any) | undefined;
        onBreakpoint?: ((...args: any[]) => any) | undefined;
    }, {
        width: number;
        collapsed: boolean;
        theme: "dark" | "light";
        defaultCollapsed: boolean;
        collapsible: boolean;
        collapsedWidth: number;
        reverseArrow: boolean;
        resizeDirections: ("top" | "bottom" | "left" | "right")[];
        hideTrigger: boolean;
    }>;
    ListItem: import("vue").DefineComponent<{
        actionLayout: {
            type: import("vue").PropType<"horizontal" | "vertical">;
            default: string;
        };
    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        actionLayout?: unknown;
    } & {
        actionLayout: "horizontal" | "vertical";
    } & {}>, {
        actionLayout: "horizontal" | "vertical";
    }>;
    ListItemMeta: import("vue").DefineComponent<{
        title: StringConstructor;
        description: StringConstructor;
    }, {
        prefixCls: string;
        hasContent: boolean;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        title?: unknown;
        description?: unknown;
    } & {} & {
        title?: string | undefined;
        description?: string | undefined;
    }>, {}>;
    MenuItem: import("vue").DefineComponent<{
        key: {
            type: StringConstructor;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        menuContext: Partial<Readonly<Pick<import("./menu/interface").InternalMenuProps, "tooltipProps" | "mode" | "theme" | "triggerProps" | "popupMaxHeight" | "levelIndent" | "autoScrollIntoView" | "scrollConfig" | "inTrigger"> & {
            selectedKeys: string[];
            openKeys: string[];
            prefixCls: string;
            collapsed: boolean;
            expandIconDown?: (() => import("vue").VNodeTypes) | undefined;
            expandIconRight?: (() => import("vue").VNodeTypes) | undefined;
            onSubMenuClick?: ((key: string, level: number) => void) | undefined;
            onMenuItemClick?: ((key: string) => void) | undefined;
        }>>;
        level: import("vue").ComputedRef<number>;
        isSelected: import("vue").ComputedRef<boolean>;
        refItemElement: import("vue").Ref<HTMLDivElement | undefined>;
        onClick(e: MouseEvent): void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        key?: unknown;
        disabled?: unknown;
    } & {
        disabled: boolean;
    } & {
        key?: string | undefined;
    }> & {
        onClick?: ((...args: any[]) => any) | undefined;
    }, {
        disabled: boolean;
    }>;
    MenuItemGroup: import("vue").DefineComponent<{
        title: {
            type: StringConstructor;
        };
    }, {
        prefixCls: import("vue").ComputedRef<string | undefined>;
        classNames: import("vue").ComputedRef<string[]>;
        level: import("vue").ComputedRef<number>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        title?: unknown;
    } & {} & {
        title?: string | undefined;
    }>, {}>;
    SubMenu: import("vue").DefineComponent<{
        key: {
            type: StringConstructor;
        };
        title: {
            type: StringConstructor;
        };
        selectable: {
            type: BooleanConstructor;
        };
        popup: {
            type: import("vue").PropType<boolean | ((level: number) => boolean)>;
            default: boolean;
        };
        popupMaxHeight: {
            type: import("vue").PropType<number | boolean>;
            default: undefined;
        };
    }, {
        subMenuKeys: import("vue").ComputedRef<string[]>;
        menuItemKeys: import("vue").ComputedRef<string[]>;
        isChildrenSelected: import("vue").ComputedRef<boolean>;
        props: import("./menu/interface").SubMenuProps;
        attrs: {
            [x: string]: unknown;
        };
        computedKey: import("vue").ComputedRef<string>;
        computedPopup: import("vue").ComputedRef<boolean>;
        expandIconDown: import("vue").Ref<(() => import("vue").VNodeTypes) | undefined>;
        expandIconRight: import("vue").Ref<(() => import("vue").VNodeTypes) | undefined>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        key?: unknown;
        title?: unknown;
        selectable?: unknown;
        popup?: unknown;
        popupMaxHeight?: unknown;
    } & {
        popup: boolean | ((level: number) => boolean);
        selectable: boolean;
    } & {
        key?: string | undefined;
        title?: string | undefined;
        popupMaxHeight?: number | boolean | undefined;
    }>, {
        popup: boolean | ((level: number) => boolean);
        selectable: boolean;
        popupMaxHeight: number | boolean;
    }>;
    RadioGroup: import("vue").DefineComponent<{
        modelValue: {
            type: import("vue").PropType<string | number | boolean>;
            default: undefined;
        };
        defaultValue: {
            type: import("vue").PropType<string | number | boolean>;
            default: string;
        };
        type: {
            type: import("vue").PropType<"button" | "radio">;
            default: string;
        };
        size: {
            type: import("vue").PropType<"mini" | "medium" | "large" | "small">;
        };
        options: {
            type: import("vue").PropType<(string | number | import("./radio/interface").RadioOption)[]>;
        };
        direction: {
            type: import("vue").PropType<"horizontal" | "vertical">;
            default: string;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        'update:modelValue': (value: string | number | boolean) => true;
        change: (value: string | number | boolean, ev: Event) => true;
    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        modelValue?: unknown;
        defaultValue?: unknown;
        type?: unknown;
        size?: unknown;
        options?: unknown;
        direction?: unknown;
        disabled?: unknown;
    } & {
        disabled: boolean;
        defaultValue: string | number | boolean;
        type: "button" | "radio";
        direction: "horizontal" | "vertical";
    } & {
        size?: "mini" | "medium" | "large" | "small" | undefined;
        modelValue?: string | number | boolean | undefined;
        options?: (string | number | import("./radio/interface").RadioOption)[] | undefined;
    }> & {
        onChange?: ((value: string | number | boolean, ev: Event) => any) | undefined;
        "onUpdate:modelValue"?: ((value: string | number | boolean) => any) | undefined;
    }, {
        disabled: boolean;
        modelValue: string | number | boolean;
        defaultValue: string | number | boolean;
        type: "button" | "radio";
        direction: "horizontal" | "vertical";
    }>;
    Option: import("vue").DefineComponent<{
        value: (ObjectConstructor | StringConstructor | NumberConstructor)[];
        label: StringConstructor;
        disabled: BooleanConstructor;
        tagProps: {
            type: import("vue").PropType<import("./tag").TagProps>;
        };
        extra: {
            type: ObjectConstructor;
        };
        index: {
            type: NumberConstructor;
        };
        internal: BooleanConstructor;
    }, {
        prefixCls: string;
        cls: import("vue").ComputedRef<(string | {
            [x: string]: boolean | undefined;
        })[]>;
        selectCtx: import("./select/context").SelectContext | undefined;
        itemRef: import("vue").Ref<HTMLElement | undefined>;
        component: import("vue").ComputedRef<string>;
        isSelected: import("vue").ComputedRef<boolean>;
        isValid: import("vue").Ref<boolean>;
        handleClick: (ev: MouseEvent) => void;
        handleMouseEnter: () => void;
        handleMouseLeave: () => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        value?: unknown;
        label?: unknown;
        disabled?: unknown;
        tagProps?: unknown;
        extra?: unknown;
        index?: unknown;
        internal?: unknown;
    } & {
        disabled: boolean;
        internal: boolean;
    } & {
        label?: string | undefined;
        value?: string | number | Record<string, any> | undefined;
        tagProps?: import("./tag").TagProps | undefined;
        index?: number | undefined;
        extra?: Record<string, any> | undefined;
    }>, {
        disabled: boolean;
        internal: boolean;
    }>;
    Optgroup: import("vue").DefineComponent<{
        label: {
            type: StringConstructor;
        };
    }, {
        prefixCls: string;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        label?: unknown;
    } & {} & {
        label?: string | undefined;
    }>, {}>;
    SkeletonLine: import("vue").DefineComponent<{
        rows: {
            type: NumberConstructor;
            default: number;
        };
        widths: {
            type: import("vue").PropType<(string | number)[]>;
            default: () => never[];
        };
        lineHeight: {
            type: NumberConstructor;
            default: number;
        };
        lineSpacing: {
            type: NumberConstructor;
            default: number;
        };
    }, {
        prefixCls: string;
        lines: import("vue").CSSProperties[];
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        rows?: unknown;
        widths?: unknown;
        lineHeight?: unknown;
        lineSpacing?: unknown;
    } & {
        lineHeight: number;
        rows: number;
        widths: (string | number)[];
        lineSpacing: number;
    } & {}>, {
        lineHeight: number;
        rows: number;
        widths: (string | number)[];
        lineSpacing: number;
    }>;
    SkeletonShape: import("vue").DefineComponent<{
        shape: {
            type: import("vue").PropType<"circle" | "square">;
            default: string;
        };
        size: {
            type: StringConstructor;
            default: string;
        };
    }, {
        prefixCls: string;
        cls: import("vue").ComputedRef<string[]>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        shape?: unknown;
        size?: unknown;
    } & {
        size: string;
        shape: "circle" | "square";
    } & {}>, {
        size: string;
        shape: "circle" | "square";
    }>;
    Countdown: import("vue").DefineComponent<{
        title: StringConstructor;
        value: {
            type: NumberConstructor;
            default: () => number;
        };
        now: {
            type: NumberConstructor;
            default: () => number;
        };
        format: {
            type: StringConstructor;
            default: string;
        };
        start: {
            type: BooleanConstructor;
            default: boolean;
        };
        valueStyle: {
            type: import("vue").PropType<import("vue").CSSProperties>;
        };
    }, {
        prefixCls: string;
        displayValue: import("vue").Ref<string>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        finish: () => true;
    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        title?: unknown;
        value?: unknown;
        now?: unknown;
        format?: unknown;
        start?: unknown;
        valueStyle?: unknown;
    } & {
        start: boolean;
        value: number;
        format: string;
        now: number;
    } & {
        title?: string | undefined;
        valueStyle?: import("vue").CSSProperties | undefined;
    }> & {
        onFinish?: (() => any) | undefined;
    }, {
        start: boolean;
        value: number;
        format: string;
        now: number;
    }>;
    Step: import("vue").DefineComponent<{
        title: StringConstructor;
        description: StringConstructor;
        status: {
            type: import("vue").PropType<"wait" | "error" | "finish" | "process">;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        prefixCls: string;
        iconCls: string;
        cls: import("vue").ComputedRef<(string | {
            [x: string]: boolean;
        })[]>;
        itemRef: import("vue").Ref<HTMLElement | undefined>;
        showTail: import("vue").ComputedRef<boolean>;
        stepNumber: import("vue").ComputedRef<number>;
        computedStatus: import("vue").ComputedRef<"wait" | "error" | "finish" | "process">;
        type: import("vue").ComputedRef<"default" | "dot" | "arrow" | "navigation">;
        handleClick: (ev: Event) => void;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        title?: unknown;
        description?: unknown;
        status?: unknown;
        disabled?: unknown;
    } & {
        disabled: boolean;
    } & {
        title?: string | undefined;
        description?: string | undefined;
        status?: "wait" | "error" | "finish" | "process" | undefined;
    }>, {
        disabled: boolean;
    }>;
    Thead: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
    Td: import("vue").DefineComponent<{
        rowIndex: NumberConstructor;
        record: {
            type: import("vue").PropType<import("./table/interface").TableDataWithRaw>;
            default: () => {};
        };
        column: {
            type: import("vue").PropType<import("./table").TableColumnData>;
            default: () => {};
        };
        type: {
            type: import("vue").PropType<"normal" | "checkbox" | "radio" | "expand" | "operation">;
            default: string;
        };
        operations: {
            type: import("vue").PropType<import("./table/interface").TableOperationColumn[]>;
            default: () => never[];
        };
        dataColumns: {
            type: import("vue").PropType<import("./table").TableColumnData[]>;
            default: () => never[];
        };
        colSpan: {
            type: NumberConstructor;
            default: number;
        };
        rowSpan: {
            type: NumberConstructor;
            default: number;
        };
        isFixedExpand: {
            type: BooleanConstructor;
            default: boolean;
        };
        containerWidth: {
            type: NumberConstructor;
        };
        showExpandBtn: {
            type: BooleanConstructor;
            default: boolean;
        };
        indentSize: {
            type: NumberConstructor;
            default: number;
        };
        renderExpandBtn: {
            type: import("vue").PropType<(record: import("./table/interface").TableDataWithRaw, stopPropagation?: boolean | undefined) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>>;
        };
        summary: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        rowIndex?: unknown;
        record?: unknown;
        column?: unknown;
        type?: unknown;
        operations?: unknown;
        dataColumns?: unknown;
        colSpan?: unknown;
        rowSpan?: unknown;
        isFixedExpand?: unknown;
        containerWidth?: unknown;
        showExpandBtn?: unknown;
        indentSize?: unknown;
        renderExpandBtn?: unknown;
        summary?: unknown;
    } & {
        column: import("./table").TableColumnData;
        summary: boolean;
        type: "normal" | "checkbox" | "radio" | "expand" | "operation";
        indentSize: number;
        record: import("./table/interface").TableDataWithRaw;
        operations: import("./table/interface").TableOperationColumn[];
        dataColumns: import("./table").TableColumnData[];
        colSpan: number;
        rowSpan: number;
        isFixedExpand: boolean;
        showExpandBtn: boolean;
    } & {
        rowIndex?: number | undefined;
        containerWidth?: number | undefined;
        renderExpandBtn?: ((record: import("./table/interface").TableDataWithRaw, stopPropagation?: boolean | undefined) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
            [key: string]: any;
        }>) | undefined;
    }>, {
        column: import("./table").TableColumnData;
        summary: boolean;
        type: "normal" | "checkbox" | "radio" | "expand" | "operation";
        indentSize: number;
        record: import("./table/interface").TableDataWithRaw;
        operations: import("./table/interface").TableOperationColumn[];
        dataColumns: import("./table").TableColumnData[];
        colSpan: number;
        rowSpan: number;
        isFixedExpand: boolean;
        showExpandBtn: boolean;
    }>;
    Th: import("vue").DefineComponent<{
        column: {
            type: import("vue").PropType<import("./table").TableColumnData>;
            default: () => {};
        };
        operations: {
            type: import("vue").PropType<import("./table/interface").TableOperationColumn[]>;
            default: () => never[];
        };
        dataColumns: {
            type: import("vue").PropType<import("./table").TableColumnData[]>;
            default: () => never[];
        };
        resizable: BooleanConstructor;
    }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        column?: unknown;
        operations?: unknown;
        dataColumns?: unknown;
        resizable?: unknown;
    } & {
        column: import("./table").TableColumnData;
        operations: import("./table/interface").TableOperationColumn[];
        dataColumns: import("./table").TableColumnData[];
        resizable: boolean;
    } & {}>, {
        column: import("./table").TableColumnData;
        operations: import("./table/interface").TableOperationColumn[];
        dataColumns: import("./table").TableColumnData[];
        resizable: boolean;
    }>;
    Tr: import("vue").DefineComponent<{
        expand: {
            type: BooleanConstructor;
        };
        empty: {
            type: BooleanConstructor;
        };
        checked: {
            type: BooleanConstructor;
        };
        rowIndex: NumberConstructor;
        record: {
            type: import("vue").PropType<import("./table/interface").TableDataWithRaw>;
            default: () => {};
        };
    }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        expand?: unknown;
        empty?: unknown;
        checked?: unknown;
        rowIndex?: unknown;
        record?: unknown;
    } & {
        empty: boolean;
        expand: boolean;
        checked: boolean;
        record: import("./table/interface").TableDataWithRaw;
    } & {
        rowIndex?: number | undefined;
    }>, {
        empty: boolean;
        expand: boolean;
        checked: boolean;
        record: import("./table/interface").TableDataWithRaw;
    }>;
    Tbody: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
    TableColumn: import("vue").DefineComponent<{
        dataIndex: StringConstructor;
        title: StringConstructor;
        width: NumberConstructor;
        align: {
            type: import("vue").PropType<"left" | "right" | "center" | undefined>;
        };
        fixed: {
            type: import("vue").PropType<"left" | "right" | undefined>;
        };
        ellipsis: {
            type: BooleanConstructor;
            default: boolean;
        };
        sortable: {
            type: import("vue").PropType<import("./table").TableSortable>;
            default: undefined;
        };
        filterable: {
            type: import("vue").PropType<import("./table").TableFilterable>;
            default: undefined;
        };
        cellClass: {
            type: import("vue").PropType<import("./_utils/types").ClassName>;
        };
        headerCellClass: {
            type: import("vue").PropType<import("./_utils/types").ClassName>;
        };
        bodyCellClass: {
            type: import("vue").PropType<import("./_utils/types").ClassName | ((record: import("./table").TableData) => import("./_utils/types").ClassName)>;
        };
        summaryCellClass: {
            type: import("vue").PropType<import("./_utils/types").ClassName | ((record: import("./table").TableData) => import("./_utils/types").ClassName)>;
        };
        cellStyle: {
            type: import("vue").PropType<import("vue").CSSProperties>;
        };
        headerCellStyle: {
            type: import("vue").PropType<import("vue").CSSProperties>;
        };
        bodyCellStyle: {
            type: import("vue").PropType<import("vue").CSSProperties | ((record: import("./table").TableData) => import("vue").CSSProperties)>;
        };
        summaryCellStyle: {
            type: import("vue").PropType<import("vue").CSSProperties | ((record: import("./table").TableData) => import("vue").CSSProperties)>;
        };
        index: {
            type: NumberConstructor;
        };
        tooltip: {
            type: (ObjectConstructor | BooleanConstructor)[];
            default: boolean;
        };
    }, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
        [key: string]: any;
    }>[] | undefined, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        dataIndex?: unknown;
        title?: unknown;
        width?: unknown;
        align?: unknown;
        fixed?: unknown;
        ellipsis?: unknown;
        sortable?: unknown;
        filterable?: unknown;
        cellClass?: unknown;
        headerCellClass?: unknown;
        bodyCellClass?: unknown;
        summaryCellClass?: unknown;
        cellStyle?: unknown;
        headerCellStyle?: unknown;
        bodyCellStyle?: unknown;
        summaryCellStyle?: unknown;
        index?: unknown;
        tooltip?: unknown;
    } & {
        ellipsis: boolean;
        tooltip: boolean | Record<string, any>;
    } & {
        fixed?: "left" | "right" | undefined;
        title?: string | undefined;
        align?: "left" | "right" | "center" | undefined;
        index?: number | undefined;
        width?: number | undefined;
        dataIndex?: string | undefined;
        sortable?: import("./table").TableSortable | undefined;
        filterable?: import("./table").TableFilterable | undefined;
        cellClass?: import("./_utils/types").ClassName | undefined;
        headerCellClass?: import("./_utils/types").ClassName | undefined;
        bodyCellClass?: import("./_utils/types").ClassName | ((record: import("./table").TableData) => import("./_utils/types").ClassName) | undefined;
        summaryCellClass?: import("./_utils/types").ClassName | ((record: import("./table").TableData) => import("./_utils/types").ClassName) | undefined;
        cellStyle?: import("vue").CSSProperties | undefined;
        headerCellStyle?: import("vue").CSSProperties | undefined;
        bodyCellStyle?: import("vue").CSSProperties | ((record: import("./table").TableData) => import("vue").CSSProperties) | undefined;
        summaryCellStyle?: import("vue").CSSProperties | ((record: import("./table").TableData) => import("vue").CSSProperties) | undefined;
    }>, {
        ellipsis: boolean;
        tooltip: boolean | Record<string, any>;
        sortable: import("./table").TableSortable;
        filterable: import("./table").TableFilterable;
    }>;
    TabPane: import("vue").DefineComponent<{
        title: StringConstructor;
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        closable: {
            type: BooleanConstructor;
            default: boolean;
        };
        destroyOnHide: {
            type: BooleanConstructor;
            default: boolean;
        };
    }, {
        prefixCls: string;
        active: import("vue").ComputedRef<boolean>;
        itemRef: import("vue").Ref<HTMLElement | undefined>;
        mounted: import("vue").Ref<boolean>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        title?: unknown;
        disabled?: unknown;
        closable?: unknown;
        destroyOnHide?: unknown;
    } & {
        disabled: boolean;
        closable: boolean;
        destroyOnHide: boolean;
    } & {
        title?: string | undefined;
    }>, {
        disabled: boolean;
        closable: boolean;
        destroyOnHide: boolean;
    }>;
    TimelineItem: import("vue").DefineComponent<{
        dotColor: {
            type: StringConstructor;
        };
        dotType: {
            type: import("vue").PropType<import("./timeline/interface").DotType>;
            default: string;
        };
        lineType: {
            type: import("vue").PropType<import("./timeline/interface").LineType>;
            default: string;
        };
        lineColor: {
            type: StringConstructor;
        };
        label: {
            type: StringConstructor;
        };
        position: {
            type: import("vue").PropType<import("./timeline/interface").PositionType>;
        };
    }, {
        cls: import("vue").ComputedRef<(string | {
            [x: string]: boolean | "horizontal" | "vertical" | import("./timeline/interface").LabelPositionType | undefined;
        })[]>;
        dotLineCls: import("vue").ComputedRef<string[]>;
        dotTypeCls: import("vue").ComputedRef<string[]>;
        prefixCls: string;
        computedDotLineStyle: import("vue").ComputedRef<{
            borderColor?: string | undefined;
        }>;
        computedDotStyle: import("vue").ComputedRef<{
            [x: string]: string | undefined;
        }>;
        labelPosition: import("vue").ComputedRef<import("./timeline/interface").LabelPositionType>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        dotColor?: unknown;
        dotType?: unknown;
        lineType?: unknown;
        lineColor?: unknown;
        label?: unknown;
        position?: unknown;
    } & {
        dotType: import("./timeline/interface").DotType;
        lineType: import("./timeline/interface").LineType;
    } & {
        position?: import("./timeline/interface").PositionType | undefined;
        label?: string | undefined;
        dotColor?: string | undefined;
        lineColor?: string | undefined;
    }>, {
        dotType: import("./timeline/interface").DotType;
        lineType: import("./timeline/interface").LineType;
    }>;
    TypographyParagraph: import("vue").DefineComponent<{
        blockquote: {
            type: BooleanConstructor;
        };
        spacing: {
            type: import("vue").PropType<"default" | "close">;
            default: string;
        };
    }, {
        component: import("vue").ComputedRef<"div" | "blockquote">;
        classNames: import("vue").ComputedRef<{
            [x: string]: boolean;
        }[]>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        blockquote?: unknown;
        spacing?: unknown;
    } & {
        blockquote: boolean;
        spacing: "default" | "close";
    } & {}>, {
        blockquote: boolean;
        spacing: "default" | "close";
    }>;
    TypographyTitle: import("vue").DefineComponent<{
        heading: {
            type: import("vue").PropType<2 | 1 | 4 | 3 | 5 | 6>;
            default: number;
        };
    }, {
        component: import("vue").ComputedRef<keyof HTMLElementTagNameMap>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        heading?: unknown;
    } & {
        heading: 2 | 1 | 4 | 3 | 5 | 6;
    } & {}>, {
        heading: 2 | 1 | 4 | 3 | 5 | 6;
    }>;
    TypographyText: import("vue").DefineComponent<{
        ellipsis: {
            type: import("vue").PropType<boolean | import("./typography").EllipsisConfig>;
            default: boolean;
        };
    }, {
        component: import("vue").ComputedRef<"div" | "span">;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        ellipsis?: unknown;
    } & {
        ellipsis: boolean | import("./typography").EllipsisConfig;
    } & {}>, {
        ellipsis: boolean | import("./typography").EllipsisConfig;
    }>;
    install: (app: App, options?: ArcoOptions | undefined) => void;
    addI18nMessages: (messages: import("./locale/interface").ArcoI18nMessages, options?: {
        overwrite?: boolean | undefined;
    } | undefined) => void;
    useLocale: (locale: string) => void;
    getLocale: () => string;
    useFormItem: ({ size, disabled, error, uninject, }?: {
        size?: import("vue").Ref<"mini" | "medium" | "large" | "small" | undefined> | undefined;
        disabled?: import("vue").Ref<boolean> | undefined;
        error?: import("vue").Ref<boolean> | undefined;
        uninject?: boolean | undefined;
    }) => {
        formItemCtx: import("./form/context").FormItemContext;
        mergedSize: import("vue").ComputedRef<"mini" | "medium" | "large" | "small" | undefined>;
        mergedDisabled: import("vue").ComputedRef<boolean>;
        mergedError: import("vue").ComputedRef<boolean>;
        feedback: import("vue").Ref<string | undefined>;
        eventHandlers: import("vue").Ref<import("./form").FormItemEventHandler>;
    };
};
export default ArcoVue;