feikuai-element-plus-virtual-component 1.0.11 → 1.0.14

package/dist/cascader-panel/index.vue.d.ts

@@ -0,0 +1,1816 @@
+import { nextTick, PropType } from 'vue';
+import { default as Node, default as CascaderNode, CascaderNodeValue, CascaderOption, CascaderValue, RenderLabel } from './node';
+import { ElCascaderPanelContext } from './types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    renderLabel: PropType<RenderLabel>;
+    modelValue: {
+        readonly type: PropType<import('../utils/vue').EpPropMergeType<(new (...args: any[]) => string | number | import('./node').CascaderNodePathValue | (import('./node').CascaderNodePathValue | CascaderNodeValue)[]) | (() => CascaderValue) | (((new (...args: any[]) => string | number | import('./node').CascaderNodePathValue | (import('./node').CascaderNodePathValue | CascaderNodeValue)[]) | (() => CascaderValue)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    options: import('../utils/vue').EpPropFinalized<(new (...args: any[]) => CascaderOption[]) | (() => CascaderOption[]) | (((new (...args: any[]) => CascaderOption[]) | (() => CascaderOption[])) | null)[], unknown, unknown, () => CascaderOption[], boolean>;
+    props: import('../utils/vue').EpPropFinalized<(new (...args: any[]) => import('./node').CascaderProps) | (() => import('./node').CascaderProps) | (((new (...args: any[]) => import('./node').CascaderProps) | (() => import('./node').CascaderProps)) | null)[], unknown, unknown, () => import('./node').CascaderProps, boolean>;
+}>, {
+    ns: {
+        namespace: import('vue').ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string | undefined) => string;
+        m: (modifier?: string | undefined) => string;
+        be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+        em: (element?: string | undefined, modifier?: string | undefined) => string;
+        bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+        bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    menuList: import('vue').Ref<any[], any[]>;
+    menus: import('vue').Ref<{
+        readonly uid: number;
+        readonly level: number;
+        readonly value: CascaderNodeValue;
+        readonly label: string;
+        readonly pathNodes: /*elided*/ any[];
+        readonly pathValues: CascaderNodeValue[];
+        readonly pathLabels: string[];
+        childrenData: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        }[] | undefined;
+        children: /*elided*/ any[];
+        text: string;
+        loaded: boolean;
+        checked: boolean;
+        indeterminate: boolean;
+        loading: boolean;
+        readonly data: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        } | null;
+        readonly config: {
+            expandTrigger: import('./node').ExpandTrigger;
+            multiple: boolean;
+            checkStrictly: boolean;
+            emitPath: boolean;
+            lazy: boolean;
+            lazyLoad: import('./node').LazyLoad;
+            value: string;
+            label: string;
+            children: string;
+            disabled: string | import('./node').isDisabled;
+            leaf: string | import('./node').isLeaf;
+            hoverThreshold: number;
+        };
+        readonly parent?: /*elided*/ any | undefined;
+        readonly root: boolean;
+        readonly isDisabled: boolean;
+        readonly isLeaf: boolean;
+        readonly valueByOption: CascaderNodeValue | CascaderNodeValue[];
+        appendChild: (childData: CascaderOption) => Node;
+        calcText: (allLevels: boolean, separator: string) => string;
+        broadcast: (event: string, ...args: unknown[]) => void;
+        emit: (event: string, ...args: unknown[]) => void;
+        onParentCheck: (checked: boolean) => void;
+        onChildCheck: () => void;
+        setCheckState: (checked: boolean) => void;
+        doCheck: (checked: boolean) => void;
+    }[][], Node[][] | {
+        readonly uid: number;
+        readonly level: number;
+        readonly value: CascaderNodeValue;
+        readonly label: string;
+        readonly pathNodes: /*elided*/ any[];
+        readonly pathValues: CascaderNodeValue[];
+        readonly pathLabels: string[];
+        childrenData: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        }[] | undefined;
+        children: /*elided*/ any[];
+        text: string;
+        loaded: boolean;
+        checked: boolean;
+        indeterminate: boolean;
+        loading: boolean;
+        readonly data: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        } | null;
+        readonly config: {
+            expandTrigger: import('./node').ExpandTrigger;
+            multiple: boolean;
+            checkStrictly: boolean;
+            emitPath: boolean;
+            lazy: boolean;
+            lazyLoad: import('./node').LazyLoad;
+            value: string;
+            label: string;
+            children: string;
+            disabled: string | import('./node').isDisabled;
+            leaf: string | import('./node').isLeaf;
+            hoverThreshold: number;
+        };
+        readonly parent?: /*elided*/ any | undefined;
+        readonly root: boolean;
+        readonly isDisabled: boolean;
+        readonly isLeaf: boolean;
+        readonly valueByOption: CascaderNodeValue | CascaderNodeValue[];
+        appendChild: (childData: CascaderOption) => Node;
+        calcText: (allLevels: boolean, separator: string) => string;
+        broadcast: (event: string, ...args: unknown[]) => void;
+        emit: (event: string, ...args: unknown[]) => void;
+        onParentCheck: (checked: boolean) => void;
+        onChildCheck: () => void;
+        setCheckState: (checked: boolean) => void;
+        doCheck: (checked: boolean) => void;
+    }[][]>;
+    checkedNodes: import('vue').Ref<{
+        readonly uid: number;
+        readonly level: number;
+        readonly value: CascaderNodeValue;
+        readonly label: string;
+        readonly pathNodes: /*elided*/ any[];
+        readonly pathValues: CascaderNodeValue[];
+        readonly pathLabels: string[];
+        childrenData: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        }[] | undefined;
+        children: /*elided*/ any[];
+        text: string;
+        loaded: boolean;
+        checked: boolean;
+        indeterminate: boolean;
+        loading: boolean;
+        readonly data: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        } | null;
+        readonly config: {
+            expandTrigger: import('./node').ExpandTrigger;
+            multiple: boolean;
+            checkStrictly: boolean;
+            emitPath: boolean;
+            lazy: boolean;
+            lazyLoad: import('./node').LazyLoad;
+            value: string;
+            label: string;
+            children: string;
+            disabled: string | import('./node').isDisabled;
+            leaf: string | import('./node').isLeaf;
+            hoverThreshold: number;
+        };
+        readonly parent?: /*elided*/ any | undefined;
+        readonly root: boolean;
+        readonly isDisabled: boolean;
+        readonly isLeaf: boolean;
+        readonly valueByOption: CascaderNodeValue | CascaderNodeValue[];
+        appendChild: (childData: CascaderOption) => Node;
+        calcText: (allLevels: boolean, separator: string) => string;
+        broadcast: (event: string, ...args: unknown[]) => void;
+        emit: (event: string, ...args: unknown[]) => void;
+        onParentCheck: (checked: boolean) => void;
+        onChildCheck: () => void;
+        setCheckState: (checked: boolean) => void;
+        doCheck: (checked: boolean) => void;
+    }[], Node[] | {
+        readonly uid: number;
+        readonly level: number;
+        readonly value: CascaderNodeValue;
+        readonly label: string;
+        readonly pathNodes: /*elided*/ any[];
+        readonly pathValues: CascaderNodeValue[];
+        readonly pathLabels: string[];
+        childrenData: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        }[] | undefined;
+        children: /*elided*/ any[];
+        text: string;
+        loaded: boolean;
+        checked: boolean;
+        indeterminate: boolean;
+        loading: boolean;
+        readonly data: {
+            [x: string]: unknown;
+            label?: string | undefined;
+            value?: CascaderNodeValue | undefined;
+            children?: /*elided*/ any[] | undefined;
+            disabled?: boolean | undefined;
+            leaf?: boolean | undefined;
+        } | null;
+        readonly config: {
+            expandTrigger: import('./node').ExpandTrigger;
+            multiple: boolean;
+            checkStrictly: boolean;
+            emitPath: boolean;
+            lazy: boolean;
+            lazyLoad: import('./node').LazyLoad;
+            value: string;
+            label: string;
+            children: string;
+            disabled: string | import('./node').isDisabled;
+            leaf: string | import('./node').isLeaf;
+            hoverThreshold: number;
+        };
+        readonly parent?: /*elided*/ any | undefined;
+        readonly root: boolean;
+        readonly isDisabled: boolean;
+        readonly isLeaf: boolean;
+        readonly valueByOption: CascaderNodeValue | CascaderNodeValue[];
+        appendChild: (childData: CascaderOption) => Node;
+        calcText: (allLevels: boolean, separator: string) => string;
+        broadcast: (event: string, ...args: unknown[]) => void;
+        emit: (event: string, ...args: unknown[]) => void;
+        onParentCheck: (checked: boolean) => void;
+        onChildCheck: () => void;
+        setCheckState: (checked: boolean) => void;
+        doCheck: (checked: boolean) => void;
+    }[]>;
+    handleKeyDown: (e: KeyboardEvent) => void;
+    handleCheckChange: (node: CascaderNode, checked: boolean, emitClose?: boolean) => void;
+    getFlattedNodes: (leafOnly: boolean) => Node[] | undefined;
+    /**
+* @description get an array of currently selected node,(leafOnly) whether only return the leaf checked nodes, default is `false`
+*/
+    getCheckedNodes: (leafOnly: boolean) => Node[] | undefined;
+    /**
+* @description clear checked nodes
+*/
+    clearCheckedNodes: () => void;
+    calculateCheckedValue: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("update:modelValue" | "change" | "close" | "expand-change")[], "update:modelValue" | "change" | "close" | "expand-change", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    renderLabel: PropType<RenderLabel>;
+    modelValue: {
+        readonly type: PropType<import('../utils/vue').EpPropMergeType<(new (...args: any[]) => string | number | import('./node').CascaderNodePathValue | (import('./node').CascaderNodePathValue | CascaderNodeValue)[]) | (() => CascaderValue) | (((new (...args: any[]) => string | number | import('./node').CascaderNodePathValue | (import('./node').CascaderNodePathValue | CascaderNodeValue)[]) | (() => CascaderValue)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    options: import('../utils/vue').EpPropFinalized<(new (...args: any[]) => CascaderOption[]) | (() => CascaderOption[]) | (((new (...args: any[]) => CascaderOption[]) | (() => CascaderOption[])) | null)[], unknown, unknown, () => CascaderOption[], boolean>;
+    props: import('../utils/vue').EpPropFinalized<(new (...args: any[]) => import('./node').CascaderProps) | (() => import('./node').CascaderProps) | (((new (...args: any[]) => import('./node').CascaderProps) | (() => import('./node').CascaderProps)) | null)[], unknown, unknown, () => import('./node').CascaderProps, boolean>;
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onClose?: ((...args: any[]) => any) | undefined;
+    "onExpand-change"?: ((...args: any[]) => any) | undefined;
+}>, {
+    border: boolean;
+    props: import('./node').CascaderProps;
+    options: CascaderOption[];
+}, {}, {
+    CustomCascaderMenu: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        nodes: {
+            type: PropType<CascaderNode[]>;
+            required: true;
+        };
+        index: {
+            type: NumberConstructor;
+            required: true;
+        };
+    }>, {
+        ns: {
+            namespace: import('vue').ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string | undefined) => string;
+            m: (modifier?: string | undefined) => string;
+            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+            em: (element?: string | undefined, modifier?: string | undefined) => string;
+            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+            is: {
+                (name: string, state: boolean | undefined): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        panel: ElCascaderPanelContext;
+        hoverZone: import('vue').Ref<SVGSVGElement | null, SVGSVGElement | null>;
+        isEmpty: import('vue').ComputedRef<boolean>;
+        isLoading: import('vue').ComputedRef<boolean>;
+        menuId: import('vue').ComputedRef<string>;
+        t: import('element-plus').Translator;
+        handleExpand: (e: MouseEvent) => void;
+        handleMouseMove: (e: MouseEvent) => void;
+        clearHoverZone: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        nodes: {
+            type: PropType<CascaderNode[]>;
+            required: true;
+        };
+        index: {
+            type: NumberConstructor;
+            required: true;
+        };
+    }>> & Readonly<{}>, {}, {}, {
+        Loading: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        ElIcon: import('element-plus/es/utils/index.mjs').SFCWithInstall<import('vue').DefineComponent<{
+            readonly size: {
+                readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }, {
+            props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly color: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>> & {
+                [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+            }>>;
+            ns: {
+                namespace: import('vue').ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            style: import('vue').ComputedRef<import('vue').CSSProperties>;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>> & Record<string, any>;
+        ElScrollbar: import('element-plus/es/utils/index.mjs').SFCWithInstall<import('vue').DefineComponent<{
+            readonly height: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly maxHeight: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly native: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            readonly wrapStyle: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue) | ((new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue))[], unknown, unknown, "", boolean>;
+            readonly wrapClass: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+            readonly viewClass: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+            readonly viewStyle: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
+            readonly noresize: BooleanConstructor;
+            readonly tag: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+            readonly always: BooleanConstructor;
+            readonly minSize: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
+            readonly id: StringConstructor;
+            readonly role: StringConstructor;
+            readonly ariaLabel: StringConstructor;
+            readonly ariaOrientation: {
+                readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "horizontal" | "vertical", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }, {
+            COMPONENT_NAME: string;
+            props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                readonly height: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly maxHeight: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly native: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+                readonly wrapStyle: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue) | ((new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue))[], unknown, unknown, "", boolean>;
+                readonly wrapClass: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+                readonly viewClass: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+                readonly viewStyle: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
+                readonly noresize: BooleanConstructor;
+                readonly tag: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+                readonly always: BooleanConstructor;
+                readonly minSize: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
+                readonly id: StringConstructor;
+                readonly role: StringConstructor;
+                readonly ariaLabel: StringConstructor;
+                readonly ariaOrientation: {
+                    readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "horizontal" | "vertical", unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>> & {
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+            }>>;
+            emit: (event: "scroll", args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void;
+            ns: {
+                namespace: import('vue').ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            stopResizeObserver: undefined;
+            stopResizeListener: undefined;
+            scrollbarRef: import('vue').Ref<HTMLDivElement | undefined>;
+            wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
+            resizeRef: import('vue').Ref<HTMLElement | undefined>;
+            sizeWidth: import('vue').Ref<string>;
+            sizeHeight: import('vue').Ref<string>;
+            barRef: import('vue').Ref<({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    readonly always: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly ratioX: number;
+                    readonly ratioY: number;
+                }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+                    readonly always: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly width: StringConstructor;
+                    readonly height: StringConstructor;
+                    readonly ratioX: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                    readonly ratioY: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                }>> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "always" | "ratioX" | "ratioY">;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
+                $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                    readonly always: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly width: StringConstructor;
+                    readonly height: StringConstructor;
+                    readonly ratioX: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                    readonly ratioY: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                }>>, {
+                    props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                        readonly always: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                        readonly width: StringConstructor;
+                        readonly height: StringConstructor;
+                        readonly ratioX: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                        readonly ratioY: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                    }>> & {
+                        [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+                    }>>;
+                    moveX: import('vue').Ref<number>;
+                    moveY: import('vue').Ref<number>;
+                    handleScroll: (wrap: HTMLDivElement) => void;
+                    Thumb: import('vue').DefineComponent<{
+                        readonly vertical: BooleanConstructor;
+                        readonly size: StringConstructor;
+                        readonly move: NumberConstructor;
+                        readonly ratio: {
+                            readonly type: import('vue').PropType<number>;
+                            readonly required: true;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly always: BooleanConstructor;
+                    }, {
+                        COMPONENT_NAME: string;
+                        props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                            readonly vertical: BooleanConstructor;
+                            readonly size: StringConstructor;
+                            readonly move: NumberConstructor;
+                            readonly ratio: {
+                                readonly type: import('vue').PropType<number>;
+                                readonly required: true;
+                                readonly validator: ((val: unknown) => boolean) | undefined;
+                                __epPropKey: true;
+                            };
+                            readonly always: BooleanConstructor;
+                        }>> & {
+                            [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+                        }>>;
+                        scrollbar: import('element-plus').ScrollbarContext;
+                        ns: {
+                            namespace: import('vue').ComputedRef<string>;
+                            b: (blockSuffix?: string) => string;
+                            e: (element?: string | undefined) => string;
+                            m: (modifier?: string | undefined) => string;
+                            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                            em: (element?: string | undefined, modifier?: string | undefined) => string;
+                            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                            is: {
+                                (name: string, state: boolean | undefined): string;
+                                (name: string): string;
+                            };
+                            cssVar: (object: Record<string, string>) => Record<string, string>;
+                            cssVarName: (name: string) => string;
+                            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                            cssVarBlockName: (name: string) => string;
+                        };
+                        instance: import('vue').Ref<HTMLDivElement | undefined>;
+                        thumb: import('vue').Ref<HTMLDivElement | undefined>;
+                        thumbState: import('vue').Ref<{
+                            X?: number | undefined;
+                            Y?: number | undefined;
+                        }>;
+                        visible: import('vue').Ref<boolean>;
+                        cursorDown: boolean;
+                        cursorLeave: boolean;
+                        originalOnSelectStart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+                        bar: 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').CSSProperties>;
+                        offsetRatio: import('vue').ComputedRef<number>;
+                        clickThumbHandler: (e: MouseEvent) => void;
+                        clickTrackHandler: (e: MouseEvent) => void;
+                        startDrag: (e: MouseEvent) => void;
+                        mouseMoveDocumentHandler: (e: MouseEvent) => void;
+                        mouseUpDocumentHandler: () => void;
+                        mouseMoveScrollbarHandler: () => void;
+                        mouseLeaveScrollbarHandler: () => void;
+                        restoreOnselectstart: () => void;
+                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+                        readonly vertical: BooleanConstructor;
+                        readonly size: StringConstructor;
+                        readonly move: NumberConstructor;
+                        readonly ratio: {
+                            readonly type: import('vue').PropType<number>;
+                            readonly required: true;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly always: BooleanConstructor;
+                    }>>, {
+                        readonly vertical: boolean;
+                        readonly always: boolean;
+                    }>;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
+                    readonly always: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly ratioX: number;
+                    readonly ratioY: number;
+                }> & {
+                    beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+                    created?: ((() => void) | (() => void)[]) | undefined;
+                    beforeMount?: ((() => void) | (() => void)[]) | undefined;
+                    mounted?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+                    updated?: ((() => void) | (() => void)[]) | undefined;
+                    activated?: ((() => void) | (() => void)[]) | undefined;
+                    deactivated?: ((() => void) | (() => void)[]) | undefined;
+                    beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+                    beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+                    destroyed?: ((() => void) | (() => void)[]) | undefined;
+                    unmounted?: ((() => void) | (() => void)[]) | undefined;
+                    renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+                    renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+                    errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void)[]) | undefined;
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof import('vue').nextTick;
+                $watch(source: string | Function, cb: Function, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
+            } & Readonly<import('vue').ExtractPropTypes<{
+                readonly always: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly width: StringConstructor;
+                readonly height: StringConstructor;
+                readonly ratioX: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                readonly ratioY: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+            }>> & import('vue').ShallowUnwrapRef<{
+                props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                    readonly always: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly width: StringConstructor;
+                    readonly height: StringConstructor;
+                    readonly ratioX: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                    readonly ratioY: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                }>> & {
+                    [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+                }>>;
+                moveX: import('vue').Ref<number>;
+                moveY: import('vue').Ref<number>;
+                handleScroll: (wrap: HTMLDivElement) => void;
+                Thumb: import('vue').DefineComponent<{
+                    readonly vertical: BooleanConstructor;
+                    readonly size: StringConstructor;
+                    readonly move: NumberConstructor;
+                    readonly ratio: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly always: BooleanConstructor;
+                }, {
+                    COMPONENT_NAME: string;
+                    props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                        readonly vertical: BooleanConstructor;
+                        readonly size: StringConstructor;
+                        readonly move: NumberConstructor;
+                        readonly ratio: {
+                            readonly type: import('vue').PropType<number>;
+                            readonly required: true;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly always: BooleanConstructor;
+                    }>> & {
+                        [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+                    }>>;
+                    scrollbar: import('element-plus').ScrollbarContext;
+                    ns: {
+                        namespace: import('vue').ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string | undefined) => string;
+                        m: (modifier?: string | undefined) => string;
+                        be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                        em: (element?: string | undefined, modifier?: string | undefined) => string;
+                        bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                        bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                    instance: import('vue').Ref<HTMLDivElement | undefined>;
+                    thumb: import('vue').Ref<HTMLDivElement | undefined>;
+                    thumbState: import('vue').Ref<{
+                        X?: number | undefined;
+                        Y?: number | undefined;
+                    }>;
+                    visible: import('vue').Ref<boolean>;
+                    cursorDown: boolean;
+                    cursorLeave: boolean;
+                    originalOnSelectStart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+                    bar: 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').CSSProperties>;
+                    offsetRatio: import('vue').ComputedRef<number>;
+                    clickThumbHandler: (e: MouseEvent) => void;
+                    clickTrackHandler: (e: MouseEvent) => void;
+                    startDrag: (e: MouseEvent) => void;
+                    mouseMoveDocumentHandler: (e: MouseEvent) => void;
+                    mouseUpDocumentHandler: () => void;
+                    mouseMoveScrollbarHandler: () => void;
+                    mouseLeaveScrollbarHandler: () => void;
+                    restoreOnselectstart: () => void;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+                    readonly vertical: BooleanConstructor;
+                    readonly size: StringConstructor;
+                    readonly move: NumberConstructor;
+                    readonly ratio: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly always: BooleanConstructor;
+                }>>, {
+                    readonly vertical: boolean;
+                    readonly always: boolean;
+                }>;
+            }> & {} & import('vue').ComponentCustomProperties) | undefined>;
+            ratioY: import('vue').Ref<number>;
+            ratioX: import('vue').Ref<number>;
+            wrapStyle: import('vue').ComputedRef<import('vue').StyleValue>;
+            wrapKls: import('vue').ComputedRef<(string | unknown[] | {
+                [x: string]: boolean;
+            })[]>;
+            resizeKls: import('vue').ComputedRef<import('element-plus/es/utils/index.mjs').EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>[]>;
+            handleScroll: () => void;
+            scrollTo: (arg1: unknown, arg2?: number | undefined) => void;
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            update: () => void;
+            Bar: import('vue').DefineComponent<{
+                readonly always: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly width: StringConstructor;
+                readonly height: StringConstructor;
+                readonly ratioX: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                readonly ratioY: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+            }, {
+                props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                    readonly always: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    readonly width: StringConstructor;
+                    readonly height: StringConstructor;
+                    readonly ratioX: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                    readonly ratioY: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                }>> & {
+                    [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+                }>>;
+                moveX: import('vue').Ref<number>;
+                moveY: import('vue').Ref<number>;
+                handleScroll: (wrap: HTMLDivElement) => void;
+                Thumb: import('vue').DefineComponent<{
+                    readonly vertical: BooleanConstructor;
+                    readonly size: StringConstructor;
+                    readonly move: NumberConstructor;
+                    readonly ratio: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly always: BooleanConstructor;
+                }, {
+                    COMPONENT_NAME: string;
+                    props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                        readonly vertical: BooleanConstructor;
+                        readonly size: StringConstructor;
+                        readonly move: NumberConstructor;
+                        readonly ratio: {
+                            readonly type: import('vue').PropType<number>;
+                            readonly required: true;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly always: BooleanConstructor;
+                    }>> & {
+                        [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+                    }>>;
+                    scrollbar: import('element-plus').ScrollbarContext;
+                    ns: {
+                        namespace: import('vue').ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string | undefined) => string;
+                        m: (modifier?: string | undefined) => string;
+                        be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                        em: (element?: string | undefined, modifier?: string | undefined) => string;
+                        bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                        bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                    instance: import('vue').Ref<HTMLDivElement | undefined>;
+                    thumb: import('vue').Ref<HTMLDivElement | undefined>;
+                    thumbState: import('vue').Ref<{
+                        X?: number | undefined;
+                        Y?: number | undefined;
+                    }>;
+                    visible: import('vue').Ref<boolean>;
+                    cursorDown: boolean;
+                    cursorLeave: boolean;
+                    originalOnSelectStart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+                    bar: 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').CSSProperties>;
+                    offsetRatio: import('vue').ComputedRef<number>;
+                    clickThumbHandler: (e: MouseEvent) => void;
+                    clickTrackHandler: (e: MouseEvent) => void;
+                    startDrag: (e: MouseEvent) => void;
+                    mouseMoveDocumentHandler: (e: MouseEvent) => void;
+                    mouseUpDocumentHandler: () => void;
+                    mouseMoveScrollbarHandler: () => void;
+                    mouseLeaveScrollbarHandler: () => void;
+                    restoreOnselectstart: () => void;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+                    readonly vertical: BooleanConstructor;
+                    readonly size: StringConstructor;
+                    readonly move: NumberConstructor;
+                    readonly ratio: {
+                        readonly type: import('vue').PropType<number>;
+                        readonly required: true;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly always: BooleanConstructor;
+                }>>, {
+                    readonly vertical: boolean;
+                    readonly always: boolean;
+                }>;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+                readonly always: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly width: StringConstructor;
+                readonly height: StringConstructor;
+                readonly ratioX: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+                readonly ratioY: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+            }>>, {
+                readonly always: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly ratioX: number;
+                readonly ratioY: number;
+            }>;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            scroll: ({ scrollTop, scrollLeft, }: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => boolean;
+        }, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+            readonly height: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly maxHeight: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly native: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            readonly wrapStyle: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue) | ((new (...args: any[]) => import('vue').StyleValue & {}) | (() => import('vue').StyleValue))[], unknown, unknown, "", boolean>;
+            readonly wrapClass: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+            readonly viewClass: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+            readonly viewStyle: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
+            readonly noresize: BooleanConstructor;
+            readonly tag: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+            readonly always: BooleanConstructor;
+            readonly minSize: import('element-plus/es/utils/index.mjs').EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
+            readonly id: StringConstructor;
+            readonly role: StringConstructor;
+            readonly ariaLabel: StringConstructor;
+            readonly ariaOrientation: {
+                readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "horizontal" | "vertical", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & {
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+        }, {
+            readonly height: import('element-plus/es/utils/index.mjs').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly always: boolean;
+            readonly maxHeight: import('element-plus/es/utils/index.mjs').EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly native: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly wrapStyle: import('vue').StyleValue;
+            readonly wrapClass: import('element-plus/es/utils/index.mjs').EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+            readonly viewClass: import('element-plus/es/utils/index.mjs').EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+            readonly viewStyle: import('element-plus/es/utils/index.mjs').EpPropMergeType<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown>;
+            readonly tag: string;
+            readonly minSize: number;
+            readonly noresize: boolean;
+        }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>> & Record<string, any>;
+        RecycleScroller: any;
+        CustomCascaderNode: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            node: {
+                type: PropType<CascaderNode>;
+                required: true;
+            };
+            menuId: StringConstructor;
+        }>, {
+            panel: ElCascaderPanelContext;
+            isHoverMenu: import('vue').ComputedRef<boolean>;
+            multiple: import('vue').ComputedRef<boolean>;
+            checkStrictly: import('vue').ComputedRef<boolean>;
+            checkedNodeId: import('vue').ComputedRef<number | undefined>;
+            isDisabled: import('vue').ComputedRef<boolean>;
+            isLeaf: import('vue').ComputedRef<boolean>;
+            expandable: import('vue').ComputedRef<boolean>;
+            inExpandingPath: import('vue').ComputedRef<boolean>;
+            inCheckedPath: import('vue').ComputedRef<boolean>;
+            ns: {
+                namespace: import('vue').ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string | undefined) => string;
+                m: (modifier?: string | undefined) => string;
+                be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                em: (element?: string | undefined, modifier?: string | undefined) => string;
+                bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                is: {
+                    (name: string, state: boolean | undefined): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            handleHoverExpand: (e: Event) => void;
+            handleExpand: () => void;
+            handleClick: () => void;
+            handleCheck: (checked: boolean) => void;
+            handleSelectCheck: (checked: boolean) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "expand"[], "expand", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+            node: {
+                type: PropType<CascaderNode>;
+                required: true;
+            };
+            menuId: StringConstructor;
+        }>> & Readonly<{
+            onExpand?: ((...args: any[]) => any) | undefined;
+        }>, {}, {}, {
+            ElCheckbox: import('element-plus/es/utils/index.mjs').SFCWithInstall<import('vue').DefineComponent<{
+                modelValue: {
+                    type: (NumberConstructor | BooleanConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                label: {
+                    type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                indeterminate: BooleanConstructor;
+                disabled: BooleanConstructor;
+                checked: BooleanConstructor;
+                name: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                trueLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                controls: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                border: BooleanConstructor;
+                size: {
+                    readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tabindex: (NumberConstructor | StringConstructor)[];
+                validateEvent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }, {
+                props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                    modelValue: {
+                        type: (NumberConstructor | BooleanConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    label: {
+                        type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    indeterminate: BooleanConstructor;
+                    disabled: BooleanConstructor;
+                    checked: BooleanConstructor;
+                    name: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    trueLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    falseLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    controls: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    border: BooleanConstructor;
+                    size: {
+                        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    tabindex: (NumberConstructor | StringConstructor)[];
+                    validateEvent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & {
+                    onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                }>>;
+                slots: Readonly<{
+                    [name: string]: import('vue').Slot | undefined;
+                }>;
+                inputId: import('vue').Ref<string | undefined>;
+                isLabeledByFormItem: import('vue').ComputedRef<boolean>;
+                isChecked: import('vue').ComputedRef<boolean>;
+                isDisabled: import('vue').ComputedRef<boolean>;
+                isFocused: import('vue').Ref<boolean>;
+                checkboxSize: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                hasOwnLabel: import('vue').ComputedRef<boolean>;
+                model: import('vue').WritableComputedRef<any>;
+                handleChange: (e: Event) => void;
+                onClickRoot: (e: MouseEvent) => Promise<void>;
+                ns: {
+                    namespace: import('vue').ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string | undefined) => string;
+                    m: (modifier?: string | undefined) => string;
+                    be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                    em: (element?: string | undefined, modifier?: string | undefined) => string;
+                    bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                    bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                    is: {
+                        (name: string, state: boolean | undefined): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+                compKls: import('vue').ComputedRef<string[]>;
+                spanKls: import('vue').ComputedRef<string[]>;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (val: import('element-plus').CheckboxValueType) => boolean;
+                change: (val: import('element-plus').CheckboxValueType) => boolean;
+            }, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+                modelValue: {
+                    type: (NumberConstructor | BooleanConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                label: {
+                    type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                indeterminate: BooleanConstructor;
+                disabled: BooleanConstructor;
+                checked: BooleanConstructor;
+                name: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                trueLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                falseLabel: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: undefined;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                controls: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                border: BooleanConstructor;
+                size: {
+                    readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tabindex: (NumberConstructor | StringConstructor)[];
+                validateEvent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+            }, {
+                modelValue: string | number | boolean;
+                label: string | number | boolean | Record<string, any>;
+                id: string;
+                disabled: boolean;
+                name: string;
+                validateEvent: boolean;
+                border: boolean;
+                indeterminate: boolean;
+                checked: boolean;
+                trueLabel: string | number;
+                falseLabel: string | number;
+                controls: string;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>> & {
+                CheckboxButton: import('vue').DefineComponent<{
+                    modelValue: {
+                        type: (NumberConstructor | BooleanConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    label: {
+                        type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    indeterminate: BooleanConstructor;
+                    disabled: BooleanConstructor;
+                    checked: BooleanConstructor;
+                    name: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    trueLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    falseLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    controls: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    border: BooleanConstructor;
+                    size: {
+                        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    tabindex: (NumberConstructor | StringConstructor)[];
+                    validateEvent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }, {
+                    props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                        modelValue: {
+                            type: (NumberConstructor | BooleanConstructor | StringConstructor)[];
+                            default: undefined;
+                        };
+                        label: {
+                            type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];
+                            default: undefined;
+                        };
+                        indeterminate: BooleanConstructor;
+                        disabled: BooleanConstructor;
+                        checked: BooleanConstructor;
+                        name: {
+                            type: StringConstructor;
+                            default: undefined;
+                        };
+                        trueLabel: {
+                            type: (NumberConstructor | StringConstructor)[];
+                            default: undefined;
+                        };
+                        falseLabel: {
+                            type: (NumberConstructor | StringConstructor)[];
+                            default: undefined;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: undefined;
+                        };
+                        controls: {
+                            type: StringConstructor;
+                            default: undefined;
+                        };
+                        border: BooleanConstructor;
+                        size: {
+                            readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        tabindex: (NumberConstructor | StringConstructor)[];
+                        validateEvent: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & {
+                        onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    }>>;
+                    slots: Readonly<{
+                        [name: string]: import('vue').Slot | undefined;
+                    }>;
+                    isFocused: import('vue').Ref<boolean>;
+                    isChecked: import('vue').ComputedRef<boolean>;
+                    isDisabled: import('vue').ComputedRef<boolean>;
+                    checkboxButtonSize: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    model: import('vue').WritableComputedRef<any>;
+                    handleChange: (e: Event) => void;
+                    checkboxGroup: ({
+                        modelValue?: import('vue').WritableComputedRef<any> | undefined;
+                        changeEvent?: ((...args: any) => any) | undefined;
+                    } & import('vue').ToRefs<Pick<import('element-plus').CheckboxGroupProps, "fill" | "size" | "disabled" | "validateEvent" | "max" | "min" | "textColor">>) | undefined;
+                    ns: {
+                        namespace: import('vue').ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string | undefined) => string;
+                        m: (modifier?: string | undefined) => string;
+                        be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                        em: (element?: string | undefined, modifier?: string | undefined) => string;
+                        bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                        bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                    activeStyle: import('vue').ComputedRef<import('vue').CSSProperties>;
+                    labelKls: import('vue').ComputedRef<string[]>;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    "update:modelValue": (val: import('element-plus').CheckboxValueType) => boolean;
+                    change: (val: import('element-plus').CheckboxValueType) => boolean;
+                }, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+                    modelValue: {
+                        type: (NumberConstructor | BooleanConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    label: {
+                        type: (ObjectConstructor | NumberConstructor | BooleanConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    indeterminate: BooleanConstructor;
+                    disabled: BooleanConstructor;
+                    checked: BooleanConstructor;
+                    name: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    trueLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    falseLabel: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: undefined;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    controls: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    border: BooleanConstructor;
+                    size: {
+                        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    tabindex: (NumberConstructor | StringConstructor)[];
+                    validateEvent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & {
+                    onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                }, {
+                    modelValue: string | number | boolean;
+                    label: string | number | boolean | Record<string, any>;
+                    id: string;
+                    disabled: boolean;
+                    name: string;
+                    validateEvent: boolean;
+                    border: boolean;
+                    indeterminate: boolean;
+                    checked: boolean;
+                    trueLabel: string | number;
+                    falseLabel: string | number;
+                    controls: string;
+                }>;
+                CheckboxGroup: import('vue').DefineComponent<{
+                    readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+                    readonly disabled: BooleanConstructor;
+                    readonly min: NumberConstructor;
+                    readonly max: NumberConstructor;
+                    readonly size: {
+                        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly label: StringConstructor;
+                    readonly fill: StringConstructor;
+                    readonly textColor: StringConstructor;
+                    readonly tag: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+                    readonly validateEvent: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                }, {
+                    props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                        readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+                        readonly disabled: BooleanConstructor;
+                        readonly min: NumberConstructor;
+                        readonly max: NumberConstructor;
+                        readonly size: {
+                            readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly label: StringConstructor;
+                        readonly fill: StringConstructor;
+                        readonly textColor: StringConstructor;
+                        readonly tag: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+                        readonly validateEvent: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    }>> & {
+                        onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                    }>>;
+                    emit: ((event: "update:modelValue", val: import('element-plus').CheckboxGroupValueType) => void) & ((event: "change", val: import('element-plus').CheckboxValueType[]) => void);
+                    ns: {
+                        namespace: import('vue').ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string | undefined) => string;
+                        m: (modifier?: string | undefined) => string;
+                        be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                        em: (element?: string | undefined, modifier?: string | undefined) => string;
+                        bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                        bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                    formItem: import('element-plus').FormItemContext | undefined;
+                    groupId: import('vue').Ref<string | undefined>;
+                    isLabeledByFormItem: import('vue').ComputedRef<boolean>;
+                    changeEvent: (value: import('element-plus').CheckboxGroupValueType) => Promise<void>;
+                    modelValue: import('vue').WritableComputedRef<import('element-plus').CheckboxGroupValueType>;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => boolean;
+                    change: (val: import('element-plus').CheckboxValueType[]) => boolean;
+                }, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+                    readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType) | ((new (...args: any[]) => import('element-plus').CheckboxGroupValueType) | (() => import('element-plus').CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+                    readonly disabled: BooleanConstructor;
+                    readonly min: NumberConstructor;
+                    readonly max: NumberConstructor;
+                    readonly size: {
+                        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly label: StringConstructor;
+                    readonly fill: StringConstructor;
+                    readonly textColor: StringConstructor;
+                    readonly tag: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+                    readonly validateEvent: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                }>> & {
+                    onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                }, {
+                    readonly modelValue: import('element-plus').CheckboxGroupValueType;
+                    readonly disabled: boolean;
+                    readonly validateEvent: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly tag: string;
+                }>;
+            };
+            ElRadio: import('element-plus/es/utils/index.mjs').SFCWithInstall<import('vue').DefineComponent<{
+                readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+                readonly name: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                readonly border: BooleanConstructor;
+                readonly size: {
+                    readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly label: import('element-plus/es/utils/index.mjs').EpPropFinalized<(NumberConstructor | BooleanConstructor | StringConstructor)[], unknown, unknown, string, boolean>;
+            }, {
+                props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                    readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+                    readonly name: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                    readonly border: BooleanConstructor;
+                    readonly size: {
+                        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly label: import('element-plus/es/utils/index.mjs').EpPropFinalized<(NumberConstructor | BooleanConstructor | StringConstructor)[], unknown, unknown, string, boolean>;
+                }>> & {
+                    onChange?: ((val: string | number | boolean) => any) | undefined;
+                    "onUpdate:modelValue"?: ((val: string | number | boolean) => any) | undefined;
+                }>>;
+                emit: ((event: "update:modelValue", val: string | number | boolean) => void) & ((event: "change", val: string | number | boolean) => void);
+                ns: {
+                    namespace: import('vue').ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string | undefined) => string;
+                    m: (modifier?: string | undefined) => string;
+                    be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                    em: (element?: string | undefined, modifier?: string | undefined) => string;
+                    bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                    bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                    is: {
+                        (name: string, state: boolean | undefined): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+                radioRef: import('vue').Ref<HTMLInputElement | undefined>;
+                radioGroup: import('element-plus').RadioGroupContext | undefined;
+                focus: import('vue').Ref<boolean>;
+                size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                disabled: import('vue').ComputedRef<boolean>;
+                modelValue: import('vue').WritableComputedRef<import('element-plus/es/utils/index.mjs').EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>>;
+                handleChange: () => void;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                "update:modelValue": (val: string | number | boolean) => boolean;
+                change: (val: string | number | boolean) => boolean;
+            }, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+                readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+                readonly name: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                readonly border: BooleanConstructor;
+                readonly size: {
+                    readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+                readonly label: import('element-plus/es/utils/index.mjs').EpPropFinalized<(NumberConstructor | BooleanConstructor | StringConstructor)[], unknown, unknown, string, boolean>;
+            }>> & {
+                onChange?: ((val: string | number | boolean) => any) | undefined;
+                "onUpdate:modelValue"?: ((val: string | number | boolean) => any) | undefined;
+            }, {
+                readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
+                readonly label: import('element-plus/es/utils/index.mjs').EpPropMergeType<(NumberConstructor | BooleanConstructor | StringConstructor)[], unknown, unknown>;
+                readonly disabled: boolean;
+                readonly name: string;
+                readonly border: boolean;
+            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>> & {
+                RadioButton: import('vue').DefineComponent<{
+                    readonly name: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                    readonly size: {
+                        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly label: import('element-plus/es/utils/index.mjs').EpPropFinalized<(NumberConstructor | BooleanConstructor | StringConstructor)[], unknown, unknown, string, boolean>;
+                }, {
+                    props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                        readonly name: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                        readonly size: {
+                            readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly disabled: BooleanConstructor;
+                        readonly label: import('element-plus/es/utils/index.mjs').EpPropFinalized<(NumberConstructor | BooleanConstructor | StringConstructor)[], unknown, unknown, string, boolean>;
+                    }>> & {
+                        [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+                    }>>;
+                    ns: {
+                        namespace: import('vue').ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string | undefined) => string;
+                        m: (modifier?: string | undefined) => string;
+                        be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                        em: (element?: string | undefined, modifier?: string | undefined) => string;
+                        bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                        bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                    radioRef: import('vue').Ref<HTMLInputElement | undefined>;
+                    focus: import('vue').Ref<boolean>;
+                    size: import('vue').ComputedRef<"" | "default" | "small" | "large">;
+                    disabled: import('vue').ComputedRef<boolean>;
+                    modelValue: import('vue').WritableComputedRef<import('element-plus/es/utils/index.mjs').EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>>;
+                    radioGroup: import('element-plus').RadioGroupContext | undefined;
+                    activeStyle: import('vue').ComputedRef<import('vue').CSSProperties>;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+                    readonly name: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                    readonly size: {
+                        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly label: import('element-plus/es/utils/index.mjs').EpPropFinalized<(NumberConstructor | BooleanConstructor | StringConstructor)[], unknown, unknown, string, boolean>;
+                }>>, {
+                    readonly label: import('element-plus/es/utils/index.mjs').EpPropMergeType<(NumberConstructor | BooleanConstructor | StringConstructor)[], unknown, unknown>;
+                    readonly disabled: boolean;
+                    readonly name: string;
+                }>;
+                RadioGroup: import('vue').DefineComponent<{
+                    readonly id: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                    readonly size: {
+                        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+                    readonly fill: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                    readonly label: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                    readonly textColor: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                    readonly name: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                    readonly validateEvent: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                }, {
+                    props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                        readonly id: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                        readonly size: {
+                            readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly disabled: BooleanConstructor;
+                        readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+                        readonly fill: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                        readonly label: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                        readonly textColor: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                        readonly name: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                        readonly validateEvent: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                    }>> & {
+                        onChange?: ((val: string | number | boolean) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: string | number | boolean) => any) | undefined;
+                    }>>;
+                    emit: ((event: "update:modelValue", val: string | number | boolean) => void) & ((event: "change", val: string | number | boolean) => void);
+                    ns: {
+                        namespace: import('vue').ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string | undefined) => string;
+                        m: (modifier?: string | undefined) => string;
+                        be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                        em: (element?: string | undefined, modifier?: string | undefined) => string;
+                        bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                        bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                        is: {
+                            (name: string, state: boolean | undefined): string;
+                            (name: string): string;
+                        };
+                        cssVar: (object: Record<string, string>) => Record<string, string>;
+                        cssVarName: (name: string) => string;
+                        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                        cssVarBlockName: (name: string) => string;
+                    };
+                    radioId: import('vue').Ref<string>;
+                    radioGroupRef: import('vue').Ref<HTMLDivElement | undefined>;
+                    formItem: import('element-plus').FormItemContext | undefined;
+                    groupId: import('vue').Ref<string | undefined>;
+                    isLabeledByFormItem: import('vue').ComputedRef<boolean>;
+                    changeEvent: (value: import('element-plus/es/utils/index.mjs').EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>) => void;
+                    name: import('vue').ComputedRef<string>;
+                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    "update:modelValue": (val: string | number | boolean) => boolean;
+                    change: (val: string | number | boolean) => boolean;
+                }, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+                    readonly id: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                    readonly size: {
+                        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly disabled: BooleanConstructor;
+                    readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+                    readonly fill: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                    readonly label: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                    readonly textColor: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                    readonly name: import('element-plus/es/utils/index.mjs').EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+                    readonly validateEvent: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                }>> & {
+                    onChange?: ((val: string | number | boolean) => any) | undefined;
+                    "onUpdate:modelValue"?: ((val: string | number | boolean) => any) | undefined;
+                }, {
+                    readonly fill: string;
+                    readonly modelValue: import('element-plus/es/utils/index.mjs').EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
+                    readonly label: string;
+                    readonly id: string;
+                    readonly disabled: boolean;
+                    readonly name: string;
+                    readonly validateEvent: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                    readonly textColor: string;
+                }>;
+            };
+            NodeContent: import('vue').DefineComponent<{}, {
+                ns: {
+                    namespace: import('vue').ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string | undefined) => string;
+                    m: (modifier?: string | undefined) => string;
+                    be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                    em: (element?: string | undefined, modifier?: string | undefined) => string;
+                    bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                    bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                    is: {
+                        (name: string, state: boolean | undefined): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ElIcon: import('element-plus/es/utils/index.mjs').SFCWithInstall<import('vue').DefineComponent<{
+                readonly size: {
+                    readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly color: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }, {
+                props: Readonly<import('@vue/shared').LooseRequired<Readonly<import('vue').ExtractPropTypes<{
+                    readonly size: {
+                        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                    readonly color: {
+                        readonly type: import('vue').PropType<string>;
+                        readonly required: false;
+                        readonly validator: ((val: unknown) => boolean) | undefined;
+                        __epPropKey: true;
+                    };
+                }>> & {
+                    [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+                }>>;
+                ns: {
+                    namespace: import('vue').ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string | undefined) => string;
+                    m: (modifier?: string | undefined) => string;
+                    be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                    em: (element?: string | undefined, modifier?: string | undefined) => string;
+                    bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                    bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                    is: {
+                        (name: string, state: boolean | undefined): string;
+                        (name: string): string;
+                    };
+                    cssVar: (object: Record<string, string>) => Record<string, string>;
+                    cssVarName: (name: string) => string;
+                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                    cssVarBlockName: (name: string) => string;
+                };
+                style: import('vue').ComputedRef<import('vue').CSSProperties>;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly color: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>> & Record<string, any>;
+            Check: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            Loading: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+            ArrowRight: import('vue').DefineComponent<{}, void, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;