import { type PropType, type VNodeChild } from 'vue';
import type { RenderTagParam, SelectOption, SelectTagWithCollapse } from './interface';
declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    readonly selectedOptions: {
        readonly type: PropType<SelectOption[]>;
        readonly default: () => SelectOption[];
    };
    readonly disabled: BooleanConstructor;
    readonly clearable: BooleanConstructor;
    readonly isOpened: BooleanConstructor;
    readonly multiple: BooleanConstructor;
    readonly filterable: BooleanConstructor;
    readonly placeholder: StringConstructor;
    readonly collapseTags: BooleanConstructor;
    readonly collapseTagsLimit: NumberConstructor;
    readonly renderTag: PropType<(option: RenderTagParam) => VNodeChild>;
    readonly tagBordered: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>, {
    prefixCls: string;
    inputHoveringRef: import("vue").Ref<boolean, boolean>;
    hasClearRef: import("vue").ComputedRef<boolean>;
    triggerClass: import("vue").ComputedRef<{
        [x: string]: boolean;
        'is-active': boolean;
        'is-disabled': boolean;
        'is-multiple': boolean;
    }>;
    unSelectedRef: import("vue").ComputedRef<boolean>;
    handleRemove: (index: number) => void;
    handleClear: () => void;
    handleFocus: (event: Event) => void;
    handleBlur: (event: Event) => void;
    inputRef: import("vue").Ref<any, any>;
    filterTextRef: import("vue").Ref<string, string>;
    handleCompositionStart: () => void;
    handleCompositionUpdate: (event: Event) => void;
    handleCompositionEnd: (event: Event) => void;
    handleInput: (e: Event) => void;
    labelTextRef: import("vue").ComputedRef<string>;
    multiLabelRef: import("vue").ComputedRef<SelectTagWithCollapse[]>;
    calcCollapseTagIndex: (collapseTagIndex: number) => number;
    handleMouseDown: (e: Event) => void;
    isComposingRef: import("vue").Ref<boolean, boolean>;
    compositionValueRef: import("vue").Ref<string, string>;
    inputWidthRef: import("vue").ComputedRef<string>;
    hasTagBordered: import("vue").ComputedRef<boolean>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("clear" | "blur" | "focus" | "input" | "remove")[], "clear" | "blur" | "focus" | "input" | "remove", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    readonly selectedOptions: {
        readonly type: PropType<SelectOption[]>;
        readonly default: () => SelectOption[];
    };
    readonly disabled: BooleanConstructor;
    readonly clearable: BooleanConstructor;
    readonly isOpened: BooleanConstructor;
    readonly multiple: BooleanConstructor;
    readonly filterable: BooleanConstructor;
    readonly placeholder: StringConstructor;
    readonly collapseTags: BooleanConstructor;
    readonly collapseTagsLimit: NumberConstructor;
    readonly renderTag: PropType<(option: RenderTagParam) => VNodeChild>;
    readonly tagBordered: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
}>> & Readonly<{
    onFocus?: (...args: any[]) => any;
    onBlur?: (...args: any[]) => any;
    onInput?: (...args: any[]) => any;
    onClear?: (...args: any[]) => any;
    onRemove?: (...args: any[]) => any;
}>, {
    readonly disabled: boolean;
    readonly multiple: boolean;
    readonly isOpened: boolean;
    readonly clearable: boolean;
    readonly selectedOptions: SelectOption[];
    readonly tagBordered: boolean;
    readonly filterable: boolean;
    readonly collapseTags: boolean;
}, {}, {
    Tag: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            type: {
                readonly type: PropType<import("../tag/interface").Type>;
                readonly default: "default";
            };
            closable: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            backgroundColor: {
                readonly type: StringConstructor;
                readonly default: "";
            };
            size: {
                readonly type: PropType<import("../tag/interface").Size>;
                readonly default: "middle";
            };
            effect: {
                readonly type: PropType<import("../tag/interface").Effect>;
                readonly default: "light";
            };
            bordered: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
        }>> & Readonly<{
            onClose?: (...args: any[]) => any;
            onClick?: (...args: any[]) => any;
        }>, {
            prefixCls: string;
            classes: import("vue").ComputedRef<{
                [x: string]: boolean | import("../tag/interface").Type | import("../tag/interface").Size | import("../tag/interface").Effect;
                'is-bordered': boolean;
            }>;
            handleClose: (event: Event) => void;
            handleClick: (event: Event) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "click")[], import("vue").PublicProps, {
            type: import("../tag/interface").Type;
            size: import("../tag/interface").Size;
            closable: boolean;
            bordered: boolean;
            backgroundColor: string;
            effect: import("../tag/interface").Effect;
        }, true, {}, {}, {
            CloseCircleFilled: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
            CloseCircleOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            type: {
                readonly type: PropType<import("../tag/interface").Type>;
                readonly default: "default";
            };
            closable: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            backgroundColor: {
                readonly type: StringConstructor;
                readonly default: "";
            };
            size: {
                readonly type: PropType<import("../tag/interface").Size>;
                readonly default: "middle";
            };
            effect: {
                readonly type: PropType<import("../tag/interface").Effect>;
                readonly default: "light";
            };
            bordered: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
        }>> & Readonly<{
            onClose?: (...args: any[]) => any;
            onClick?: (...args: any[]) => any;
        }>, {
            prefixCls: string;
            classes: import("vue").ComputedRef<{
                [x: string]: boolean | import("../tag/interface").Type | import("../tag/interface").Size | import("../tag/interface").Effect;
                'is-bordered': boolean;
            }>;
            handleClose: (event: Event) => void;
            handleClick: (event: Event) => void;
        }, {}, {}, {}, {
            type: import("../tag/interface").Type;
            size: import("../tag/interface").Size;
            closable: boolean;
            bordered: boolean;
            backgroundColor: string;
            effect: import("../tag/interface").Effect;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        type: {
            readonly type: PropType<import("../tag/interface").Type>;
            readonly default: "default";
        };
        closable: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        backgroundColor: {
            readonly type: StringConstructor;
            readonly default: "";
        };
        size: {
            readonly type: PropType<import("../tag/interface").Size>;
            readonly default: "middle";
        };
        effect: {
            readonly type: PropType<import("../tag/interface").Effect>;
            readonly default: "light";
        };
        bordered: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
    }>> & Readonly<{
        onClose?: (...args: any[]) => any;
        onClick?: (...args: any[]) => any;
    }>, {
        prefixCls: string;
        classes: import("vue").ComputedRef<{
            [x: string]: boolean | import("../tag/interface").Type | import("../tag/interface").Size | import("../tag/interface").Effect;
            'is-bordered': boolean;
        }>;
        handleClose: (event: Event) => void;
        handleClick: (event: Event) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "click")[], "close" | "click", {
        type: import("../tag/interface").Type;
        size: import("../tag/interface").Size;
        closable: boolean;
        bordered: boolean;
        backgroundColor: string;
        effect: import("../tag/interface").Effect;
    }, {}, string, {}, {
        CloseCircleFilled: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
        CloseCircleOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
    Scrollbar: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            readonly shadow: {
                type: PropType<import("../scrollbar/const").ShadowType>;
                default: boolean;
            };
            readonly height: {
                type: PropType<string | number>;
            };
            readonly maxHeight: {
                type: PropType<string | number>;
            };
            readonly native: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly always: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly minSize: {
                type: NumberConstructor;
                default: number;
            };
            readonly horizontalRatioStyle: {
                type: PropType<import("vue").StyleValue>;
            };
            readonly verticalRatioStyle: {
                type: PropType<import("vue").StyleValue>;
            };
            readonly shadowStyle: {
                type: PropType<import("vue").StyleValue>;
            };
            readonly containerClass: PropType<string | object | []>;
            readonly containerStyle: PropType<import("vue").StyleValue>;
            readonly contentStyle: PropType<import("vue").StyleValue>;
            readonly thumbStyle: PropType<import("vue").StyleValue>;
            readonly noresize: BooleanConstructor;
        }>> & Readonly<{
            onScroll?: (...args: any[]) => any;
        }>, {
            scrollbarRef: import("vue").Ref<HTMLElement, HTMLElement>;
            containerRef: import("vue").Ref<HTMLElement, HTMLElement>;
            contentRef: import("vue").Ref<HTMLElement, HTMLElement>;
            style: import("vue").ComputedRef<import("vue").StyleValue[]>;
            prefixCls: string;
            setScrollTop: (val: number, duration: number) => void;
            setScrollLeft: (val: number, duration: number) => void;
            scrollToEnd: (direction: "right" | "bottom", duration: number) => void;
            update: () => void;
            handleScroll: (event: Event) => void;
            thumbMoveX: import("vue").Ref<number, number>;
            thumbMoveY: import("vue").Ref<number, number>;
            ratioX: import("vue").Ref<number, number>;
            ratioY: import("vue").Ref<number, number>;
            sizeHeight: import("vue").Ref<string, string>;
            sizeWidth: import("vue").Ref<string, string>;
            wrapperClassRef: import("vue").ComputedRef<string[]>;
            containerClassRef: import("vue").ComputedRef<(string | object)[]>;
            scrollX: import("vue").Ref<boolean, boolean>;
            scrollXRatio: import("vue").Ref<number, number>;
            scrollY: import("vue").Ref<boolean, boolean>;
            scrollYRatio: import("vue").Ref<number, number>;
            shadowRef: import("vue").ComputedRef<{
                x: boolean;
                y: boolean;
            }>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scroll"[], import("vue").PublicProps, {
            readonly shadow: import("../scrollbar/const").ShadowType;
            readonly always: boolean;
            readonly native: boolean;
            readonly minSize: number;
            readonly noresize: boolean;
        }, true, {}, {}, {
            FBar: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                readonly vertical: BooleanConstructor;
                readonly size: StringConstructor;
                readonly move: NumberConstructor;
                readonly ratio: NumberConstructor;
                readonly always: BooleanConstructor;
                readonly scrollbarRef: PropType<HTMLElement[]>;
                readonly containerRef: PropType<HTMLElement>;
                readonly thumbStyle: PropType<import("vue").StyleValue>;
            }>, {
                prefixCls: string;
                barRef: import("vue").Ref<HTMLElement, HTMLElement>;
                thumbRef: import("vue").Ref<any, any>;
                visible: import("vue").Ref<boolean, boolean>;
                cursorDown: import("vue").Ref<any, any>;
                barMap: import("vue").ComputedRef<{
                    readonly offset: "offsetHeight";
                    readonly scroll: "scrollTop";
                    readonly scrollSize: "scrollHeight";
                    readonly size: "height";
                    readonly key: "vertical";
                    readonly axis: "Y";
                    readonly client: "clientY";
                    readonly direction: "top";
                } | {
                    readonly offset: "offsetWidth";
                    readonly scroll: "scrollLeft";
                    readonly scrollSize: "scrollWidth";
                    readonly size: "width";
                    readonly key: "horizontal";
                    readonly axis: "X";
                    readonly client: "clientX";
                    readonly direction: "left";
                }>;
                thumbStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
                clickTrackHandler: (e: MouseEvent) => void;
                clickThumbHandler: (e: MouseEvent) => void;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                readonly vertical: BooleanConstructor;
                readonly size: StringConstructor;
                readonly move: NumberConstructor;
                readonly ratio: NumberConstructor;
                readonly always: BooleanConstructor;
                readonly scrollbarRef: PropType<HTMLElement[]>;
                readonly containerRef: PropType<HTMLElement>;
                readonly thumbStyle: PropType<import("vue").StyleValue>;
            }>> & Readonly<{}>, {
                readonly always: boolean;
                readonly vertical: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            readonly shadow: {
                type: PropType<import("../scrollbar/const").ShadowType>;
                default: boolean;
            };
            readonly height: {
                type: PropType<string | number>;
            };
            readonly maxHeight: {
                type: PropType<string | number>;
            };
            readonly native: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly always: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly minSize: {
                type: NumberConstructor;
                default: number;
            };
            readonly horizontalRatioStyle: {
                type: PropType<import("vue").StyleValue>;
            };
            readonly verticalRatioStyle: {
                type: PropType<import("vue").StyleValue>;
            };
            readonly shadowStyle: {
                type: PropType<import("vue").StyleValue>;
            };
            readonly containerClass: PropType<string | object | []>;
            readonly containerStyle: PropType<import("vue").StyleValue>;
            readonly contentStyle: PropType<import("vue").StyleValue>;
            readonly thumbStyle: PropType<import("vue").StyleValue>;
            readonly noresize: BooleanConstructor;
        }>> & Readonly<{
            onScroll?: (...args: any[]) => any;
        }>, {
            scrollbarRef: import("vue").Ref<HTMLElement, HTMLElement>;
            containerRef: import("vue").Ref<HTMLElement, HTMLElement>;
            contentRef: import("vue").Ref<HTMLElement, HTMLElement>;
            style: import("vue").ComputedRef<import("vue").StyleValue[]>;
            prefixCls: string;
            setScrollTop: (val: number, duration: number) => void;
            setScrollLeft: (val: number, duration: number) => void;
            scrollToEnd: (direction: "right" | "bottom", duration: number) => void;
            update: () => void;
            handleScroll: (event: Event) => void;
            thumbMoveX: import("vue").Ref<number, number>;
            thumbMoveY: import("vue").Ref<number, number>;
            ratioX: import("vue").Ref<number, number>;
            ratioY: import("vue").Ref<number, number>;
            sizeHeight: import("vue").Ref<string, string>;
            sizeWidth: import("vue").Ref<string, string>;
            wrapperClassRef: import("vue").ComputedRef<string[]>;
            containerClassRef: import("vue").ComputedRef<(string | object)[]>;
            scrollX: import("vue").Ref<boolean, boolean>;
            scrollXRatio: import("vue").Ref<number, number>;
            scrollY: import("vue").Ref<boolean, boolean>;
            scrollYRatio: import("vue").Ref<number, number>;
            shadowRef: import("vue").ComputedRef<{
                x: boolean;
                y: boolean;
            }>;
        }, {}, {}, {}, {
            readonly shadow: import("../scrollbar/const").ShadowType;
            readonly always: boolean;
            readonly native: boolean;
            readonly minSize: number;
            readonly noresize: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        readonly shadow: {
            type: PropType<import("../scrollbar/const").ShadowType>;
            default: boolean;
        };
        readonly height: {
            type: PropType<string | number>;
        };
        readonly maxHeight: {
            type: PropType<string | number>;
        };
        readonly native: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly always: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly minSize: {
            type: NumberConstructor;
            default: number;
        };
        readonly horizontalRatioStyle: {
            type: PropType<import("vue").StyleValue>;
        };
        readonly verticalRatioStyle: {
            type: PropType<import("vue").StyleValue>;
        };
        readonly shadowStyle: {
            type: PropType<import("vue").StyleValue>;
        };
        readonly containerClass: PropType<string | object | []>;
        readonly containerStyle: PropType<import("vue").StyleValue>;
        readonly contentStyle: PropType<import("vue").StyleValue>;
        readonly thumbStyle: PropType<import("vue").StyleValue>;
        readonly noresize: BooleanConstructor;
    }>> & Readonly<{
        onScroll?: (...args: any[]) => any;
    }>, {
        scrollbarRef: import("vue").Ref<HTMLElement, HTMLElement>;
        containerRef: import("vue").Ref<HTMLElement, HTMLElement>;
        contentRef: import("vue").Ref<HTMLElement, HTMLElement>;
        style: import("vue").ComputedRef<import("vue").StyleValue[]>;
        prefixCls: string;
        setScrollTop: (val: number, duration: number) => void;
        setScrollLeft: (val: number, duration: number) => void;
        scrollToEnd: (direction: "right" | "bottom", duration: number) => void;
        update: () => void;
        handleScroll: (event: Event) => void;
        thumbMoveX: import("vue").Ref<number, number>;
        thumbMoveY: import("vue").Ref<number, number>;
        ratioX: import("vue").Ref<number, number>;
        ratioY: import("vue").Ref<number, number>;
        sizeHeight: import("vue").Ref<string, string>;
        sizeWidth: import("vue").Ref<string, string>;
        wrapperClassRef: import("vue").ComputedRef<string[]>;
        containerClassRef: import("vue").ComputedRef<(string | object)[]>;
        scrollX: import("vue").Ref<boolean, boolean>;
        scrollXRatio: import("vue").Ref<number, number>;
        scrollY: import("vue").Ref<boolean, boolean>;
        scrollYRatio: import("vue").Ref<number, number>;
        shadowRef: import("vue").ComputedRef<{
            x: boolean;
            y: boolean;
        }>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scroll"[], "scroll", {
        readonly shadow: import("../scrollbar/const").ShadowType;
        readonly always: boolean;
        readonly native: boolean;
        readonly minSize: number;
        readonly noresize: boolean;
    }, {}, string, {}, {
        FBar: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            readonly vertical: BooleanConstructor;
            readonly size: StringConstructor;
            readonly move: NumberConstructor;
            readonly ratio: NumberConstructor;
            readonly always: BooleanConstructor;
            readonly scrollbarRef: PropType<HTMLElement[]>;
            readonly containerRef: PropType<HTMLElement>;
            readonly thumbStyle: PropType<import("vue").StyleValue>;
        }>, {
            prefixCls: string;
            barRef: import("vue").Ref<HTMLElement, HTMLElement>;
            thumbRef: import("vue").Ref<any, any>;
            visible: import("vue").Ref<boolean, boolean>;
            cursorDown: import("vue").Ref<any, any>;
            barMap: import("vue").ComputedRef<{
                readonly offset: "offsetHeight";
                readonly scroll: "scrollTop";
                readonly scrollSize: "scrollHeight";
                readonly size: "height";
                readonly key: "vertical";
                readonly axis: "Y";
                readonly client: "clientY";
                readonly direction: "top";
            } | {
                readonly offset: "offsetWidth";
                readonly scroll: "scrollLeft";
                readonly scrollSize: "scrollWidth";
                readonly size: "width";
                readonly key: "horizontal";
                readonly axis: "X";
                readonly client: "clientX";
                readonly direction: "left";
            }>;
            thumbStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
            clickTrackHandler: (e: MouseEvent) => void;
            clickThumbHandler: (e: MouseEvent) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            readonly vertical: BooleanConstructor;
            readonly size: StringConstructor;
            readonly move: NumberConstructor;
            readonly ratio: NumberConstructor;
            readonly always: BooleanConstructor;
            readonly scrollbarRef: PropType<HTMLElement[]>;
            readonly containerRef: PropType<HTMLElement>;
            readonly thumbStyle: PropType<import("vue").StyleValue>;
        }>> & Readonly<{}>, {
            readonly always: boolean;
            readonly vertical: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
    Ellipsis: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            readonly content: PropType<string | number>;
            readonly line: {
                readonly type: PropType<string | number>;
                readonly default: 1;
            };
            readonly tooltip: {
                readonly type: PropType<boolean | import("../tooltip").ToolTipProps>;
                readonly default: () => import("../tooltip").ToolTipProps;
            };
            readonly class: PropType<string | object | []>;
            readonly style: {
                readonly type: PropType<string | import("vue").CSSProperties>;
                readonly default: () => {};
            };
        }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
            readonly style: string | import("vue").CSSProperties;
            readonly tooltip: import("../tooltip").ToolTipProps;
            readonly line: string | number;
        }, true, {}, {}, {
            Tooltip: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                    readonly title: PropType<string | number>;
                    readonly content: PropType<string | number>;
                    readonly mode: {
                        readonly type: PropType<"text" | "confirm" | "popover">;
                        readonly default: "text";
                    };
                    readonly confirmOption: {
                        readonly type: ObjectConstructor;
                        readonly default: () => {
                            okText: string;
                            cancelText: string;
                            showOk: boolean;
                            showCancel: boolean;
                            icon: import("vue/jsx-runtime").JSX.Element;
                        };
                    };
                    readonly arrow: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly offset: {
                        readonly type: NumberConstructor;
                        readonly default: 8;
                    };
                    readonly modelValue: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly trigger: {
                        readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                        readonly default: "hover";
                    };
                    readonly placement: {
                        readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        readonly default: "bottom";
                    };
                    readonly disabled: {
                        readonly type: PropType<boolean | (() => boolean)>;
                        readonly default: false;
                    };
                    readonly appendToContainer: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly popperClass: PropType<string | object | []>;
                    readonly popperStyle: {
                        readonly type: PropType<import("vue").StyleValue>;
                        readonly default: () => {};
                    };
                    readonly showAfter: {
                        readonly type: NumberConstructor;
                        readonly default: 0;
                    };
                    readonly hideAfter: {
                        readonly type: NumberConstructor;
                        readonly default: 200;
                    };
                    readonly getContainer: {
                        readonly type: FunctionConstructor;
                    };
                    readonly lazy: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly onlyShowTrigger: {
                        readonly type: BooleanConstructor;
                    };
                    readonly passive: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                }>> & Readonly<{
                    "onUpdate:modelValue"?: (...args: any[]) => any;
                    onCancel?: (...args: any[]) => any;
                    onClickOutside?: (...args: any[]) => any;
                    onOk?: (...args: any[]) => any;
                }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "cancel" | "clickOutside" | "ok")[], import("vue").PublicProps, {
                    readonly disabled: boolean | (() => boolean);
                    readonly trigger: "click" | "hover" | "contextmenu" | "focus";
                    readonly mode: "text" | "confirm" | "popover";
                    readonly modelValue: boolean;
                    readonly arrow: boolean;
                    readonly appendToContainer: boolean;
                    readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
                    readonly offset: number;
                    readonly popperStyle: import("vue").StyleValue;
                    readonly showAfter: number;
                    readonly hideAfter: number;
                    readonly lazy: boolean;
                    readonly onlyShowTrigger: boolean;
                    readonly passive: boolean;
                    readonly confirmOption: Record<string, any>;
                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import("vue").ExtractPropTypes<{
                    readonly title: PropType<string | number>;
                    readonly content: PropType<string | number>;
                    readonly mode: {
                        readonly type: PropType<"text" | "confirm" | "popover">;
                        readonly default: "text";
                    };
                    readonly confirmOption: {
                        readonly type: ObjectConstructor;
                        readonly default: () => {
                            okText: string;
                            cancelText: string;
                            showOk: boolean;
                            showCancel: boolean;
                            icon: import("vue/jsx-runtime").JSX.Element;
                        };
                    };
                    readonly arrow: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly offset: {
                        readonly type: NumberConstructor;
                        readonly default: 8;
                    };
                    readonly modelValue: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly trigger: {
                        readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                        readonly default: "hover";
                    };
                    readonly placement: {
                        readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        readonly default: "bottom";
                    };
                    readonly disabled: {
                        readonly type: PropType<boolean | (() => boolean)>;
                        readonly default: false;
                    };
                    readonly appendToContainer: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly popperClass: PropType<string | object | []>;
                    readonly popperStyle: {
                        readonly type: PropType<import("vue").StyleValue>;
                        readonly default: () => {};
                    };
                    readonly showAfter: {
                        readonly type: NumberConstructor;
                        readonly default: 0;
                    };
                    readonly hideAfter: {
                        readonly type: NumberConstructor;
                        readonly default: 200;
                    };
                    readonly getContainer: {
                        readonly type: FunctionConstructor;
                    };
                    readonly lazy: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly onlyShowTrigger: {
                        readonly type: BooleanConstructor;
                    };
                    readonly passive: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                }>> & Readonly<{
                    "onUpdate:modelValue"?: (...args: any[]) => any;
                    onCancel?: (...args: any[]) => any;
                    onClickOutside?: (...args: any[]) => any;
                    onOk?: (...args: any[]) => any;
                }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                    readonly disabled: boolean | (() => boolean);
                    readonly trigger: "click" | "hover" | "contextmenu" | "focus";
                    readonly mode: "text" | "confirm" | "popover";
                    readonly modelValue: boolean;
                    readonly arrow: boolean;
                    readonly appendToContainer: boolean;
                    readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
                    readonly offset: number;
                    readonly popperStyle: import("vue").StyleValue;
                    readonly showAfter: number;
                    readonly hideAfter: number;
                    readonly lazy: boolean;
                    readonly onlyShowTrigger: boolean;
                    readonly passive: boolean;
                    readonly confirmOption: Record<string, any>;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                readonly title: PropType<string | number>;
                readonly content: PropType<string | number>;
                readonly mode: {
                    readonly type: PropType<"text" | "confirm" | "popover">;
                    readonly default: "text";
                };
                readonly confirmOption: {
                    readonly type: ObjectConstructor;
                    readonly default: () => {
                        okText: string;
                        cancelText: string;
                        showOk: boolean;
                        showCancel: boolean;
                        icon: import("vue/jsx-runtime").JSX.Element;
                    };
                };
                readonly arrow: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly offset: {
                    readonly type: NumberConstructor;
                    readonly default: 8;
                };
                readonly modelValue: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly trigger: {
                    readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                    readonly default: "hover";
                };
                readonly placement: {
                    readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    readonly default: "bottom";
                };
                readonly disabled: {
                    readonly type: PropType<boolean | (() => boolean)>;
                    readonly default: false;
                };
                readonly appendToContainer: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly popperClass: PropType<string | object | []>;
                readonly popperStyle: {
                    readonly type: PropType<import("vue").StyleValue>;
                    readonly default: () => {};
                };
                readonly showAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 0;
                };
                readonly hideAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 200;
                };
                readonly getContainer: {
                    readonly type: FunctionConstructor;
                };
                readonly lazy: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly onlyShowTrigger: {
                    readonly type: BooleanConstructor;
                };
                readonly passive: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
            }>> & Readonly<{
                "onUpdate:modelValue"?: (...args: any[]) => any;
                onCancel?: (...args: any[]) => any;
                onClickOutside?: (...args: any[]) => any;
                onOk?: (...args: any[]) => any;
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "cancel" | "clickOutside" | "ok")[], "update:modelValue" | "cancel" | "clickOutside" | "ok", {
                readonly disabled: boolean | (() => boolean);
                readonly trigger: "click" | "hover" | "contextmenu" | "focus";
                readonly mode: "text" | "confirm" | "popover";
                readonly modelValue: boolean;
                readonly arrow: boolean;
                readonly appendToContainer: boolean;
                readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
                readonly offset: number;
                readonly popperStyle: import("vue").StyleValue;
                readonly showAfter: number;
                readonly hideAfter: number;
                readonly lazy: boolean;
                readonly onlyShowTrigger: boolean;
                readonly passive: boolean;
                readonly confirmOption: Record<string, any>;
            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            readonly content: PropType<string | number>;
            readonly line: {
                readonly type: PropType<string | number>;
                readonly default: 1;
            };
            readonly tooltip: {
                readonly type: PropType<boolean | import("../tooltip").ToolTipProps>;
                readonly default: () => import("../tooltip").ToolTipProps;
            };
            readonly class: PropType<string | object | []>;
            readonly style: {
                readonly type: PropType<string | import("vue").CSSProperties>;
                readonly default: () => {};
            };
        }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
            readonly style: string | import("vue").CSSProperties;
            readonly tooltip: import("../tooltip").ToolTipProps;
            readonly line: string | number;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        readonly content: PropType<string | number>;
        readonly line: {
            readonly type: PropType<string | number>;
            readonly default: 1;
        };
        readonly tooltip: {
            readonly type: PropType<boolean | import("../tooltip").ToolTipProps>;
            readonly default: () => import("../tooltip").ToolTipProps;
        };
        readonly class: PropType<string | object | []>;
        readonly style: {
            readonly type: PropType<string | import("vue").CSSProperties>;
            readonly default: () => {};
        };
    }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
        readonly style: string | import("vue").CSSProperties;
        readonly tooltip: import("../tooltip").ToolTipProps;
        readonly line: string | number;
    }, {}, string, {}, {
        Tooltip: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                readonly title: PropType<string | number>;
                readonly content: PropType<string | number>;
                readonly mode: {
                    readonly type: PropType<"text" | "confirm" | "popover">;
                    readonly default: "text";
                };
                readonly confirmOption: {
                    readonly type: ObjectConstructor;
                    readonly default: () => {
                        okText: string;
                        cancelText: string;
                        showOk: boolean;
                        showCancel: boolean;
                        icon: import("vue/jsx-runtime").JSX.Element;
                    };
                };
                readonly arrow: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly offset: {
                    readonly type: NumberConstructor;
                    readonly default: 8;
                };
                readonly modelValue: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly trigger: {
                    readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                    readonly default: "hover";
                };
                readonly placement: {
                    readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    readonly default: "bottom";
                };
                readonly disabled: {
                    readonly type: PropType<boolean | (() => boolean)>;
                    readonly default: false;
                };
                readonly appendToContainer: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly popperClass: PropType<string | object | []>;
                readonly popperStyle: {
                    readonly type: PropType<import("vue").StyleValue>;
                    readonly default: () => {};
                };
                readonly showAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 0;
                };
                readonly hideAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 200;
                };
                readonly getContainer: {
                    readonly type: FunctionConstructor;
                };
                readonly lazy: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly onlyShowTrigger: {
                    readonly type: BooleanConstructor;
                };
                readonly passive: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
            }>> & Readonly<{
                "onUpdate:modelValue"?: (...args: any[]) => any;
                onCancel?: (...args: any[]) => any;
                onClickOutside?: (...args: any[]) => any;
                onOk?: (...args: any[]) => any;
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "cancel" | "clickOutside" | "ok")[], import("vue").PublicProps, {
                readonly disabled: boolean | (() => boolean);
                readonly trigger: "click" | "hover" | "contextmenu" | "focus";
                readonly mode: "text" | "confirm" | "popover";
                readonly modelValue: boolean;
                readonly arrow: boolean;
                readonly appendToContainer: boolean;
                readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
                readonly offset: number;
                readonly popperStyle: import("vue").StyleValue;
                readonly showAfter: number;
                readonly hideAfter: number;
                readonly lazy: boolean;
                readonly onlyShowTrigger: boolean;
                readonly passive: boolean;
                readonly confirmOption: Record<string, any>;
            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("vue").ExtractPropTypes<{
                readonly title: PropType<string | number>;
                readonly content: PropType<string | number>;
                readonly mode: {
                    readonly type: PropType<"text" | "confirm" | "popover">;
                    readonly default: "text";
                };
                readonly confirmOption: {
                    readonly type: ObjectConstructor;
                    readonly default: () => {
                        okText: string;
                        cancelText: string;
                        showOk: boolean;
                        showCancel: boolean;
                        icon: import("vue/jsx-runtime").JSX.Element;
                    };
                };
                readonly arrow: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly offset: {
                    readonly type: NumberConstructor;
                    readonly default: 8;
                };
                readonly modelValue: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly trigger: {
                    readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                    readonly default: "hover";
                };
                readonly placement: {
                    readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    readonly default: "bottom";
                };
                readonly disabled: {
                    readonly type: PropType<boolean | (() => boolean)>;
                    readonly default: false;
                };
                readonly appendToContainer: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly popperClass: PropType<string | object | []>;
                readonly popperStyle: {
                    readonly type: PropType<import("vue").StyleValue>;
                    readonly default: () => {};
                };
                readonly showAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 0;
                };
                readonly hideAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 200;
                };
                readonly getContainer: {
                    readonly type: FunctionConstructor;
                };
                readonly lazy: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly onlyShowTrigger: {
                    readonly type: BooleanConstructor;
                };
                readonly passive: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
            }>> & Readonly<{
                "onUpdate:modelValue"?: (...args: any[]) => any;
                onCancel?: (...args: any[]) => any;
                onClickOutside?: (...args: any[]) => any;
                onOk?: (...args: any[]) => any;
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                readonly disabled: boolean | (() => boolean);
                readonly trigger: "click" | "hover" | "contextmenu" | "focus";
                readonly mode: "text" | "confirm" | "popover";
                readonly modelValue: boolean;
                readonly arrow: boolean;
                readonly appendToContainer: boolean;
                readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
                readonly offset: number;
                readonly popperStyle: import("vue").StyleValue;
                readonly showAfter: number;
                readonly hideAfter: number;
                readonly lazy: boolean;
                readonly onlyShowTrigger: boolean;
                readonly passive: boolean;
                readonly confirmOption: Record<string, any>;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            readonly title: PropType<string | number>;
            readonly content: PropType<string | number>;
            readonly mode: {
                readonly type: PropType<"text" | "confirm" | "popover">;
                readonly default: "text";
            };
            readonly confirmOption: {
                readonly type: ObjectConstructor;
                readonly default: () => {
                    okText: string;
                    cancelText: string;
                    showOk: boolean;
                    showCancel: boolean;
                    icon: import("vue/jsx-runtime").JSX.Element;
                };
            };
            readonly arrow: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly offset: {
                readonly type: NumberConstructor;
                readonly default: 8;
            };
            readonly modelValue: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly trigger: {
                readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                readonly default: "hover";
            };
            readonly placement: {
                readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                readonly default: "bottom";
            };
            readonly disabled: {
                readonly type: PropType<boolean | (() => boolean)>;
                readonly default: false;
            };
            readonly appendToContainer: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly popperClass: PropType<string | object | []>;
            readonly popperStyle: {
                readonly type: PropType<import("vue").StyleValue>;
                readonly default: () => {};
            };
            readonly showAfter: {
                readonly type: NumberConstructor;
                readonly default: 0;
            };
            readonly hideAfter: {
                readonly type: NumberConstructor;
                readonly default: 200;
            };
            readonly getContainer: {
                readonly type: FunctionConstructor;
            };
            readonly lazy: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly onlyShowTrigger: {
                readonly type: BooleanConstructor;
            };
            readonly passive: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
        }>> & Readonly<{
            "onUpdate:modelValue"?: (...args: any[]) => any;
            onCancel?: (...args: any[]) => any;
            onClickOutside?: (...args: any[]) => any;
            onOk?: (...args: any[]) => any;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "cancel" | "clickOutside" | "ok")[], "update:modelValue" | "cancel" | "clickOutside" | "ok", {
            readonly disabled: boolean | (() => boolean);
            readonly trigger: "click" | "hover" | "contextmenu" | "focus";
            readonly mode: "text" | "confirm" | "popover";
            readonly modelValue: boolean;
            readonly arrow: boolean;
            readonly appendToContainer: boolean;
            readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
            readonly offset: number;
            readonly popperStyle: import("vue").StyleValue;
            readonly showAfter: number;
            readonly hideAfter: number;
            readonly lazy: boolean;
            readonly onlyShowTrigger: boolean;
            readonly passive: boolean;
            readonly confirmOption: Record<string, any>;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
    Tooltip: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            readonly title: PropType<string | number>;
            readonly content: PropType<string | number>;
            readonly mode: {
                readonly type: PropType<"text" | "confirm" | "popover">;
                readonly default: "text";
            };
            readonly confirmOption: {
                readonly type: ObjectConstructor;
                readonly default: () => {
                    okText: string;
                    cancelText: string;
                    showOk: boolean;
                    showCancel: boolean;
                    icon: import("vue/jsx-runtime").JSX.Element;
                };
            };
            readonly arrow: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly offset: {
                readonly type: NumberConstructor;
                readonly default: 8;
            };
            readonly modelValue: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly trigger: {
                readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                readonly default: "hover";
            };
            readonly placement: {
                readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                readonly default: "bottom";
            };
            readonly disabled: {
                readonly type: PropType<boolean | (() => boolean)>;
                readonly default: false;
            };
            readonly appendToContainer: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly popperClass: PropType<string | object | []>;
            readonly popperStyle: {
                readonly type: PropType<import("vue").StyleValue>;
                readonly default: () => {};
            };
            readonly showAfter: {
                readonly type: NumberConstructor;
                readonly default: 0;
            };
            readonly hideAfter: {
                readonly type: NumberConstructor;
                readonly default: 200;
            };
            readonly getContainer: {
                readonly type: FunctionConstructor;
            };
            readonly lazy: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly onlyShowTrigger: {
                readonly type: BooleanConstructor;
            };
            readonly passive: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
        }>> & Readonly<{
            "onUpdate:modelValue"?: (...args: any[]) => any;
            onCancel?: (...args: any[]) => any;
            onClickOutside?: (...args: any[]) => any;
            onOk?: (...args: any[]) => any;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "cancel" | "clickOutside" | "ok")[], import("vue").PublicProps, {
            readonly disabled: boolean | (() => boolean);
            readonly trigger: "click" | "hover" | "contextmenu" | "focus";
            readonly mode: "text" | "confirm" | "popover";
            readonly modelValue: boolean;
            readonly arrow: boolean;
            readonly appendToContainer: boolean;
            readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
            readonly offset: number;
            readonly popperStyle: import("vue").StyleValue;
            readonly showAfter: number;
            readonly hideAfter: number;
            readonly lazy: boolean;
            readonly onlyShowTrigger: boolean;
            readonly passive: boolean;
            readonly confirmOption: Record<string, any>;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            readonly title: PropType<string | number>;
            readonly content: PropType<string | number>;
            readonly mode: {
                readonly type: PropType<"text" | "confirm" | "popover">;
                readonly default: "text";
            };
            readonly confirmOption: {
                readonly type: ObjectConstructor;
                readonly default: () => {
                    okText: string;
                    cancelText: string;
                    showOk: boolean;
                    showCancel: boolean;
                    icon: import("vue/jsx-runtime").JSX.Element;
                };
            };
            readonly arrow: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly offset: {
                readonly type: NumberConstructor;
                readonly default: 8;
            };
            readonly modelValue: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly trigger: {
                readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                readonly default: "hover";
            };
            readonly placement: {
                readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                readonly default: "bottom";
            };
            readonly disabled: {
                readonly type: PropType<boolean | (() => boolean)>;
                readonly default: false;
            };
            readonly appendToContainer: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly popperClass: PropType<string | object | []>;
            readonly popperStyle: {
                readonly type: PropType<import("vue").StyleValue>;
                readonly default: () => {};
            };
            readonly showAfter: {
                readonly type: NumberConstructor;
                readonly default: 0;
            };
            readonly hideAfter: {
                readonly type: NumberConstructor;
                readonly default: 200;
            };
            readonly getContainer: {
                readonly type: FunctionConstructor;
            };
            readonly lazy: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly onlyShowTrigger: {
                readonly type: BooleanConstructor;
            };
            readonly passive: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
        }>> & Readonly<{
            "onUpdate:modelValue"?: (...args: any[]) => any;
            onCancel?: (...args: any[]) => any;
            onClickOutside?: (...args: any[]) => any;
            onOk?: (...args: any[]) => any;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
            readonly disabled: boolean | (() => boolean);
            readonly trigger: "click" | "hover" | "contextmenu" | "focus";
            readonly mode: "text" | "confirm" | "popover";
            readonly modelValue: boolean;
            readonly arrow: boolean;
            readonly appendToContainer: boolean;
            readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
            readonly offset: number;
            readonly popperStyle: import("vue").StyleValue;
            readonly showAfter: number;
            readonly hideAfter: number;
            readonly lazy: boolean;
            readonly onlyShowTrigger: boolean;
            readonly passive: boolean;
            readonly confirmOption: Record<string, any>;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        readonly title: PropType<string | number>;
        readonly content: PropType<string | number>;
        readonly mode: {
            readonly type: PropType<"text" | "confirm" | "popover">;
            readonly default: "text";
        };
        readonly confirmOption: {
            readonly type: ObjectConstructor;
            readonly default: () => {
                okText: string;
                cancelText: string;
                showOk: boolean;
                showCancel: boolean;
                icon: import("vue/jsx-runtime").JSX.Element;
            };
        };
        readonly arrow: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly offset: {
            readonly type: NumberConstructor;
            readonly default: 8;
        };
        readonly modelValue: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly trigger: {
            readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
            readonly default: "hover";
        };
        readonly placement: {
            readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
            readonly default: "bottom";
        };
        readonly disabled: {
            readonly type: PropType<boolean | (() => boolean)>;
            readonly default: false;
        };
        readonly appendToContainer: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly popperClass: PropType<string | object | []>;
        readonly popperStyle: {
            readonly type: PropType<import("vue").StyleValue>;
            readonly default: () => {};
        };
        readonly showAfter: {
            readonly type: NumberConstructor;
            readonly default: 0;
        };
        readonly hideAfter: {
            readonly type: NumberConstructor;
            readonly default: 200;
        };
        readonly getContainer: {
            readonly type: FunctionConstructor;
        };
        readonly lazy: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        readonly onlyShowTrigger: {
            readonly type: BooleanConstructor;
        };
        readonly passive: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
    }>> & Readonly<{
        "onUpdate:modelValue"?: (...args: any[]) => any;
        onCancel?: (...args: any[]) => any;
        onClickOutside?: (...args: any[]) => any;
        onOk?: (...args: any[]) => any;
    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "cancel" | "clickOutside" | "ok")[], "update:modelValue" | "cancel" | "clickOutside" | "ok", {
        readonly disabled: boolean | (() => boolean);
        readonly trigger: "click" | "hover" | "contextmenu" | "focus";
        readonly mode: "text" | "confirm" | "popover";
        readonly modelValue: boolean;
        readonly arrow: boolean;
        readonly appendToContainer: boolean;
        readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
        readonly offset: number;
        readonly popperStyle: import("vue").StyleValue;
        readonly showAfter: number;
        readonly hideAfter: number;
        readonly lazy: boolean;
        readonly onlyShowTrigger: boolean;
        readonly passive: boolean;
        readonly confirmOption: Record<string, any>;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
    UpOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
    DownOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
    CloseCircleFilled: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
    RenderTag: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        option: PropType<SelectOption>;
        renderTag: PropType<(param: RenderTagParam) => VNodeChild>;
    }>, () => VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "close"[], "close", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        option: PropType<SelectOption>;
        renderTag: PropType<(param: RenderTagParam) => VNodeChild>;
    }>> & Readonly<{
        onClose?: (...args: any[]) => any;
    }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
export default _default;
