import { type CSSProperties, type PropType } from 'vue';
import type { CascaderNodeKey, CascaderNodeList, CascaderOption, CheckParams, InnerCascaderOption, SelectParams } from '../cascader/interface';
import type { ExtractPublicPropTypes } from '../_util/interface';
export declare const selectCascaderProps: {
    readonly modelValue: {
        readonly type: PropType<CascaderNodeKey | CascaderNodeKey[] | CascaderNodeKey[][]>;
    };
    readonly data: {
        readonly type: PropType<CascaderOption[]>;
        readonly default: () => CascaderOption[];
    };
    readonly emptyText: {
        readonly type: StringConstructor;
    };
    readonly expandedKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly selectable: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly selectedKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly cascade: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly checkable: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly checkStrictly: {
        readonly type: PropType<import("../cascader/const").CheckStrictly>;
        readonly default: "child";
    };
    readonly checkedKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly multiple: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly childrenField: {
        readonly type: StringConstructor;
        readonly default: "children";
    };
    readonly valueField: {
        readonly type: StringConstructor;
        readonly default: "value";
    };
    readonly labelField: {
        readonly type: StringConstructor;
        readonly default: "label";
    };
    readonly remote: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly loadData: {
        readonly type: PropType<(node: CascaderOption) => Promise<CascaderOption[]>>;
    };
    readonly cancelable: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly expandTrigger: {
        readonly type: StringConstructor;
        readonly default: string;
    };
    readonly emitPath: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly initLoadKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly showPath: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly isOpened: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly placeholder: {
        readonly type: StringConstructor;
    };
    readonly disabled: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly clearable: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly multipleLimit: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly appendToContainer: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly getContainer: {
        readonly type: PropType<import("../_util/interface").GetContainer>;
    };
    readonly filterable: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly filter: {
        readonly type: PropType<(pattern: string, option: object) => boolean>;
    };
    readonly filterTextHighlight: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly collapseTags: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly collapseTagsLimit: {
        readonly type: NumberConstructor;
        readonly default: 1;
    };
    readonly options: {
        readonly type: PropType<import("../select/interface").SelectOption[]>;
        readonly default: () => import("../select/interface").SelectOption[];
    };
    readonly virtualScroll: {
        readonly type: PropType<number | boolean>;
        readonly default: true;
    };
    readonly tagBordered: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly tag: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly popperClass: PropType<string | object | []>;
    readonly triggerClass: PropType<string | object | []>;
    readonly triggerStyle: PropType<string | CSSProperties>;
};
export type SelectCascaderProps = ExtractPublicPropTypes<typeof selectCascaderProps>;
declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    readonly modelValue: {
        readonly type: PropType<CascaderNodeKey | CascaderNodeKey[] | CascaderNodeKey[][]>;
    };
    readonly data: {
        readonly type: PropType<CascaderOption[]>;
        readonly default: () => CascaderOption[];
    };
    readonly emptyText: {
        readonly type: StringConstructor;
    };
    readonly expandedKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly selectable: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly selectedKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly cascade: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly checkable: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly checkStrictly: {
        readonly type: PropType<import("../cascader/const").CheckStrictly>;
        readonly default: "child";
    };
    readonly checkedKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly multiple: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly childrenField: {
        readonly type: StringConstructor;
        readonly default: "children";
    };
    readonly valueField: {
        readonly type: StringConstructor;
        readonly default: "value";
    };
    readonly labelField: {
        readonly type: StringConstructor;
        readonly default: "label";
    };
    readonly remote: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly loadData: {
        readonly type: PropType<(node: CascaderOption) => Promise<CascaderOption[]>>;
    };
    readonly cancelable: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly expandTrigger: {
        readonly type: StringConstructor;
        readonly default: string;
    };
    readonly emitPath: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly initLoadKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly showPath: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly isOpened: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly placeholder: {
        readonly type: StringConstructor;
    };
    readonly disabled: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly clearable: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly multipleLimit: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly appendToContainer: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly getContainer: {
        readonly type: PropType<import("../_util/interface").GetContainer>;
    };
    readonly filterable: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly filter: {
        readonly type: PropType<(pattern: string, option: object) => boolean>;
    };
    readonly filterTextHighlight: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly collapseTags: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly collapseTagsLimit: {
        readonly type: NumberConstructor;
        readonly default: 1;
    };
    readonly options: {
        readonly type: PropType<import("../select/interface").SelectOption[]>;
        readonly default: () => import("../select/interface").SelectOption[];
    };
    readonly virtualScroll: {
        readonly type: PropType<number | boolean>;
        readonly default: true;
    };
    readonly tagBordered: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly tag: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly popperClass: PropType<string | object | []>;
    readonly triggerClass: PropType<string | object | []>;
    readonly triggerStyle: PropType<string | CSSProperties>;
}>, {
    triggerDomRef: import("vue").Ref<any, any>;
    cascaderRef: import("vue").Ref<any, any>;
    prefixCls: string;
    selectPrefixCls: string;
    isOpened: import("vue").Ref<boolean, boolean>;
    currentValue: import("vue").WritableComputedRef<CascaderNodeKey | CascaderNodeKey[] | CascaderNodeKey[][], CascaderNodeKey | CascaderNodeKey[] | CascaderNodeKey[][]>;
    handleRemove: (value: CascaderNodeKey) => void;
    handleClear: () => void;
    selectedOptions: import("vue").ComputedRef<{
        value: CascaderNodeKey;
        label: CascaderNodeKey;
        path: any;
    }[]>;
    focus: (e: Event) => void;
    blur: (e: Event) => void;
    handleFilterTextChange: (val: string) => void;
    cascaderSelectable: import("vue").ComputedRef<boolean>;
    selectedKeys: import("vue").ComputedRef<any[]>;
    expandedKeys: import("vue").WritableComputedRef<CascaderNodeKey[], CascaderNodeKey[]>;
    cascaderCheckable: import("vue").ComputedRef<boolean>;
    handleSelect: (data: SelectParams) => void;
    handleCheck: (data: CheckParams) => void;
    checkedKeys: import("vue").ComputedRef<any[]>;
    onChangeNodeList: (data: CascaderNodeList) => void;
    inputPlaceholder: import("vue").ComputedRef<string>;
    isError: import("vue").Ref<boolean, boolean>;
    initLoadKeys: import("vue").ComputedRef<CascaderNodeKey[]>;
    attrs: {
        [x: string]: unknown;
    };
    innerDisabled: import("vue").ComputedRef<boolean>;
    innerFilterable: import("vue").ComputedRef<boolean>;
    listEmptyText: import("vue").ComputedRef<string>;
    filterEmptyText: import("vue").ComputedRef<string>;
    filterText: import("vue").Ref<string, string>;
    filteredOptions: import("vue").Ref<{
        [x: string]: any;
        origin?: {
            [x: string]: any;
            value?: CascaderNodeKey;
            label?: string;
            children?: any[];
            disabled?: boolean;
            selectable?: boolean;
            checkable?: boolean;
            isLeaf?: boolean;
            prefix?: string | (() => import("vue").VNodeChild);
            suffix?: string | (() => import("vue").VNodeChild);
        };
        level?: number;
        hasChildren?: boolean;
        indexPath?: CascaderNodeKey[];
        children?: any[];
        childrenValues?: CascaderNodeKey[];
        isExpanded?: boolean;
        value?: CascaderNodeKey;
        label?: string;
        disabled?: boolean;
        selectable?: boolean;
        checkable?: boolean;
        isLeaf?: boolean;
        prefix?: string | (() => import("vue").VNodeChild);
        suffix?: string | (() => import("vue").VNodeChild);
    }[], InnerCascaderOption[] | {
        [x: string]: any;
        origin?: {
            [x: string]: any;
            value?: CascaderNodeKey;
            label?: string;
            children?: any[];
            disabled?: boolean;
            selectable?: boolean;
            checkable?: boolean;
            isLeaf?: boolean;
            prefix?: string | (() => import("vue").VNodeChild);
            suffix?: string | (() => import("vue").VNodeChild);
        };
        level?: number;
        hasChildren?: boolean;
        indexPath?: CascaderNodeKey[];
        children?: any[];
        childrenValues?: CascaderNodeKey[];
        isExpanded?: boolean;
        value?: CascaderNodeKey;
        label?: string;
        disabled?: boolean;
        selectable?: boolean;
        checkable?: boolean;
        isLeaf?: boolean;
        prefix?: string | (() => import("vue").VNodeChild);
        suffix?: string | (() => import("vue").VNodeChild);
    }[]>;
    filterIsSelect: (value: CascaderNodeKey) => boolean;
    filterDropdownStyle: import("vue").ComputedRef<CSSProperties>;
    handleFilterSelect: (value: CascaderNodeKey) => void;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("clear" | "change" | "update:expandedKeys" | "update:modelValue" | "blur" | "focus" | "visibleChange" | "removeTag")[], "clear" | "change" | "update:expandedKeys" | "update:modelValue" | "blur" | "focus" | "visibleChange" | "removeTag", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    readonly modelValue: {
        readonly type: PropType<CascaderNodeKey | CascaderNodeKey[] | CascaderNodeKey[][]>;
    };
    readonly data: {
        readonly type: PropType<CascaderOption[]>;
        readonly default: () => CascaderOption[];
    };
    readonly emptyText: {
        readonly type: StringConstructor;
    };
    readonly expandedKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly selectable: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly selectedKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly cascade: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly checkable: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly checkStrictly: {
        readonly type: PropType<import("../cascader/const").CheckStrictly>;
        readonly default: "child";
    };
    readonly checkedKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly multiple: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly childrenField: {
        readonly type: StringConstructor;
        readonly default: "children";
    };
    readonly valueField: {
        readonly type: StringConstructor;
        readonly default: "value";
    };
    readonly labelField: {
        readonly type: StringConstructor;
        readonly default: "label";
    };
    readonly remote: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly loadData: {
        readonly type: PropType<(node: CascaderOption) => Promise<CascaderOption[]>>;
    };
    readonly cancelable: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly expandTrigger: {
        readonly type: StringConstructor;
        readonly default: string;
    };
    readonly emitPath: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly initLoadKeys: {
        readonly type: PropType<CascaderNodeKey[]>;
        readonly default: () => CascaderNodeKey[];
    };
    readonly showPath: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly isOpened: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly placeholder: {
        readonly type: StringConstructor;
    };
    readonly disabled: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly clearable: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly multipleLimit: {
        readonly type: NumberConstructor;
        readonly default: 0;
    };
    readonly appendToContainer: {
        readonly type: BooleanConstructor;
        readonly default: true;
    };
    readonly getContainer: {
        readonly type: PropType<import("../_util/interface").GetContainer>;
    };
    readonly filterable: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly filter: {
        readonly type: PropType<(pattern: string, option: object) => boolean>;
    };
    readonly filterTextHighlight: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly collapseTags: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly collapseTagsLimit: {
        readonly type: NumberConstructor;
        readonly default: 1;
    };
    readonly options: {
        readonly type: PropType<import("../select/interface").SelectOption[]>;
        readonly default: () => import("../select/interface").SelectOption[];
    };
    readonly virtualScroll: {
        readonly type: PropType<number | boolean>;
        readonly default: true;
    };
    readonly tagBordered: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly tag: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly popperClass: PropType<string | object | []>;
    readonly triggerClass: PropType<string | object | []>;
    readonly triggerStyle: PropType<string | CSSProperties>;
}>> & Readonly<{
    onFocus?: (...args: any[]) => any;
    onBlur?: (...args: any[]) => any;
    onChange?: (...args: any[]) => any;
    "onUpdate:expandedKeys"?: (...args: any[]) => any;
    "onUpdate:modelValue"?: (...args: any[]) => any;
    onClear?: (...args: any[]) => any;
    onVisibleChange?: (...args: any[]) => any;
    onRemoveTag?: (...args: any[]) => any;
}>, {
    readonly data: CascaderOption[];
    readonly disabled: boolean;
    readonly expandedKeys: CascaderNodeKey[];
    readonly selectable: boolean;
    readonly selectedKeys: CascaderNodeKey[];
    readonly cascade: boolean;
    readonly checkable: boolean;
    readonly checkStrictly: import("../cascader/const").CheckStrictly;
    readonly checkedKeys: CascaderNodeKey[];
    readonly multiple: boolean;
    readonly childrenField: string;
    readonly valueField: string;
    readonly labelField: string;
    readonly remote: boolean;
    readonly cancelable: boolean;
    readonly expandTrigger: string;
    readonly emitPath: boolean;
    readonly initLoadKeys: CascaderNodeKey[];
    readonly showPath: boolean;
    readonly isOpened: boolean;
    readonly options: import("../select/interface").SelectOption[];
    readonly clearable: boolean;
    readonly appendToContainer: boolean;
    readonly tag: boolean;
    readonly tagBordered: boolean;
    readonly filterable: boolean;
    readonly collapseTags: boolean;
    readonly collapseTagsLimit: number;
    readonly multipleLimit: number;
    readonly filterTextHighlight: boolean;
    readonly virtualScroll: number | boolean;
}, {}, {
    Popper: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            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 offset: {
                readonly type: NumberConstructor;
                readonly default: 6;
            };
            readonly disabled: {
                readonly type: PropType<boolean | (() => boolean)>;
                readonly default: false;
            };
            readonly arrow: {
                readonly type: BooleanConstructor;
                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;
            onClickOutside?: (...args: any[]) => any;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "clickOutside")[], import("vue").PublicProps, {
            readonly disabled: boolean | (() => boolean);
            readonly trigger: "click" | "hover" | "contextmenu" | "focus";
            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;
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            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 offset: {
                readonly type: NumberConstructor;
                readonly default: 6;
            };
            readonly disabled: {
                readonly type: PropType<boolean | (() => boolean)>;
                readonly default: false;
            };
            readonly arrow: {
                readonly type: BooleanConstructor;
                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;
            onClickOutside?: (...args: any[]) => any;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
            readonly disabled: boolean | (() => boolean);
            readonly trigger: "click" | "hover" | "contextmenu" | "focus";
            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;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
        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 offset: {
            readonly type: NumberConstructor;
            readonly default: 6;
        };
        readonly disabled: {
            readonly type: PropType<boolean | (() => boolean)>;
            readonly default: false;
        };
        readonly arrow: {
            readonly type: BooleanConstructor;
            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;
        onClickOutside?: (...args: any[]) => any;
    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "clickOutside")[], "update:modelValue" | "clickOutside", {
        readonly disabled: boolean | (() => boolean);
        readonly trigger: "click" | "hover" | "contextmenu" | "focus";
        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;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
    SelectTrigger: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        readonly selectedOptions: {
            readonly type: PropType<import("../select-trigger/interface").SelectOption[]>;
            readonly default: () => import("../select-trigger/interface").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: import("../select-trigger/interface").RenderTagParam) => import("vue").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<import("../select-trigger/interface").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<import("../select-trigger/interface").SelectOption[]>;
            readonly default: () => import("../select-trigger/interface").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: import("../select-trigger/interface").RenderTagParam) => import("vue").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: import("../select-trigger/interface").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("..").ToolTipProps>;
                    readonly default: () => import("..").ToolTipProps;
                };
                readonly class: PropType<string | object | []>;
                readonly style: {
                    readonly type: PropType<string | CSSProperties>;
                    readonly default: () => {};
                };
            }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                readonly style: string | CSSProperties;
                readonly tooltip: import("..").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("..").ToolTipProps>;
                    readonly default: () => import("..").ToolTipProps;
                };
                readonly class: PropType<string | object | []>;
                readonly style: {
                    readonly type: PropType<string | CSSProperties>;
                    readonly default: () => {};
                };
            }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                readonly style: string | CSSProperties;
                readonly tooltip: import("..").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("..").ToolTipProps>;
                readonly default: () => import("..").ToolTipProps;
            };
            readonly class: PropType<string | object | []>;
            readonly style: {
                readonly type: PropType<string | CSSProperties>;
                readonly default: () => {};
            };
        }>> & Readonly<{}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
            readonly style: string | CSSProperties;
            readonly tooltip: import("..").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<import("../select-trigger/interface").SelectOption>;
            renderTag: PropType<(param: import("../select-trigger/interface").RenderTagParam) => import("vue").VNodeChild>;
        }>, () => import("vue").VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "close"[], "close", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            option: PropType<import("../select-trigger/interface").SelectOption>;
            renderTag: PropType<(param: import("../select-trigger/interface").RenderTagParam) => import("vue").VNodeChild>;
        }>> & Readonly<{
            onClose?: (...args: any[]) => any;
        }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Cascader: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        data: {
            readonly type: PropType<CascaderOption[]>;
            readonly default: () => CascaderOption[];
        };
        emptyText: {
            readonly type: StringConstructor;
        };
        expandedKeys: {
            readonly type: PropType<CascaderNodeKey[]>;
            readonly default: () => CascaderNodeKey[];
        };
        selectable: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        selectedKeys: {
            readonly type: PropType<CascaderNodeKey[]>;
            readonly default: () => CascaderNodeKey[];
        };
        cascade: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        checkable: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        checkStrictly: {
            readonly type: PropType<import("../cascader/const").CheckStrictly>;
            readonly default: "child";
        };
        checkedKeys: {
            readonly type: PropType<CascaderNodeKey[]>;
            readonly default: () => CascaderNodeKey[];
        };
        multiple: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        childrenField: {
            readonly type: StringConstructor;
            readonly default: "children";
        };
        valueField: {
            readonly type: StringConstructor;
            readonly default: "value";
        };
        labelField: {
            readonly type: StringConstructor;
            readonly default: "label";
        };
        remote: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        loadData: {
            readonly type: PropType<(node: CascaderOption) => Promise<CascaderOption[]>>;
        };
        cancelable: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        expandTrigger: {
            readonly type: StringConstructor;
            readonly default: string;
        };
        emitPath: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        initLoadKeys: {
            readonly type: PropType<CascaderNodeKey[]>;
            readonly default: () => CascaderNodeKey[];
        };
        showPath: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        isOpened: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:expandedKeys" | "update:checkedKeys" | "update:selectedKeys" | "update:nodeList" | "check" | "expand" | "load" | "select")[], "update:expandedKeys" | "update:checkedKeys" | "update:selectedKeys" | "update:nodeList" | "check" | "expand" | "load" | "select", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        data: {
            readonly type: PropType<CascaderOption[]>;
            readonly default: () => CascaderOption[];
        };
        emptyText: {
            readonly type: StringConstructor;
        };
        expandedKeys: {
            readonly type: PropType<CascaderNodeKey[]>;
            readonly default: () => CascaderNodeKey[];
        };
        selectable: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        selectedKeys: {
            readonly type: PropType<CascaderNodeKey[]>;
            readonly default: () => CascaderNodeKey[];
        };
        cascade: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        checkable: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        checkStrictly: {
            readonly type: PropType<import("../cascader/const").CheckStrictly>;
            readonly default: "child";
        };
        checkedKeys: {
            readonly type: PropType<CascaderNodeKey[]>;
            readonly default: () => CascaderNodeKey[];
        };
        multiple: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        childrenField: {
            readonly type: StringConstructor;
            readonly default: "children";
        };
        valueField: {
            readonly type: StringConstructor;
            readonly default: "value";
        };
        labelField: {
            readonly type: StringConstructor;
            readonly default: "label";
        };
        remote: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        loadData: {
            readonly type: PropType<(node: CascaderOption) => Promise<CascaderOption[]>>;
        };
        cancelable: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
        expandTrigger: {
            readonly type: StringConstructor;
            readonly default: string;
        };
        emitPath: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        initLoadKeys: {
            readonly type: PropType<CascaderNodeKey[]>;
            readonly default: () => CascaderNodeKey[];
        };
        showPath: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        isOpened: {
            readonly type: BooleanConstructor;
            readonly default: true;
        };
    }>> & Readonly<{
        onLoad?: (...args: any[]) => any;
        onSelect?: (...args: any[]) => any;
        "onUpdate:expandedKeys"?: (...args: any[]) => any;
        "onUpdate:checkedKeys"?: (...args: any[]) => any;
        "onUpdate:selectedKeys"?: (...args: any[]) => any;
        "onUpdate:nodeList"?: (...args: any[]) => any;
        onCheck?: (...args: any[]) => any;
        onExpand?: (...args: any[]) => any;
    }>, {
        data: CascaderOption[];
        expandedKeys: CascaderNodeKey[];
        selectable: boolean;
        selectedKeys: CascaderNodeKey[];
        cascade: boolean;
        checkable: boolean;
        checkStrictly: import("../cascader/const").CheckStrictly;
        checkedKeys: CascaderNodeKey[];
        multiple: boolean;
        childrenField: string;
        valueField: string;
        labelField: string;
        remote: boolean;
        cancelable: boolean;
        expandTrigger: string;
        emitPath: boolean;
        initLoadKeys: CascaderNodeKey[];
        showPath: boolean;
        isOpened: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    OptionList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        readonly prefixCls: StringConstructor;
        readonly containerStyle: {
            readonly type: PropType<CSSProperties>;
        };
        readonly options: {
            readonly type: PropType<import("../select/interface").SelectOption[]>;
            readonly default: () => import("../select/interface").SelectOption[];
        };
        readonly virtualScroll: {
            readonly type: PropType<number | boolean>;
            readonly default: true;
        };
        readonly isSelect: {
            readonly type: FunctionConstructor;
            readonly default: () => void;
        };
        readonly onSelect: {
            readonly type: FunctionConstructor;
            readonly default: () => void;
        };
        readonly onHover: {
            readonly type: FunctionConstructor;
            readonly default: () => void;
        };
        readonly isLimit: {
            readonly type: BooleanConstructor;
        };
        readonly emptyText: StringConstructor;
        readonly renderOption: FunctionConstructor;
        readonly renderEmpty: FunctionConstructor;
        readonly hoverOptionValue: PropType<import("../select/interface").SelectValue>;
        readonly filterText: StringConstructor;
        readonly filterTextHighlight: BooleanConstructor;
    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scroll"[], "scroll", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        readonly prefixCls: StringConstructor;
        readonly containerStyle: {
            readonly type: PropType<CSSProperties>;
        };
        readonly options: {
            readonly type: PropType<import("../select/interface").SelectOption[]>;
            readonly default: () => import("../select/interface").SelectOption[];
        };
        readonly virtualScroll: {
            readonly type: PropType<number | boolean>;
            readonly default: true;
        };
        readonly isSelect: {
            readonly type: FunctionConstructor;
            readonly default: () => void;
        };
        readonly onSelect: {
            readonly type: FunctionConstructor;
            readonly default: () => void;
        };
        readonly onHover: {
            readonly type: FunctionConstructor;
            readonly default: () => void;
        };
        readonly isLimit: {
            readonly type: BooleanConstructor;
        };
        readonly emptyText: StringConstructor;
        readonly renderOption: FunctionConstructor;
        readonly renderEmpty: FunctionConstructor;
        readonly hoverOptionValue: PropType<import("../select/interface").SelectValue>;
        readonly filterText: StringConstructor;
        readonly filterTextHighlight: BooleanConstructor;
    }>> & Readonly<{
        onScroll?: (...args: any[]) => any;
    }>, {
        readonly onSelect: Function;
        readonly options: import("../select/interface").SelectOption[];
        readonly filterTextHighlight: boolean;
        readonly virtualScroll: number | boolean;
        readonly isSelect: Function;
        readonly onHover: Function;
        readonly isLimit: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
export default _default;
