fangguo-component 1.0.0

package/dist/components/cascader/cascader/cascader.vue.d.ts

@@ -0,0 +1,3734 @@
+import { nextTick, ComputedRef, Ref, StyleValue } from 'vue';
+import { Options, CascaderNode, CascaderPanelInstance, CascaderValue } from 'element-plus';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        empty?(_: {}): any;
+    };
+    refs: {
+        tooltipRef: {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly showArrow?: boolean;
+                readonly "onUpdate:visible"?: ((value: boolean) => void) & ((...args: any[]) => any);
+                readonly role?: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                readonly appendTo?: string | HTMLElement;
+                readonly content?: string;
+                readonly rawContent?: boolean;
+                readonly persistent?: boolean;
+                readonly visible?: boolean | null;
+                readonly transition?: string;
+                readonly teleported?: boolean;
+                readonly disabled?: boolean;
+                readonly ariaLabel?: import('element-plus').AriaProps["ariaLabel"];
+                readonly showAfter?: number;
+                readonly hideAfter?: number;
+                readonly autoClose?: number;
+                readonly style?: StyleValue;
+                readonly zIndex?: number;
+                readonly offset?: number;
+                readonly id?: string;
+                readonly popperClass?: string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[];
+                readonly placement?: import('element-plus').Placement;
+                readonly strategy?: "fixed" | "absolute";
+                readonly effect?: import('element-plus').PopperEffect;
+                readonly className?: string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[];
+                readonly enterable?: boolean;
+                readonly pure?: boolean;
+                readonly focusOnShow?: boolean;
+                readonly trapping?: boolean;
+                readonly popperStyle?: StyleValue;
+                readonly referenceEl?: HTMLElement;
+                readonly triggerTargetEl?: HTMLElement;
+                readonly stopPopperMouseEvent?: boolean;
+                readonly virtualTriggering?: boolean;
+                readonly loop?: boolean;
+                readonly boundariesPadding?: number;
+                readonly fallbackPlacements?: import('element-plus').Placement[];
+                readonly gpuAcceleration?: boolean;
+                readonly popperOptions?: Partial<Options>;
+                readonly arrowOffset?: number;
+                readonly trigger?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+                readonly triggerKeys?: string[];
+                readonly focusOnTarget?: boolean;
+                readonly virtualRef?: import('element-plus').Measurable;
+                readonly onMouseenter?: (e: MouseEvent) => void;
+                readonly onMouseleave?: (e: MouseEvent) => void;
+                readonly onClick?: (e: PointerEvent) => void;
+                readonly onKeydown?: (e: KeyboardEvent) => void;
+                readonly onFocus?: (e: FocusEvent) => void;
+                readonly onBlur?: (e: FocusEvent) => void;
+                readonly onContextmenu?: (e: PointerEvent) => void;
+                readonly open?: boolean;
+                readonly onClose?: ((...args: any[]) => any) | undefined;
+                readonly onHide?: ((...args: any[]) => any) | undefined;
+                readonly onShow?: ((...args: any[]) => any) | undefined;
+                readonly onOpen?: ((...args: any[]) => any) | undefined;
+                readonly "onBefore-show"?: ((...args: any[]) => any) | undefined;
+                readonly "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "hide", ...args: any[]) => void) & ((event: "show", ...args: any[]) => void) & ((event: "open", ...args: any[]) => void) & ((event: "close", ...args: any[]) => void) & ((event: "update:visible", ...args: any[]) => void) & ((event: "before-show", ...args: any[]) => void) & ((event: "before-hide", ...args: any[]) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').UseTooltipProps> & Readonly<{
+                onClose?: ((...args: any[]) => any) | undefined;
+                onHide?: ((...args: any[]) => any) | undefined;
+                onShow?: ((...args: any[]) => any) | undefined;
+                onOpen?: ((...args: any[]) => any) | undefined;
+                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+                "onBefore-show"?: ((...args: any[]) => any) | undefined;
+                "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                popperRef: Ref<import('element-plus').PopperInstance | undefined, import('element-plus').PopperInstance | undefined>;
+                contentRef: Ref<import('element-plus').TooltipContentInstance | undefined, import('element-plus').TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event, delay?: number) => void;
+                onClose: (event?: Event, delay?: number) => void;
+                hide: (event?: Event) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                close: (...args: any[]) => void;
+                hide: (...args: any[]) => void;
+                show: (...args: any[]) => void;
+                open: (...args: any[]) => void;
+                "update:visible": (...args: any[]) => void;
+                "before-show": (...args: any[]) => void;
+                "before-hide": (...args: any[]) => void;
+            }, string, {
+                offset: number;
+                teleported: boolean;
+                effect: import('element-plus').PopperEffect;
+                visible: boolean | null;
+                content: string;
+                style: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                enterable: boolean;
+                pure: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                popperStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                stopPopperMouseEvent: boolean;
+                virtualTriggering: boolean;
+                loop: boolean;
+                boundariesPadding: number;
+                gpuAcceleration: boolean;
+                placement: import('element-plus').Placement;
+                popperOptions: Partial<Options>;
+                strategy: "fixed" | "absolute";
+                arrowOffset: number;
+                showArrow: boolean;
+                role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+                triggerKeys: string[];
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            offset: number;
+            teleported: boolean;
+            effect: import('element-plus').PopperEffect;
+            visible: boolean | null;
+            content: string;
+            style: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            enterable: boolean;
+            pure: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            popperStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            stopPopperMouseEvent: boolean;
+            virtualTriggering: boolean;
+            loop: boolean;
+            boundariesPadding: number;
+            gpuAcceleration: boolean;
+            placement: import('element-plus').Placement;
+            popperOptions: Partial<Options>;
+            strategy: "fixed" | "absolute";
+            arrowOffset: number;
+            showArrow: boolean;
+            role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+            triggerKeys: string[];
+        }> & Omit<Readonly<import('element-plus').UseTooltipProps> & Readonly<{
+            onClose?: ((...args: any[]) => any) | undefined;
+            onHide?: ((...args: any[]) => any) | undefined;
+            onShow?: ((...args: any[]) => any) | undefined;
+            onOpen?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+            "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        }>, "style" | "content" | "offset" | "visible" | "hide" | "role" | "onClose" | "teleported" | "placement" | "strategy" | "effect" | "enterable" | "pure" | "focusOnShow" | "trapping" | "popperStyle" | "stopPopperMouseEvent" | "virtualTriggering" | "loop" | "boundariesPadding" | "gpuAcceleration" | "popperOptions" | "arrowOffset" | "showArrow" | "showAfter" | "hideAfter" | "autoClose" | "trigger" | "triggerKeys" | "onOpen" | "popperRef" | "contentRef" | "isFocusInsideContent" | "updatePopper"> & {
+            popperRef: import('element-plus').PopperInstance;
+            contentRef: import('element-plus').TooltipContentInstance;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event, delay?: number) => void;
+            onClose: (event?: Event, delay?: number) => void;
+            hide: (event?: Event) => void;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?: (props: {}) => any;
+            } & {
+                content?: (props: {}) => any;
+            };
+        };
+        input: {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly id?: string;
+                readonly size?: import('element-plus').ComponentSize;
+                readonly disabled?: boolean;
+                readonly modelValue?: string | number | null | undefined;
+                readonly modelModifiers?: import('element-plus').InputModelModifiers;
+                readonly maxlength?: string | number;
+                readonly minlength?: string | number;
+                readonly type?: import('element-plus').InputType;
+                readonly resize?: "none" | "both" | "horizontal" | "vertical";
+                readonly autosize?: import('element-plus').InputAutoSize;
+                readonly autocomplete?: string;
+                readonly formatter?: (value: string) => string;
+                readonly parser?: (value: string) => string;
+                readonly placeholder?: string;
+                readonly form?: string;
+                readonly readonly?: boolean;
+                readonly clearable?: boolean;
+                readonly clearIcon?: import('element-plus/es/utils/index.mjs').IconPropType;
+                readonly showPassword?: boolean;
+                readonly showWordLimit?: boolean;
+                readonly wordLimitPosition?: "inside" | "outside";
+                readonly suffixIcon?: import('element-plus/es/utils/index.mjs').IconPropType;
+                readonly prefixIcon?: import('element-plus/es/utils/index.mjs').IconPropType;
+                readonly containerRole?: string;
+                readonly tabindex?: string | number;
+                readonly validateEvent?: boolean;
+                readonly inputStyle?: StyleValue;
+                readonly autofocus?: boolean;
+                readonly rows?: number;
+                readonly ariaLabel?: string;
+                readonly inputmode?: import('vue').HTMLAttributes["inputmode"];
+                readonly name?: string;
+                readonly countGraphemes?: (value: string) => number;
+                readonly onBlur?: ((evt: FocusEvent) => any) | undefined;
+                readonly onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+                readonly onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+                readonly onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+                readonly onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+                readonly onFocus?: ((evt: FocusEvent) => any) | undefined;
+                readonly onInput?: ((value: string) => any) | undefined;
+                readonly onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+                readonly onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+                readonly onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                readonly onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "input", value: string) => void) & ((event: "clear", evt: MouseEvent) => void) & ((event: "change", value: string, evt?: Event) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').InputProps> & Readonly<{
+                onBlur?: ((evt: FocusEvent) => any) | undefined;
+                onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+                onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+                onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+                onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+                onFocus?: ((evt: FocusEvent) => any) | undefined;
+                onInput?: ((value: string) => any) | undefined;
+                onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+                onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+                onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+            }>, {
+                input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+                textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+                ref: ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+                textareaStyle: ComputedRef<StyleValue>;
+                autosize: Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+                isComposing: Ref<boolean, boolean>;
+                passwordVisible: Ref<boolean, boolean>;
+                focus: () => void | undefined;
+                blur: () => void | undefined;
+                select: () => void;
+                clear: (evt?: MouseEvent) => void;
+                resizeTextarea: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (evt: FocusEvent) => void;
+                change: (value: string, evt?: Event | undefined) => void;
+                compositionend: (evt: CompositionEvent) => void;
+                compositionstart: (evt: CompositionEvent) => void;
+                compositionupdate: (evt: CompositionEvent) => void;
+                focus: (evt: FocusEvent) => void;
+                input: (value: string) => void;
+                keydown: (evt: Event | KeyboardEvent) => void;
+                mouseenter: (evt: MouseEvent) => void;
+                mouseleave: (evt: MouseEvent) => void;
+                "update:modelValue": (value: string) => void;
+                clear: (evt: MouseEvent | undefined) => void;
+            }, string, {
+                type: import('element-plus').InputType;
+                disabled: boolean;
+                modelValue: string | number | null;
+                modelModifiers: import('element-plus').InputModelModifiers;
+                autocomplete: string;
+                clearIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+                wordLimitPosition: "inside" | "outside";
+                tabindex: string | number;
+                validateEvent: boolean;
+                inputStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                rows: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            type: import('element-plus').InputType;
+            disabled: boolean;
+            modelValue: string | number | null;
+            modelModifiers: import('element-plus').InputModelModifiers;
+            autocomplete: string;
+            clearIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+            wordLimitPosition: "inside" | "outside";
+            tabindex: string | number;
+            validateEvent: boolean;
+            inputStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            rows: number;
+        }> & Omit<Readonly<import('element-plus').InputProps> & Readonly<{
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+            onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+            onFocus?: ((evt: FocusEvent) => any) | undefined;
+            onInput?: ((value: string) => any) | undefined;
+            onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+            onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+            onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+        }>, "input" | "select" | "textarea" | "clear" | "disabled" | "type" | "ref" | "modelValue" | "tabindex" | "validateEvent" | "focus" | "blur" | "modelModifiers" | "autosize" | "autocomplete" | "clearIcon" | "wordLimitPosition" | "inputStyle" | "rows" | "textareaStyle" | "isComposing" | "passwordVisible" | "resizeTextarea"> & {
+            input: HTMLInputElement;
+            textarea: HTMLTextAreaElement;
+            ref: HTMLInputElement | HTMLTextAreaElement;
+            textareaStyle: StyleValue;
+            autosize: import('element-plus').InputAutoSize;
+            isComposing: boolean;
+            passwordVisible: boolean;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            select: () => void;
+            clear: (evt?: MouseEvent) => void;
+            resizeTextarea: () => void;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                prepend?: (props: {}) => any;
+            } & {
+                prefix?: (props: {}) => any;
+            } & {
+                suffix?: (props: {}) => any;
+            } & {
+                'password-icon'?: (props: {
+                    visible: boolean;
+                }) => any;
+            } & {
+                append?: (props: {}) => any;
+            };
+        };
+        tagWrapper: HTMLDivElement;
+        cascaderPanelRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            border: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            inputWidth: {
+                type: NumberConstructor;
+                default: number;
+            };
+            renderLabel: import('vue').PropType<import('../cascader-panel/node').RenderLabel>;
+            modelValue: {
+                readonly type: import('vue').PropType<import('../utils/vue').EpPropMergeType<import('vue').PropType<import('../cascader-panel/node').CascaderValue>, unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            options: import('../utils/vue').EpPropFinalized<import('vue').PropType<import('.').CascaderOption[]>, unknown, unknown, () => import('.').CascaderOption[], boolean>;
+            props: import('../utils/vue').EpPropFinalized<import('vue').PropType<import('.').CascaderProps>, unknown, unknown, () => import('.').CascaderProps, boolean>;
+        }>> & Readonly<{
+            onChange?: (...args: any[]) => any;
+            "onUpdate:modelValue"?: (...args: any[]) => any;
+            onClose?: (...args: any[]) => any;
+            "onExpand-change"?: (...args: any[]) => any;
+        }>, {
+            ns: {
+                namespace: ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => 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: Ref<any[], any[]>;
+            menuRenderKey: Ref<number, number>;
+            menus: Ref<{
+                readonly uid: number;
+                readonly level: number;
+                readonly value: import('../cascader-panel/node').CascaderNodeValue;
+                readonly label: string;
+                readonly pathNodes: /*elided*/ any[];
+                readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+                readonly pathLabels: string[];
+                childrenData: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                }[];
+                children: /*elided*/ any[];
+                text: string;
+                loaded: boolean;
+                checked: boolean;
+                indeterminate: boolean;
+                loading: boolean;
+                readonly data: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                };
+                readonly config: {
+                    expandTrigger: import('.').ExpandTrigger;
+                    multiple: boolean;
+                    checkStrictly: boolean;
+                    emitPath: boolean;
+                    lazy: boolean;
+                    lazyLoad: import('../cascader-panel/node').LazyLoad;
+                    value: string;
+                    label: string;
+                    children: string;
+                    disabled: string | import('../cascader-panel/node').isDisabled;
+                    leaf: string | import('../cascader-panel/node').isLeaf;
+                    hoverThreshold: number;
+                };
+                readonly parent?: /*elided*/ any;
+                readonly root: boolean;
+                readonly isDisabled: boolean;
+                readonly isLeaf: boolean;
+                readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+                appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+                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;
+            }[][], import('.').CascaderNode[][] | {
+                readonly uid: number;
+                readonly level: number;
+                readonly value: import('../cascader-panel/node').CascaderNodeValue;
+                readonly label: string;
+                readonly pathNodes: /*elided*/ any[];
+                readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+                readonly pathLabels: string[];
+                childrenData: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                }[];
+                children: /*elided*/ any[];
+                text: string;
+                loaded: boolean;
+                checked: boolean;
+                indeterminate: boolean;
+                loading: boolean;
+                readonly data: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                };
+                readonly config: {
+                    expandTrigger: import('.').ExpandTrigger;
+                    multiple: boolean;
+                    checkStrictly: boolean;
+                    emitPath: boolean;
+                    lazy: boolean;
+                    lazyLoad: import('../cascader-panel/node').LazyLoad;
+                    value: string;
+                    label: string;
+                    children: string;
+                    disabled: string | import('../cascader-panel/node').isDisabled;
+                    leaf: string | import('../cascader-panel/node').isLeaf;
+                    hoverThreshold: number;
+                };
+                readonly parent?: /*elided*/ any;
+                readonly root: boolean;
+                readonly isDisabled: boolean;
+                readonly isLeaf: boolean;
+                readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+                appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+                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: Ref<{
+                readonly uid: number;
+                readonly level: number;
+                readonly value: import('../cascader-panel/node').CascaderNodeValue;
+                readonly label: string;
+                readonly pathNodes: /*elided*/ any[];
+                readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+                readonly pathLabels: string[];
+                childrenData: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                }[];
+                children: /*elided*/ any[];
+                text: string;
+                loaded: boolean;
+                checked: boolean;
+                indeterminate: boolean;
+                loading: boolean;
+                readonly data: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                };
+                readonly config: {
+                    expandTrigger: import('.').ExpandTrigger;
+                    multiple: boolean;
+                    checkStrictly: boolean;
+                    emitPath: boolean;
+                    lazy: boolean;
+                    lazyLoad: import('../cascader-panel/node').LazyLoad;
+                    value: string;
+                    label: string;
+                    children: string;
+                    disabled: string | import('../cascader-panel/node').isDisabled;
+                    leaf: string | import('../cascader-panel/node').isLeaf;
+                    hoverThreshold: number;
+                };
+                readonly parent?: /*elided*/ any;
+                readonly root: boolean;
+                readonly isDisabled: boolean;
+                readonly isLeaf: boolean;
+                readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+                appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+                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;
+            }[], import('.').CascaderNode[] | {
+                readonly uid: number;
+                readonly level: number;
+                readonly value: import('../cascader-panel/node').CascaderNodeValue;
+                readonly label: string;
+                readonly pathNodes: /*elided*/ any[];
+                readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+                readonly pathLabels: string[];
+                childrenData: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                }[];
+                children: /*elided*/ any[];
+                text: string;
+                loaded: boolean;
+                checked: boolean;
+                indeterminate: boolean;
+                loading: boolean;
+                readonly data: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                };
+                readonly config: {
+                    expandTrigger: import('.').ExpandTrigger;
+                    multiple: boolean;
+                    checkStrictly: boolean;
+                    emitPath: boolean;
+                    lazy: boolean;
+                    lazyLoad: import('../cascader-panel/node').LazyLoad;
+                    value: string;
+                    label: string;
+                    children: string;
+                    disabled: string | import('../cascader-panel/node').isDisabled;
+                    leaf: string | import('../cascader-panel/node').isLeaf;
+                    hoverThreshold: number;
+                };
+                readonly parent?: /*elided*/ any;
+                readonly root: boolean;
+                readonly isDisabled: boolean;
+                readonly isLeaf: boolean;
+                readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+                appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+                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: import('.').CascaderNode, checked: boolean, emitClose?: boolean) => void;
+            getFlattedNodes: (leafOnly: boolean) => import('.').CascaderNode[];
+            getCheckedNodes: (leafOnly: boolean) => import('.').CascaderNode[];
+            clearCheckedNodes: () => void;
+            calculateCheckedValue: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("change" | "update:modelValue" | "close" | "expand-change")[], import('vue').PublicProps, {
+            border: boolean;
+            props: import('.').CascaderProps;
+            options: import('.').CascaderOption[];
+            inputWidth: number;
+        }, true, {}, {}, {
+            CustomCascaderMenu: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                nodes: {
+                    type: import('vue').PropType<import('.').CascaderNode[]>;
+                    required: true;
+                };
+                index: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+            }>, {
+                ns: {
+                    namespace: ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string) => string;
+                    m: (modifier?: string) => string;
+                    be: (blockSuffix?: string, element?: string) => string;
+                    em: (element?: string, modifier?: string) => string;
+                    bm: (blockSuffix?: string, modifier?: string) => string;
+                    bem: (blockSuffix?: string, element?: string, modifier?: string) => 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: import('.').ElCascaderPanelContext;
+                hoverZone: Ref<SVGSVGElement, SVGSVGElement>;
+                isEmpty: ComputedRef<boolean>;
+                isLoading: ComputedRef<boolean>;
+                menuId: ComputedRef<string>;
+                menuWidth: ComputedRef<number>;
+                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: import('vue').PropType<import('.').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<{
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                })>;
+                ElScrollbar: import('element-plus/es/utils/index.mjs').SFCWithInstall<{
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ScrollbarProps> & Readonly<{
+                        onScroll?: ((args_0: {
+                            scrollTop: number;
+                            scrollLeft: number;
+                        }) => any) | undefined;
+                        "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+                    }>, {
+                        wrapRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                        update: () => void;
+                        scrollTo: {
+                            (xCord: number, yCord?: number): void;
+                            (options: ScrollToOptions): void;
+                        };
+                        setScrollTop: (value: number) => void;
+                        setScrollLeft: (value: number) => void;
+                        handleScroll: () => void;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        scroll: (args_0: {
+                            scrollTop: number;
+                            scrollLeft: number;
+                        }) => void;
+                        "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
+                    }, import('vue').PublicProps, {
+                        tabindex: number | string;
+                        height: number | string;
+                        maxHeight: number | string;
+                        tag: keyof HTMLElementTagNameMap | (string & {});
+                        distance: number;
+                        wrapStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                        wrapClass: string | string[];
+                        viewClass: string | string[];
+                        viewStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                        minSize: number;
+                    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus').ScrollbarProps> & Readonly<{
+                        onScroll?: ((args_0: {
+                            scrollTop: number;
+                            scrollLeft: number;
+                        }) => any) | undefined;
+                        "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+                    }>, {
+                        wrapRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                        update: () => void;
+                        scrollTo: {
+                            (xCord: number, yCord?: number): void;
+                            (options: ScrollToOptions): void;
+                        };
+                        setScrollTop: (value: number) => void;
+                        setScrollLeft: (value: number) => void;
+                        handleScroll: () => void;
+                    }, {}, {}, {}, {
+                        tabindex: number | string;
+                        height: number | string;
+                        maxHeight: number | string;
+                        tag: keyof HTMLElementTagNameMap | (string & {});
+                        distance: number;
+                        wrapStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                        wrapClass: string | string[];
+                        viewClass: string | string[];
+                        viewStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                        minSize: number;
+                    }>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ScrollbarProps> & Readonly<{
+                    onScroll?: ((args_0: {
+                        scrollTop: number;
+                        scrollLeft: number;
+                    }) => any) | undefined;
+                    "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+                }>, {
+                    wrapRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                    update: () => void;
+                    scrollTo: {
+                        (xCord: number, yCord?: number): void;
+                        (options: ScrollToOptions): void;
+                    };
+                    setScrollTop: (value: number) => void;
+                    setScrollLeft: (value: number) => void;
+                    handleScroll: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    scroll: (args_0: {
+                        scrollTop: number;
+                        scrollLeft: number;
+                    }) => void;
+                    "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
+                }, string, {
+                    tabindex: number | string;
+                    height: number | string;
+                    maxHeight: number | string;
+                    tag: keyof HTMLElementTagNameMap | (string & {});
+                    distance: number;
+                    wrapStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                    wrapClass: string | string[];
+                    viewClass: string | string[];
+                    viewStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                    minSize: number;
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                })>;
+                RecycleScroller: import('vue').DefineComponent<any, any, any>;
+                CustomCascaderNode: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                    node: {
+                        type: import('vue').PropType<import('.').CascaderNode>;
+                        required: true;
+                    };
+                    menuId: StringConstructor;
+                }>, {
+                    panel: import('.').ElCascaderPanelContext;
+                    isHoverMenu: ComputedRef<boolean>;
+                    multiple: ComputedRef<boolean>;
+                    checkStrictly: ComputedRef<boolean>;
+                    checkedNodeId: ComputedRef<number>;
+                    isDisabled: ComputedRef<boolean>;
+                    isLeaf: ComputedRef<boolean>;
+                    expandable: ComputedRef<boolean>;
+                    inExpandingPath: ComputedRef<boolean>;
+                    inCheckedPath: ComputedRef<boolean>;
+                    ns: {
+                        namespace: ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string) => string;
+                        m: (modifier?: string) => string;
+                        be: (blockSuffix?: string, element?: string) => string;
+                        em: (element?: string, modifier?: string) => string;
+                        bm: (blockSuffix?: string, modifier?: string) => string;
+                        bem: (blockSuffix?: string, element?: string, modifier?: string) => 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: import('vue').PropType<import('.').CascaderNode>;
+                        required: true;
+                    };
+                    menuId: StringConstructor;
+                }>> & Readonly<{
+                    onExpand?: (...args: any[]) => any;
+                }>, {}, {}, {
+                    ElCheckbox: {
+                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                            onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                            change: (val: import('element-plus').CheckboxValueType) => void;
+                            "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                        }, import('vue').PublicProps, {
+                            id: string;
+                            disabled: boolean;
+                            modelValue: number | string | boolean;
+                            validateEvent: boolean;
+                            name: string;
+                            value: string | boolean | number | object;
+                            label: string | boolean | number | object;
+                            trueValue: string | number;
+                            falseValue: string | number;
+                            trueLabel: string | number;
+                            falseLabel: string | number;
+                        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                            onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, {
+                            id: string;
+                            disabled: boolean;
+                            modelValue: number | string | boolean;
+                            validateEvent: boolean;
+                            name: string;
+                            value: string | boolean | number | object;
+                            label: string | boolean | number | object;
+                            trueValue: string | number;
+                            falseValue: string | number;
+                            trueLabel: string | number;
+                            falseLabel: string | number;
+                        }>;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                        onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        change: (val: import('element-plus').CheckboxValueType) => void;
+                        "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                    }, string, {
+                        id: string;
+                        disabled: boolean;
+                        modelValue: number | string | boolean;
+                        validateEvent: boolean;
+                        name: string;
+                        value: string | boolean | number | object;
+                        label: string | boolean | number | object;
+                        trueValue: string | number;
+                        falseValue: string | number;
+                        trueLabel: string | number;
+                        falseLabel: string | number;
+                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                        $slots: {
+                            default?: (props: {}) => any;
+                        };
+                    }) & import('vue').ObjectPlugin & {
+                        setPropsDefaults: (defaults: Partial<Omit<{
+                            readonly modelValue?: number | string | boolean;
+                            readonly label?: string | boolean | number | object;
+                            readonly value?: string | boolean | number | object;
+                            readonly indeterminate?: boolean;
+                            readonly disabled?: boolean;
+                            readonly checked?: boolean;
+                            readonly name?: string;
+                            readonly trueValue?: string | number;
+                            readonly falseValue?: string | number;
+                            readonly trueLabel?: string | number;
+                            readonly falseLabel?: string | number;
+                            readonly id?: string;
+                            readonly border?: boolean;
+                            readonly size?: import('element-plus').ComponentSize;
+                            readonly tabindex?: string | number;
+                            readonly validateEvent?: boolean;
+                            readonly ariaLabel?: string;
+                            readonly ariaControls?: string;
+                            readonly onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                            readonly "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "onChange" | "onUpdate:modelValue" | keyof import('vue').VNodeProps | keyof import('vue').AllowedComponentProps>>) => void;
+                    } & {
+                        CheckboxButton: {
+                            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                                onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                                change: (val: import('element-plus').CheckboxValueType) => void;
+                                "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                            }, import('vue').PublicProps, {
+                                id: string;
+                                disabled: boolean;
+                                modelValue: number | string | boolean;
+                                validateEvent: boolean;
+                                name: string;
+                                value: string | boolean | number | object;
+                                label: string | boolean | number | object;
+                                trueValue: string | number;
+                                falseValue: string | number;
+                                trueLabel: string | number;
+                                falseLabel: string | number;
+                            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                                P: {};
+                                B: {};
+                                D: {};
+                                C: {};
+                                M: {};
+                                Defaults: {};
+                            }, Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                                onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                            }>, {}, {}, {}, {}, {
+                                id: string;
+                                disabled: boolean;
+                                modelValue: number | string | boolean;
+                                validateEvent: boolean;
+                                name: string;
+                                value: string | boolean | number | object;
+                                label: string | boolean | number | object;
+                                trueValue: string | number;
+                                falseValue: string | number;
+                                trueLabel: string | number;
+                                falseLabel: string | number;
+                            }>;
+                            __isFragment?: never;
+                            __isTeleport?: never;
+                            __isSuspense?: never;
+                        } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                            onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                            change: (val: import('element-plus').CheckboxValueType) => void;
+                            "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                        }, string, {
+                            id: string;
+                            disabled: boolean;
+                            modelValue: number | string | boolean;
+                            validateEvent: boolean;
+                            name: string;
+                            value: string | boolean | number | object;
+                            label: string | boolean | number | object;
+                            trueValue: string | number;
+                            falseValue: string | number;
+                            trueLabel: string | number;
+                            falseLabel: string | number;
+                        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                            $slots: {
+                                default?: (props: {}) => any;
+                            };
+                        });
+                        CheckboxGroup: {
+                            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').CheckboxGroupProps> & Readonly<{
+                                onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                                change: (val: import('element-plus').CheckboxValueType[]) => void;
+                                "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
+                            }, import('vue').PublicProps, {
+                                props: {
+                                    value?: string;
+                                    label?: string;
+                                    disabled?: string;
+                                };
+                                type: "checkbox" | "button";
+                                disabled: boolean;
+                                modelValue: import('element-plus').CheckboxGroupValueType;
+                                validateEvent: boolean;
+                                tag: string;
+                            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                                P: {};
+                                B: {};
+                                D: {};
+                                C: {};
+                                M: {};
+                                Defaults: {};
+                            }, Readonly<import('element-plus').CheckboxGroupProps> & Readonly<{
+                                onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                                "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                            }>, {}, {}, {}, {}, {
+                                props: {
+                                    value?: string;
+                                    label?: string;
+                                    disabled?: string;
+                                };
+                                type: "checkbox" | "button";
+                                disabled: boolean;
+                                modelValue: import('element-plus').CheckboxGroupValueType;
+                                validateEvent: boolean;
+                                tag: string;
+                            }>;
+                            __isFragment?: never;
+                            __isTeleport?: never;
+                            __isSuspense?: never;
+                        } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').CheckboxGroupProps> & Readonly<{
+                            onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                            change: (val: import('element-plus').CheckboxValueType[]) => void;
+                            "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
+                        }, string, {
+                            props: {
+                                value?: string;
+                                label?: string;
+                                disabled?: string;
+                            };
+                            type: "checkbox" | "button";
+                            disabled: boolean;
+                            modelValue: import('element-plus').CheckboxGroupValueType;
+                            validateEvent: boolean;
+                            tag: string;
+                        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                            $slots: {
+                                default?: (props: {}) => any;
+                            };
+                        });
+                    };
+                    ElRadio: {
+                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').RadioProps> & Readonly<{
+                            onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                            change: (val: string | number | boolean | undefined) => void;
+                            "update:modelValue": (val: string | number | boolean | undefined) => void;
+                        }, import('vue').PublicProps, {
+                            disabled: boolean;
+                            modelValue: string | number | boolean;
+                            name: string;
+                            value: string | number | boolean;
+                            border: boolean;
+                            label: string | number | boolean;
+                        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import('element-plus').RadioProps> & Readonly<{
+                            onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                        }>, {}, {}, {}, {}, {
+                            disabled: boolean;
+                            modelValue: string | number | boolean;
+                            name: string;
+                            value: string | number | boolean;
+                            border: boolean;
+                            label: string | number | boolean;
+                        }>;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').RadioProps> & Readonly<{
+                        onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        change: (val: string | number | boolean | undefined) => void;
+                        "update:modelValue": (val: string | number | boolean | undefined) => void;
+                    }, string, {
+                        disabled: boolean;
+                        modelValue: string | number | boolean;
+                        name: string;
+                        value: string | number | boolean;
+                        border: boolean;
+                        label: string | number | boolean;
+                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                        $slots: {
+                            default?: (props: {}) => any;
+                        };
+                    }) & import('vue').ObjectPlugin & {
+                        setPropsDefaults: (defaults: Partial<Omit<{
+                            readonly border?: boolean;
+                            readonly modelValue?: string | number | boolean;
+                            readonly size?: import('element-plus').ComponentSize;
+                            readonly disabled?: boolean;
+                            readonly label?: string | number | boolean;
+                            readonly value?: string | number | boolean;
+                            readonly name?: string;
+                            readonly onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                            readonly "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "onChange" | "onUpdate:modelValue" | keyof import('vue').VNodeProps | keyof import('vue').AllowedComponentProps>>) => void;
+                    } & {
+                        RadioButton: {
+                            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').RadioButtonProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                                disabled: boolean;
+                                modelValue: string | number | boolean;
+                                name: string;
+                                value: string | number | boolean;
+                                label: string | number | boolean;
+                            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                                P: {};
+                                B: {};
+                                D: {};
+                                C: {};
+                                M: {};
+                                Defaults: {};
+                            }, Readonly<import('element-plus').RadioButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
+                                disabled: boolean;
+                                modelValue: string | number | boolean;
+                                name: string;
+                                value: string | number | boolean;
+                                label: string | number | boolean;
+                            }>;
+                            __isFragment?: never;
+                            __isTeleport?: never;
+                            __isSuspense?: never;
+                        } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').RadioButtonProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                            disabled: boolean;
+                            modelValue: string | number | boolean;
+                            name: string;
+                            value: string | number | boolean;
+                            label: string | number | boolean;
+                        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                            $slots: {
+                                default?: (props: {}) => any;
+                            };
+                        });
+                        RadioGroup: {
+                            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').RadioGroupProps> & Readonly<{
+                                onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                                "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                                change: (val: string | number | boolean | undefined) => void;
+                                "update:modelValue": (val: string | number | boolean | undefined) => void;
+                            }, import('vue').PublicProps, {
+                                fill: string;
+                                props: import('element-plus').radioOptionProp;
+                                type: "radio" | "button";
+                                id: string;
+                                disabled: boolean;
+                                modelValue: string | number | boolean;
+                                validateEvent: boolean;
+                                name: string;
+                                textColor: string;
+                            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                                P: {};
+                                B: {};
+                                D: {};
+                                C: {};
+                                M: {};
+                                Defaults: {};
+                            }, Readonly<import('element-plus').RadioGroupProps> & Readonly<{
+                                onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                                "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                            }>, {}, {}, {}, {}, {
+                                fill: string;
+                                props: import('element-plus').radioOptionProp;
+                                type: "radio" | "button";
+                                id: string;
+                                disabled: boolean;
+                                modelValue: string | number | boolean;
+                                validateEvent: boolean;
+                                name: string;
+                                textColor: string;
+                            }>;
+                            __isFragment?: never;
+                            __isTeleport?: never;
+                            __isSuspense?: never;
+                        } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').RadioGroupProps> & Readonly<{
+                            onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                            change: (val: string | number | boolean | undefined) => void;
+                            "update:modelValue": (val: string | number | boolean | undefined) => void;
+                        }, string, {
+                            fill: string;
+                            props: import('element-plus').radioOptionProp;
+                            type: "radio" | "button";
+                            id: string;
+                            disabled: boolean;
+                            modelValue: string | number | boolean;
+                            validateEvent: boolean;
+                            name: string;
+                            textColor: string;
+                        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                            $slots: {
+                                default?: (props: {}) => any;
+                            };
+                        });
+                    };
+                    NodeContent: import('vue').DefineComponent<{}, {
+                        ns: {
+                            namespace: ComputedRef<string>;
+                            b: (blockSuffix?: string) => string;
+                            e: (element?: string) => string;
+                            m: (modifier?: string) => string;
+                            be: (blockSuffix?: string, element?: string) => string;
+                            em: (element?: string, modifier?: string) => string;
+                            bm: (blockSuffix?: string, modifier?: string) => string;
+                            bem: (blockSuffix?: string, element?: string, modifier?: string) => 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<{
+                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                        $slots: {
+                            default?: (props: {}) => 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>;
+        } & import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            border: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            inputWidth: {
+                type: NumberConstructor;
+                default: number;
+            };
+            renderLabel: import('vue').PropType<import('../cascader-panel/node').RenderLabel>;
+            modelValue: {
+                readonly type: import('vue').PropType<import('../utils/vue').EpPropMergeType<import('vue').PropType<import('../cascader-panel/node').CascaderValue>, unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            options: import('../utils/vue').EpPropFinalized<import('vue').PropType<import('.').CascaderOption[]>, unknown, unknown, () => import('.').CascaderOption[], boolean>;
+            props: import('../utils/vue').EpPropFinalized<import('vue').PropType<import('.').CascaderProps>, unknown, unknown, () => import('.').CascaderProps, boolean>;
+        }>> & Readonly<{
+            onChange?: (...args: any[]) => any;
+            "onUpdate:modelValue"?: (...args: any[]) => any;
+            onClose?: (...args: any[]) => any;
+            "onExpand-change"?: (...args: any[]) => any;
+        }>, {
+            ns: {
+                namespace: ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => 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: Ref<any[], any[]>;
+            menuRenderKey: Ref<number, number>;
+            menus: Ref<{
+                readonly uid: number;
+                readonly level: number;
+                readonly value: import('../cascader-panel/node').CascaderNodeValue;
+                readonly label: string;
+                readonly pathNodes: /*elided*/ any[];
+                readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+                readonly pathLabels: string[];
+                childrenData: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                }[];
+                children: /*elided*/ any[];
+                text: string;
+                loaded: boolean;
+                checked: boolean;
+                indeterminate: boolean;
+                loading: boolean;
+                readonly data: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                };
+                readonly config: {
+                    expandTrigger: import('.').ExpandTrigger;
+                    multiple: boolean;
+                    checkStrictly: boolean;
+                    emitPath: boolean;
+                    lazy: boolean;
+                    lazyLoad: import('../cascader-panel/node').LazyLoad;
+                    value: string;
+                    label: string;
+                    children: string;
+                    disabled: string | import('../cascader-panel/node').isDisabled;
+                    leaf: string | import('../cascader-panel/node').isLeaf;
+                    hoverThreshold: number;
+                };
+                readonly parent?: /*elided*/ any;
+                readonly root: boolean;
+                readonly isDisabled: boolean;
+                readonly isLeaf: boolean;
+                readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+                appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+                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;
+            }[][], import('.').CascaderNode[][] | {
+                readonly uid: number;
+                readonly level: number;
+                readonly value: import('../cascader-panel/node').CascaderNodeValue;
+                readonly label: string;
+                readonly pathNodes: /*elided*/ any[];
+                readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+                readonly pathLabels: string[];
+                childrenData: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                }[];
+                children: /*elided*/ any[];
+                text: string;
+                loaded: boolean;
+                checked: boolean;
+                indeterminate: boolean;
+                loading: boolean;
+                readonly data: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                };
+                readonly config: {
+                    expandTrigger: import('.').ExpandTrigger;
+                    multiple: boolean;
+                    checkStrictly: boolean;
+                    emitPath: boolean;
+                    lazy: boolean;
+                    lazyLoad: import('../cascader-panel/node').LazyLoad;
+                    value: string;
+                    label: string;
+                    children: string;
+                    disabled: string | import('../cascader-panel/node').isDisabled;
+                    leaf: string | import('../cascader-panel/node').isLeaf;
+                    hoverThreshold: number;
+                };
+                readonly parent?: /*elided*/ any;
+                readonly root: boolean;
+                readonly isDisabled: boolean;
+                readonly isLeaf: boolean;
+                readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+                appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+                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: Ref<{
+                readonly uid: number;
+                readonly level: number;
+                readonly value: import('../cascader-panel/node').CascaderNodeValue;
+                readonly label: string;
+                readonly pathNodes: /*elided*/ any[];
+                readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+                readonly pathLabels: string[];
+                childrenData: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                }[];
+                children: /*elided*/ any[];
+                text: string;
+                loaded: boolean;
+                checked: boolean;
+                indeterminate: boolean;
+                loading: boolean;
+                readonly data: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                };
+                readonly config: {
+                    expandTrigger: import('.').ExpandTrigger;
+                    multiple: boolean;
+                    checkStrictly: boolean;
+                    emitPath: boolean;
+                    lazy: boolean;
+                    lazyLoad: import('../cascader-panel/node').LazyLoad;
+                    value: string;
+                    label: string;
+                    children: string;
+                    disabled: string | import('../cascader-panel/node').isDisabled;
+                    leaf: string | import('../cascader-panel/node').isLeaf;
+                    hoverThreshold: number;
+                };
+                readonly parent?: /*elided*/ any;
+                readonly root: boolean;
+                readonly isDisabled: boolean;
+                readonly isLeaf: boolean;
+                readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+                appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+                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;
+            }[], import('.').CascaderNode[] | {
+                readonly uid: number;
+                readonly level: number;
+                readonly value: import('../cascader-panel/node').CascaderNodeValue;
+                readonly label: string;
+                readonly pathNodes: /*elided*/ any[];
+                readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+                readonly pathLabels: string[];
+                childrenData: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                }[];
+                children: /*elided*/ any[];
+                text: string;
+                loaded: boolean;
+                checked: boolean;
+                indeterminate: boolean;
+                loading: boolean;
+                readonly data: {
+                    [x: string]: unknown;
+                    label?: string;
+                    value?: import('../cascader-panel/node').CascaderNodeValue;
+                    children?: /*elided*/ any[];
+                    disabled?: boolean;
+                    leaf?: boolean;
+                };
+                readonly config: {
+                    expandTrigger: import('.').ExpandTrigger;
+                    multiple: boolean;
+                    checkStrictly: boolean;
+                    emitPath: boolean;
+                    lazy: boolean;
+                    lazyLoad: import('../cascader-panel/node').LazyLoad;
+                    value: string;
+                    label: string;
+                    children: string;
+                    disabled: string | import('../cascader-panel/node').isDisabled;
+                    leaf: string | import('../cascader-panel/node').isLeaf;
+                    hoverThreshold: number;
+                };
+                readonly parent?: /*elided*/ any;
+                readonly root: boolean;
+                readonly isDisabled: boolean;
+                readonly isLeaf: boolean;
+                readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+                appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+                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: import('.').CascaderNode, checked: boolean, emitClose?: boolean) => void;
+            getFlattedNodes: (leafOnly: boolean) => import('.').CascaderNode[];
+            getCheckedNodes: (leafOnly: boolean) => import('.').CascaderNode[];
+            clearCheckedNodes: () => void;
+            calculateCheckedValue: () => void;
+        }, {}, {}, {}, {
+            border: boolean;
+            props: import('.').CascaderProps;
+            options: import('.').CascaderOption[];
+            inputWidth: number;
+        }>;
+        suggestionPanel: {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly distance?: number;
+                readonly height?: number | string;
+                readonly maxHeight?: number | string;
+                readonly native?: boolean;
+                readonly wrapStyle?: StyleValue;
+                readonly wrapClass?: string | string[];
+                readonly viewClass?: string | string[];
+                readonly viewStyle?: StyleValue;
+                readonly noresize?: boolean;
+                readonly tag?: keyof HTMLElementTagNameMap | (string & {});
+                readonly always?: boolean;
+                readonly minSize?: number;
+                readonly tabindex?: number | string;
+                readonly id?: string;
+                readonly role?: string;
+                readonly ariaLabel?: string;
+                readonly ariaOrientation?: "horizontal" | "vertical" | "undefined";
+                readonly onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                readonly "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "scroll", args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void) & ((event: "end-reached", direction: import('element-plus').ScrollbarDirection) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').ScrollbarProps> & Readonly<{
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+            }>, {
+                wrapRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                update: () => void;
+                scrollTo: {
+                    (xCord: number, yCord?: number): void;
+                    (options: ScrollToOptions): void;
+                };
+                setScrollTop: (value: number) => void;
+                setScrollLeft: (value: number) => void;
+                handleScroll: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                scroll: (args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => void;
+                "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
+            }, string, {
+                tabindex: number | string;
+                height: number | string;
+                maxHeight: number | string;
+                tag: keyof HTMLElementTagNameMap | (string & {});
+                distance: number;
+                wrapStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                wrapClass: string | string[];
+                viewClass: string | string[];
+                viewStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                minSize: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            tabindex: number | string;
+            height: number | string;
+            maxHeight: number | string;
+            tag: keyof HTMLElementTagNameMap | (string & {});
+            distance: number;
+            wrapStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            wrapClass: string | string[];
+            viewClass: string | string[];
+            viewStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            minSize: number;
+        }> & Omit<Readonly<import('element-plus').ScrollbarProps> & Readonly<{
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+        }>, "height" | "maxHeight" | "tabindex" | "tag" | "distance" | "wrapStyle" | "wrapClass" | "viewClass" | "viewStyle" | "minSize" | "wrapRef" | "update" | "scrollTo" | "setScrollTop" | "setScrollLeft" | "handleScroll"> & {
+            wrapRef: HTMLDivElement;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        };
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    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;
+    };
+    placeholder: StringConstructor;
+    disabled: BooleanConstructor;
+    clearable: BooleanConstructor;
+    filterable: BooleanConstructor;
+    filterMethod: import('../utils/vue').EpPropFinalized<import('vue').PropType<(node: CascaderNode, keyword: string) => boolean>, unknown, unknown, (node: CascaderNode, keyword: string) => boolean, boolean>;
+    separator: import('../utils/vue').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    showAllLevels: import('../utils/vue').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    collapseTags: BooleanConstructor;
+    maxCollapseTags: import('../utils/vue').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    collapseTagsTooltip: import('../utils/vue').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    debounce: import('../utils/vue').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    beforeFilter: import('../utils/vue').EpPropFinalized<import('vue').PropType<(value: string) => boolean | Promise<any>>, unknown, unknown, () => true, boolean>;
+    popperClass: import('../utils/vue').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    teleported: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    tagType: {
+        default: string;
+        type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "info" | "primary" | "success" | "warning" | "danger", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    validateEvent: import('../utils/vue').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    modelValue: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<(new (...args: any[]) => string | number | Record<string, any> | import('element-plus').CascaderNodePathValue | (import('element-plus').CascaderNodeValue | import('element-plus').CascaderNodePathValue)[]) | (() => CascaderValue | null) | (((new (...args: any[]) => string | number | Record<string, any> | import('element-plus').CascaderNodePathValue | (import('element-plus').CascaderNodeValue | import('element-plus').CascaderNodePathValue)[]) | (() => CascaderValue | null)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    options: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => import('element-plus').CascaderOption[]) | (() => import('element-plus').CascaderOption[]) | (((new (...args: any[]) => import('element-plus').CascaderOption[]) | (() => import('element-plus').CascaderOption[])) | null)[], unknown, unknown, () => import('element-plus').CascaderOption[], boolean>;
+    props: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => import('element-plus').CascaderProps) | (() => import('element-plus').CascaderProps) | (((new (...args: any[]) => import('element-plus').CascaderProps) | (() => import('element-plus').CascaderProps)) | null)[], unknown, unknown, () => import('element-plus').CascaderProps, boolean>;
+}>, {
+    /**
+   * @description get an array of currently selected node,(leafOnly) whether only return the leaf checked nodes, default is `false`
+   */
+    getCheckedNodes: (leafOnly: boolean) => CascaderNode[];
+    /**
+   * @description cascader panel ref
+   */
+    cascaderPanelRef: Ref<CascaderPanelInstance, CascaderPanelInstance>;
+    /**
+   * @description toggle the visible of popper
+   */
+    togglePopperVisible: (visible?: boolean) => void;
+    /**
+   * @description cascader content ref
+   */
+    contentRef: any;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (val: CascaderValue) => void;
+    change: (val: CascaderValue) => void;
+    focus: (evt: FocusEvent) => void;
+    blur: (evt: FocusEvent) => void;
+    visibleChange: (val: boolean) => void;
+    expandChange: (val: CascaderValue) => void;
+    removeTag: (val: import('element-plus').CascaderNodeValue | import('element-plus').CascaderNodePathValue) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    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;
+    };
+    placeholder: StringConstructor;
+    disabled: BooleanConstructor;
+    clearable: BooleanConstructor;
+    filterable: BooleanConstructor;
+    filterMethod: import('../utils/vue').EpPropFinalized<import('vue').PropType<(node: CascaderNode, keyword: string) => boolean>, unknown, unknown, (node: CascaderNode, keyword: string) => boolean, boolean>;
+    separator: import('../utils/vue').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    showAllLevels: import('../utils/vue').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    collapseTags: BooleanConstructor;
+    maxCollapseTags: import('../utils/vue').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    collapseTagsTooltip: import('../utils/vue').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    debounce: import('../utils/vue').EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    beforeFilter: import('../utils/vue').EpPropFinalized<import('vue').PropType<(value: string) => boolean | Promise<any>>, unknown, unknown, () => true, boolean>;
+    popperClass: import('../utils/vue').EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    teleported: import('element-plus/es/utils/index.mjs').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    tagType: {
+        default: string;
+        type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "info" | "primary" | "success" | "warning" | "danger", unknown>>;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    validateEvent: import('../utils/vue').EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    modelValue: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index.mjs').EpPropMergeType<(new (...args: any[]) => string | number | Record<string, any> | import('element-plus').CascaderNodePathValue | (import('element-plus').CascaderNodeValue | import('element-plus').CascaderNodePathValue)[]) | (() => CascaderValue | null) | (((new (...args: any[]) => string | number | Record<string, any> | import('element-plus').CascaderNodePathValue | (import('element-plus').CascaderNodeValue | import('element-plus').CascaderNodePathValue)[]) | (() => CascaderValue | null)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    options: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => import('element-plus').CascaderOption[]) | (() => import('element-plus').CascaderOption[]) | (((new (...args: any[]) => import('element-plus').CascaderOption[]) | (() => import('element-plus').CascaderOption[])) | null)[], unknown, unknown, () => import('element-plus').CascaderOption[], boolean>;
+    props: import('element-plus/es/utils/index.mjs').EpPropFinalized<(new (...args: any[]) => import('element-plus').CascaderProps) | (() => import('element-plus').CascaderProps) | (((new (...args: any[]) => import('element-plus').CascaderProps) | (() => import('element-plus').CascaderProps)) | null)[], unknown, unknown, () => import('element-plus').CascaderProps, boolean>;
+}>> & Readonly<{
+    onChange?: (val: CascaderValue) => any;
+    "onUpdate:modelValue"?: (val: CascaderValue) => any;
+    onFocus?: (evt: FocusEvent) => any;
+    onBlur?: (evt: FocusEvent) => any;
+    onVisibleChange?: (val: boolean) => any;
+    onExpandChange?: (val: CascaderValue) => any;
+    onRemoveTag?: (val: import('element-plus').CascaderNodeValue | import('element-plus').CascaderNodePathValue) => any;
+}>, {
+    separator: string;
+    disabled: boolean;
+    props: import('element-plus').CascaderProps;
+    validateEvent: import('../utils/vue').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    options: import('element-plus').CascaderOption[];
+    clearable: boolean;
+    filterable: boolean;
+    filterMethod: (node: CascaderNode, keyword: string) => boolean;
+    showAllLevels: import('../utils/vue').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    collapseTags: boolean;
+    maxCollapseTags: number;
+    collapseTagsTooltip: import('../utils/vue').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    debounce: number;
+    beforeFilter: (value: string) => boolean | Promise<any>;
+    popperClass: string;
+    teleported: import('element-plus/es/utils/index.mjs').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    tagType: import('element-plus/es/utils/index.mjs').EpPropMergeType<StringConstructor, "info" | "primary" | "success" | "warning" | "danger", unknown>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    tooltipRef: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly showArrow?: boolean;
+            readonly "onUpdate:visible"?: ((value: boolean) => void) & ((...args: any[]) => any);
+            readonly role?: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+            readonly appendTo?: string | HTMLElement;
+            readonly content?: string;
+            readonly rawContent?: boolean;
+            readonly persistent?: boolean;
+            readonly visible?: boolean | null;
+            readonly transition?: string;
+            readonly teleported?: boolean;
+            readonly disabled?: boolean;
+            readonly ariaLabel?: import('element-plus').AriaProps["ariaLabel"];
+            readonly showAfter?: number;
+            readonly hideAfter?: number;
+            readonly autoClose?: number;
+            readonly style?: StyleValue;
+            readonly zIndex?: number;
+            readonly offset?: number;
+            readonly id?: string;
+            readonly popperClass?: string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[];
+            readonly placement?: import('element-plus').Placement;
+            readonly strategy?: "fixed" | "absolute";
+            readonly effect?: import('element-plus').PopperEffect;
+            readonly className?: string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[];
+            readonly enterable?: boolean;
+            readonly pure?: boolean;
+            readonly focusOnShow?: boolean;
+            readonly trapping?: boolean;
+            readonly popperStyle?: StyleValue;
+            readonly referenceEl?: HTMLElement;
+            readonly triggerTargetEl?: HTMLElement;
+            readonly stopPopperMouseEvent?: boolean;
+            readonly virtualTriggering?: boolean;
+            readonly loop?: boolean;
+            readonly boundariesPadding?: number;
+            readonly fallbackPlacements?: import('element-plus').Placement[];
+            readonly gpuAcceleration?: boolean;
+            readonly popperOptions?: Partial<Options>;
+            readonly arrowOffset?: number;
+            readonly trigger?: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+            readonly triggerKeys?: string[];
+            readonly focusOnTarget?: boolean;
+            readonly virtualRef?: import('element-plus').Measurable;
+            readonly onMouseenter?: (e: MouseEvent) => void;
+            readonly onMouseleave?: (e: MouseEvent) => void;
+            readonly onClick?: (e: PointerEvent) => void;
+            readonly onKeydown?: (e: KeyboardEvent) => void;
+            readonly onFocus?: (e: FocusEvent) => void;
+            readonly onBlur?: (e: FocusEvent) => void;
+            readonly onContextmenu?: (e: PointerEvent) => void;
+            readonly open?: boolean;
+            readonly onClose?: ((...args: any[]) => any) | undefined;
+            readonly onHide?: ((...args: any[]) => any) | undefined;
+            readonly onShow?: ((...args: any[]) => any) | undefined;
+            readonly onOpen?: ((...args: any[]) => any) | undefined;
+            readonly "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            readonly "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "hide", ...args: any[]) => void) & ((event: "show", ...args: any[]) => void) & ((event: "open", ...args: any[]) => void) & ((event: "close", ...args: any[]) => void) & ((event: "update:visible", ...args: any[]) => void) & ((event: "before-show", ...args: any[]) => void) & ((event: "before-hide", ...args: any[]) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').UseTooltipProps> & Readonly<{
+            onClose?: ((...args: any[]) => any) | undefined;
+            onHide?: ((...args: any[]) => any) | undefined;
+            onShow?: ((...args: any[]) => any) | undefined;
+            onOpen?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+            "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            popperRef: Ref<import('element-plus').PopperInstance | undefined, import('element-plus').PopperInstance | undefined>;
+            contentRef: Ref<import('element-plus').TooltipContentInstance | undefined, import('element-plus').TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event, delay?: number) => void;
+            onClose: (event?: Event, delay?: number) => void;
+            hide: (event?: Event) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            close: (...args: any[]) => void;
+            hide: (...args: any[]) => void;
+            show: (...args: any[]) => void;
+            open: (...args: any[]) => void;
+            "update:visible": (...args: any[]) => void;
+            "before-show": (...args: any[]) => void;
+            "before-hide": (...args: any[]) => void;
+        }, string, {
+            offset: number;
+            teleported: boolean;
+            effect: import('element-plus').PopperEffect;
+            visible: boolean | null;
+            content: string;
+            style: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            enterable: boolean;
+            pure: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            popperStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            stopPopperMouseEvent: boolean;
+            virtualTriggering: boolean;
+            loop: boolean;
+            boundariesPadding: number;
+            gpuAcceleration: boolean;
+            placement: import('element-plus').Placement;
+            popperOptions: Partial<Options>;
+            strategy: "fixed" | "absolute";
+            arrowOffset: number;
+            showArrow: boolean;
+            role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+            triggerKeys: string[];
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        offset: number;
+        teleported: boolean;
+        effect: import('element-plus').PopperEffect;
+        visible: boolean | null;
+        content: string;
+        style: string | false | import('vue').CSSProperties | StyleValue[] | null;
+        enterable: boolean;
+        pure: boolean;
+        focusOnShow: boolean;
+        trapping: boolean;
+        popperStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+        stopPopperMouseEvent: boolean;
+        virtualTriggering: boolean;
+        loop: boolean;
+        boundariesPadding: number;
+        gpuAcceleration: boolean;
+        placement: import('element-plus').Placement;
+        popperOptions: Partial<Options>;
+        strategy: "fixed" | "absolute";
+        arrowOffset: number;
+        showArrow: boolean;
+        role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        trigger: import('element-plus/es/utils/typescript.mjs').Arrayable<import('element-plus').TooltipTriggerType>;
+        triggerKeys: string[];
+    }> & Omit<Readonly<import('element-plus').UseTooltipProps> & Readonly<{
+        onClose?: ((...args: any[]) => any) | undefined;
+        onHide?: ((...args: any[]) => any) | undefined;
+        onShow?: ((...args: any[]) => any) | undefined;
+        onOpen?: ((...args: any[]) => any) | undefined;
+        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+        "onBefore-show"?: ((...args: any[]) => any) | undefined;
+        "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+    }>, "style" | "content" | "offset" | "visible" | "hide" | "role" | "onClose" | "teleported" | "placement" | "strategy" | "effect" | "enterable" | "pure" | "focusOnShow" | "trapping" | "popperStyle" | "stopPopperMouseEvent" | "virtualTriggering" | "loop" | "boundariesPadding" | "gpuAcceleration" | "popperOptions" | "arrowOffset" | "showArrow" | "showAfter" | "hideAfter" | "autoClose" | "trigger" | "triggerKeys" | "onOpen" | "popperRef" | "contentRef" | "isFocusInsideContent" | "updatePopper"> & {
+        popperRef: import('element-plus').PopperInstance;
+        contentRef: import('element-plus').TooltipContentInstance;
+        isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+        updatePopper: () => void;
+        onOpen: (event?: Event, delay?: number) => void;
+        onClose: (event?: Event, delay?: number) => void;
+        hide: (event?: Event) => void;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?: (props: {}) => any;
+        } & {
+            content?: (props: {}) => any;
+        };
+    };
+    input: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly id?: string;
+            readonly size?: import('element-plus').ComponentSize;
+            readonly disabled?: boolean;
+            readonly modelValue?: string | number | null | undefined;
+            readonly modelModifiers?: import('element-plus').InputModelModifiers;
+            readonly maxlength?: string | number;
+            readonly minlength?: string | number;
+            readonly type?: import('element-plus').InputType;
+            readonly resize?: "none" | "both" | "horizontal" | "vertical";
+            readonly autosize?: import('element-plus').InputAutoSize;
+            readonly autocomplete?: string;
+            readonly formatter?: (value: string) => string;
+            readonly parser?: (value: string) => string;
+            readonly placeholder?: string;
+            readonly form?: string;
+            readonly readonly?: boolean;
+            readonly clearable?: boolean;
+            readonly clearIcon?: import('element-plus/es/utils/index.mjs').IconPropType;
+            readonly showPassword?: boolean;
+            readonly showWordLimit?: boolean;
+            readonly wordLimitPosition?: "inside" | "outside";
+            readonly suffixIcon?: import('element-plus/es/utils/index.mjs').IconPropType;
+            readonly prefixIcon?: import('element-plus/es/utils/index.mjs').IconPropType;
+            readonly containerRole?: string;
+            readonly tabindex?: string | number;
+            readonly validateEvent?: boolean;
+            readonly inputStyle?: StyleValue;
+            readonly autofocus?: boolean;
+            readonly rows?: number;
+            readonly ariaLabel?: string;
+            readonly inputmode?: import('vue').HTMLAttributes["inputmode"];
+            readonly name?: string;
+            readonly countGraphemes?: (value: string) => number;
+            readonly onBlur?: ((evt: FocusEvent) => any) | undefined;
+            readonly onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+            readonly onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+            readonly onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+            readonly onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+            readonly onFocus?: ((evt: FocusEvent) => any) | undefined;
+            readonly onInput?: ((value: string) => any) | undefined;
+            readonly onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+            readonly onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+            readonly onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            readonly onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "input", value: string) => void) & ((event: "clear", evt: MouseEvent) => void) & ((event: "change", value: string, evt?: Event) => void) & ((event: "update:modelValue", value: string) => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').InputProps> & Readonly<{
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+            onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+            onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+            onFocus?: ((evt: FocusEvent) => any) | undefined;
+            onInput?: ((value: string) => any) | undefined;
+            onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+            onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+            onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+        }>, {
+            input: import('vue').ShallowRef<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+            textarea: import('vue').ShallowRef<HTMLTextAreaElement | undefined, HTMLTextAreaElement | undefined>;
+            ref: ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;
+            textareaStyle: ComputedRef<StyleValue>;
+            autosize: Ref<import('element-plus').InputAutoSize | undefined, import('element-plus').InputAutoSize | undefined>;
+            isComposing: Ref<boolean, boolean>;
+            passwordVisible: Ref<boolean, boolean>;
+            focus: () => void | undefined;
+            blur: () => void | undefined;
+            select: () => void;
+            clear: (evt?: MouseEvent) => void;
+            resizeTextarea: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (evt: FocusEvent) => void;
+            change: (value: string, evt?: Event | undefined) => void;
+            compositionend: (evt: CompositionEvent) => void;
+            compositionstart: (evt: CompositionEvent) => void;
+            compositionupdate: (evt: CompositionEvent) => void;
+            focus: (evt: FocusEvent) => void;
+            input: (value: string) => void;
+            keydown: (evt: Event | KeyboardEvent) => void;
+            mouseenter: (evt: MouseEvent) => void;
+            mouseleave: (evt: MouseEvent) => void;
+            "update:modelValue": (value: string) => void;
+            clear: (evt: MouseEvent | undefined) => void;
+        }, string, {
+            type: import('element-plus').InputType;
+            disabled: boolean;
+            modelValue: string | number | null;
+            modelModifiers: import('element-plus').InputModelModifiers;
+            autocomplete: string;
+            clearIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+            wordLimitPosition: "inside" | "outside";
+            tabindex: string | number;
+            validateEvent: boolean;
+            inputStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            rows: number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        type: import('element-plus').InputType;
+        disabled: boolean;
+        modelValue: string | number | null;
+        modelModifiers: import('element-plus').InputModelModifiers;
+        autocomplete: string;
+        clearIcon: import('element-plus/es/utils/index.mjs').IconPropType;
+        wordLimitPosition: "inside" | "outside";
+        tabindex: string | number;
+        validateEvent: boolean;
+        inputStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+        rows: number;
+    }> & Omit<Readonly<import('element-plus').InputProps> & Readonly<{
+        onBlur?: ((evt: FocusEvent) => any) | undefined;
+        onChange?: ((value: string, evt?: Event | undefined) => any) | undefined;
+        onCompositionend?: ((evt: CompositionEvent) => any) | undefined;
+        onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;
+        onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;
+        onFocus?: ((evt: FocusEvent) => any) | undefined;
+        onInput?: ((value: string) => any) | undefined;
+        onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;
+        onMouseenter?: ((evt: MouseEvent) => any) | undefined;
+        onMouseleave?: ((evt: MouseEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onClear?: ((evt: MouseEvent | undefined) => any) | undefined;
+    }>, "input" | "select" | "textarea" | "clear" | "disabled" | "type" | "ref" | "modelValue" | "tabindex" | "validateEvent" | "focus" | "blur" | "modelModifiers" | "autosize" | "autocomplete" | "clearIcon" | "wordLimitPosition" | "inputStyle" | "rows" | "textareaStyle" | "isComposing" | "passwordVisible" | "resizeTextarea"> & {
+        input: HTMLInputElement;
+        textarea: HTMLTextAreaElement;
+        ref: HTMLInputElement | HTMLTextAreaElement;
+        textareaStyle: StyleValue;
+        autosize: import('element-plus').InputAutoSize;
+        isComposing: boolean;
+        passwordVisible: boolean;
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+        select: () => void;
+        clear: (evt?: MouseEvent) => void;
+        resizeTextarea: () => void;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            prepend?: (props: {}) => any;
+        } & {
+            prefix?: (props: {}) => any;
+        } & {
+            suffix?: (props: {}) => any;
+        } & {
+            'password-icon'?: (props: {
+                visible: boolean;
+            }) => any;
+        } & {
+            append?: (props: {}) => any;
+        };
+    };
+    tagWrapper: HTMLDivElement;
+    cascaderPanelRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        border: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        inputWidth: {
+            type: NumberConstructor;
+            default: number;
+        };
+        renderLabel: import('vue').PropType<import('../cascader-panel/node').RenderLabel>;
+        modelValue: {
+            readonly type: import('vue').PropType<import('../utils/vue').EpPropMergeType<import('vue').PropType<import('../cascader-panel/node').CascaderValue>, unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        options: import('../utils/vue').EpPropFinalized<import('vue').PropType<import('.').CascaderOption[]>, unknown, unknown, () => import('.').CascaderOption[], boolean>;
+        props: import('../utils/vue').EpPropFinalized<import('vue').PropType<import('.').CascaderProps>, unknown, unknown, () => import('.').CascaderProps, boolean>;
+    }>> & Readonly<{
+        onChange?: (...args: any[]) => any;
+        "onUpdate:modelValue"?: (...args: any[]) => any;
+        onClose?: (...args: any[]) => any;
+        "onExpand-change"?: (...args: any[]) => any;
+    }>, {
+        ns: {
+            namespace: ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => 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: Ref<any[], any[]>;
+        menuRenderKey: Ref<number, number>;
+        menus: Ref<{
+            readonly uid: number;
+            readonly level: number;
+            readonly value: import('../cascader-panel/node').CascaderNodeValue;
+            readonly label: string;
+            readonly pathNodes: /*elided*/ any[];
+            readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+            readonly pathLabels: string[];
+            childrenData: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            }[];
+            children: /*elided*/ any[];
+            text: string;
+            loaded: boolean;
+            checked: boolean;
+            indeterminate: boolean;
+            loading: boolean;
+            readonly data: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            };
+            readonly config: {
+                expandTrigger: import('.').ExpandTrigger;
+                multiple: boolean;
+                checkStrictly: boolean;
+                emitPath: boolean;
+                lazy: boolean;
+                lazyLoad: import('../cascader-panel/node').LazyLoad;
+                value: string;
+                label: string;
+                children: string;
+                disabled: string | import('../cascader-panel/node').isDisabled;
+                leaf: string | import('../cascader-panel/node').isLeaf;
+                hoverThreshold: number;
+            };
+            readonly parent?: /*elided*/ any;
+            readonly root: boolean;
+            readonly isDisabled: boolean;
+            readonly isLeaf: boolean;
+            readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+            appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+            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;
+        }[][], import('.').CascaderNode[][] | {
+            readonly uid: number;
+            readonly level: number;
+            readonly value: import('../cascader-panel/node').CascaderNodeValue;
+            readonly label: string;
+            readonly pathNodes: /*elided*/ any[];
+            readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+            readonly pathLabels: string[];
+            childrenData: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            }[];
+            children: /*elided*/ any[];
+            text: string;
+            loaded: boolean;
+            checked: boolean;
+            indeterminate: boolean;
+            loading: boolean;
+            readonly data: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            };
+            readonly config: {
+                expandTrigger: import('.').ExpandTrigger;
+                multiple: boolean;
+                checkStrictly: boolean;
+                emitPath: boolean;
+                lazy: boolean;
+                lazyLoad: import('../cascader-panel/node').LazyLoad;
+                value: string;
+                label: string;
+                children: string;
+                disabled: string | import('../cascader-panel/node').isDisabled;
+                leaf: string | import('../cascader-panel/node').isLeaf;
+                hoverThreshold: number;
+            };
+            readonly parent?: /*elided*/ any;
+            readonly root: boolean;
+            readonly isDisabled: boolean;
+            readonly isLeaf: boolean;
+            readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+            appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+            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: Ref<{
+            readonly uid: number;
+            readonly level: number;
+            readonly value: import('../cascader-panel/node').CascaderNodeValue;
+            readonly label: string;
+            readonly pathNodes: /*elided*/ any[];
+            readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+            readonly pathLabels: string[];
+            childrenData: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            }[];
+            children: /*elided*/ any[];
+            text: string;
+            loaded: boolean;
+            checked: boolean;
+            indeterminate: boolean;
+            loading: boolean;
+            readonly data: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            };
+            readonly config: {
+                expandTrigger: import('.').ExpandTrigger;
+                multiple: boolean;
+                checkStrictly: boolean;
+                emitPath: boolean;
+                lazy: boolean;
+                lazyLoad: import('../cascader-panel/node').LazyLoad;
+                value: string;
+                label: string;
+                children: string;
+                disabled: string | import('../cascader-panel/node').isDisabled;
+                leaf: string | import('../cascader-panel/node').isLeaf;
+                hoverThreshold: number;
+            };
+            readonly parent?: /*elided*/ any;
+            readonly root: boolean;
+            readonly isDisabled: boolean;
+            readonly isLeaf: boolean;
+            readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+            appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+            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;
+        }[], import('.').CascaderNode[] | {
+            readonly uid: number;
+            readonly level: number;
+            readonly value: import('../cascader-panel/node').CascaderNodeValue;
+            readonly label: string;
+            readonly pathNodes: /*elided*/ any[];
+            readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+            readonly pathLabels: string[];
+            childrenData: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            }[];
+            children: /*elided*/ any[];
+            text: string;
+            loaded: boolean;
+            checked: boolean;
+            indeterminate: boolean;
+            loading: boolean;
+            readonly data: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            };
+            readonly config: {
+                expandTrigger: import('.').ExpandTrigger;
+                multiple: boolean;
+                checkStrictly: boolean;
+                emitPath: boolean;
+                lazy: boolean;
+                lazyLoad: import('../cascader-panel/node').LazyLoad;
+                value: string;
+                label: string;
+                children: string;
+                disabled: string | import('../cascader-panel/node').isDisabled;
+                leaf: string | import('../cascader-panel/node').isLeaf;
+                hoverThreshold: number;
+            };
+            readonly parent?: /*elided*/ any;
+            readonly root: boolean;
+            readonly isDisabled: boolean;
+            readonly isLeaf: boolean;
+            readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+            appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+            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: import('.').CascaderNode, checked: boolean, emitClose?: boolean) => void;
+        getFlattedNodes: (leafOnly: boolean) => import('.').CascaderNode[];
+        getCheckedNodes: (leafOnly: boolean) => import('.').CascaderNode[];
+        clearCheckedNodes: () => void;
+        calculateCheckedValue: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("change" | "update:modelValue" | "close" | "expand-change")[], import('vue').PublicProps, {
+        border: boolean;
+        props: import('.').CascaderProps;
+        options: import('.').CascaderOption[];
+        inputWidth: number;
+    }, true, {}, {}, {
+        CustomCascaderMenu: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+            nodes: {
+                type: import('vue').PropType<import('.').CascaderNode[]>;
+                required: true;
+            };
+            index: {
+                type: NumberConstructor;
+                required: true;
+            };
+        }>, {
+            ns: {
+                namespace: ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => 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: import('.').ElCascaderPanelContext;
+            hoverZone: Ref<SVGSVGElement, SVGSVGElement>;
+            isEmpty: ComputedRef<boolean>;
+            isLoading: ComputedRef<boolean>;
+            menuId: ComputedRef<string>;
+            menuWidth: ComputedRef<number>;
+            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: import('vue').PropType<import('.').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<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            })>;
+            ElScrollbar: import('element-plus/es/utils/index.mjs').SFCWithInstall<{
+                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').ScrollbarProps> & Readonly<{
+                    onScroll?: ((args_0: {
+                        scrollTop: number;
+                        scrollLeft: number;
+                    }) => any) | undefined;
+                    "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+                }>, {
+                    wrapRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                    update: () => void;
+                    scrollTo: {
+                        (xCord: number, yCord?: number): void;
+                        (options: ScrollToOptions): void;
+                    };
+                    setScrollTop: (value: number) => void;
+                    setScrollLeft: (value: number) => void;
+                    handleScroll: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    scroll: (args_0: {
+                        scrollTop: number;
+                        scrollLeft: number;
+                    }) => void;
+                    "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
+                }, import('vue').PublicProps, {
+                    tabindex: number | string;
+                    height: number | string;
+                    maxHeight: number | string;
+                    tag: keyof HTMLElementTagNameMap | (string & {});
+                    distance: number;
+                    wrapStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                    wrapClass: string | string[];
+                    viewClass: string | string[];
+                    viewStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                    minSize: number;
+                }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import('element-plus').ScrollbarProps> & Readonly<{
+                    onScroll?: ((args_0: {
+                        scrollTop: number;
+                        scrollLeft: number;
+                    }) => any) | undefined;
+                    "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+                }>, {
+                    wrapRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                    update: () => void;
+                    scrollTo: {
+                        (xCord: number, yCord?: number): void;
+                        (options: ScrollToOptions): void;
+                    };
+                    setScrollTop: (value: number) => void;
+                    setScrollLeft: (value: number) => void;
+                    handleScroll: () => void;
+                }, {}, {}, {}, {
+                    tabindex: number | string;
+                    height: number | string;
+                    maxHeight: number | string;
+                    tag: keyof HTMLElementTagNameMap | (string & {});
+                    distance: number;
+                    wrapStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                    wrapClass: string | string[];
+                    viewClass: string | string[];
+                    viewStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                    minSize: number;
+                }>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').ScrollbarProps> & Readonly<{
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+            }>, {
+                wrapRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                update: () => void;
+                scrollTo: {
+                    (xCord: number, yCord?: number): void;
+                    (options: ScrollToOptions): void;
+                };
+                setScrollTop: (value: number) => void;
+                setScrollLeft: (value: number) => void;
+                handleScroll: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                scroll: (args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => void;
+                "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
+            }, string, {
+                tabindex: number | string;
+                height: number | string;
+                maxHeight: number | string;
+                tag: keyof HTMLElementTagNameMap | (string & {});
+                distance: number;
+                wrapStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                wrapClass: string | string[];
+                viewClass: string | string[];
+                viewStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+                minSize: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            })>;
+            RecycleScroller: import('vue').DefineComponent<any, any, any>;
+            CustomCascaderNode: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+                node: {
+                    type: import('vue').PropType<import('.').CascaderNode>;
+                    required: true;
+                };
+                menuId: StringConstructor;
+            }>, {
+                panel: import('.').ElCascaderPanelContext;
+                isHoverMenu: ComputedRef<boolean>;
+                multiple: ComputedRef<boolean>;
+                checkStrictly: ComputedRef<boolean>;
+                checkedNodeId: ComputedRef<number>;
+                isDisabled: ComputedRef<boolean>;
+                isLeaf: ComputedRef<boolean>;
+                expandable: ComputedRef<boolean>;
+                inExpandingPath: ComputedRef<boolean>;
+                inCheckedPath: ComputedRef<boolean>;
+                ns: {
+                    namespace: ComputedRef<string>;
+                    b: (blockSuffix?: string) => string;
+                    e: (element?: string) => string;
+                    m: (modifier?: string) => string;
+                    be: (blockSuffix?: string, element?: string) => string;
+                    em: (element?: string, modifier?: string) => string;
+                    bm: (blockSuffix?: string, modifier?: string) => string;
+                    bem: (blockSuffix?: string, element?: string, modifier?: string) => 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: import('vue').PropType<import('.').CascaderNode>;
+                    required: true;
+                };
+                menuId: StringConstructor;
+            }>> & Readonly<{
+                onExpand?: (...args: any[]) => any;
+            }>, {}, {}, {
+                ElCheckbox: {
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                        onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        change: (val: import('element-plus').CheckboxValueType) => void;
+                        "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                    }, import('vue').PublicProps, {
+                        id: string;
+                        disabled: boolean;
+                        modelValue: number | string | boolean;
+                        validateEvent: boolean;
+                        name: string;
+                        value: string | boolean | number | object;
+                        label: string | boolean | number | object;
+                        trueValue: string | number;
+                        falseValue: string | number;
+                        trueLabel: string | number;
+                        falseLabel: string | number;
+                    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                        onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    }>, {}, {}, {}, {}, {
+                        id: string;
+                        disabled: boolean;
+                        modelValue: number | string | boolean;
+                        validateEvent: boolean;
+                        name: string;
+                        value: string | boolean | number | object;
+                        label: string | boolean | number | object;
+                        trueValue: string | number;
+                        falseValue: string | number;
+                        trueLabel: string | number;
+                        falseLabel: string | number;
+                    }>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                    onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    change: (val: import('element-plus').CheckboxValueType) => void;
+                    "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                }, string, {
+                    id: string;
+                    disabled: boolean;
+                    modelValue: number | string | boolean;
+                    validateEvent: boolean;
+                    name: string;
+                    value: string | boolean | number | object;
+                    label: string | boolean | number | object;
+                    trueValue: string | number;
+                    falseValue: string | number;
+                    trueLabel: string | number;
+                    falseLabel: string | number;
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                }) & import('vue').ObjectPlugin & {
+                    setPropsDefaults: (defaults: Partial<Omit<{
+                        readonly modelValue?: number | string | boolean;
+                        readonly label?: string | boolean | number | object;
+                        readonly value?: string | boolean | number | object;
+                        readonly indeterminate?: boolean;
+                        readonly disabled?: boolean;
+                        readonly checked?: boolean;
+                        readonly name?: string;
+                        readonly trueValue?: string | number;
+                        readonly falseValue?: string | number;
+                        readonly trueLabel?: string | number;
+                        readonly falseLabel?: string | number;
+                        readonly id?: string;
+                        readonly border?: boolean;
+                        readonly size?: import('element-plus').ComponentSize;
+                        readonly tabindex?: string | number;
+                        readonly validateEvent?: boolean;
+                        readonly ariaLabel?: string;
+                        readonly ariaControls?: string;
+                        readonly onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        readonly "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "onChange" | "onUpdate:modelValue" | keyof import('vue').VNodeProps | keyof import('vue').AllowedComponentProps>>) => void;
+                } & {
+                    CheckboxButton: {
+                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                            onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                            change: (val: import('element-plus').CheckboxValueType) => void;
+                            "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                        }, import('vue').PublicProps, {
+                            id: string;
+                            disabled: boolean;
+                            modelValue: number | string | boolean;
+                            validateEvent: boolean;
+                            name: string;
+                            value: string | boolean | number | object;
+                            label: string | boolean | number | object;
+                            trueValue: string | number;
+                            falseValue: string | number;
+                            trueLabel: string | number;
+                            falseLabel: string | number;
+                        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                            onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, {
+                            id: string;
+                            disabled: boolean;
+                            modelValue: number | string | boolean;
+                            validateEvent: boolean;
+                            name: string;
+                            value: string | boolean | number | object;
+                            label: string | boolean | number | object;
+                            trueValue: string | number;
+                            falseValue: string | number;
+                            trueLabel: string | number;
+                            falseLabel: string | number;
+                        }>;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').CheckboxProps> & Readonly<{
+                        onChange?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxValueType) => any) | undefined;
+                    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        change: (val: import('element-plus').CheckboxValueType) => void;
+                        "update:modelValue": (val: import('element-plus').CheckboxValueType) => void;
+                    }, string, {
+                        id: string;
+                        disabled: boolean;
+                        modelValue: number | string | boolean;
+                        validateEvent: boolean;
+                        name: string;
+                        value: string | boolean | number | object;
+                        label: string | boolean | number | object;
+                        trueValue: string | number;
+                        falseValue: string | number;
+                        trueLabel: string | number;
+                        falseLabel: string | number;
+                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                        $slots: {
+                            default?: (props: {}) => any;
+                        };
+                    });
+                    CheckboxGroup: {
+                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').CheckboxGroupProps> & Readonly<{
+                            onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                            change: (val: import('element-plus').CheckboxValueType[]) => void;
+                            "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
+                        }, import('vue').PublicProps, {
+                            props: {
+                                value?: string;
+                                label?: string;
+                                disabled?: string;
+                            };
+                            type: "checkbox" | "button";
+                            disabled: boolean;
+                            modelValue: import('element-plus').CheckboxGroupValueType;
+                            validateEvent: boolean;
+                            tag: string;
+                        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import('element-plus').CheckboxGroupProps> & Readonly<{
+                            onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                        }>, {}, {}, {}, {}, {
+                            props: {
+                                value?: string;
+                                label?: string;
+                                disabled?: string;
+                            };
+                            type: "checkbox" | "button";
+                            disabled: boolean;
+                            modelValue: import('element-plus').CheckboxGroupValueType;
+                            validateEvent: boolean;
+                            tag: string;
+                        }>;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').CheckboxGroupProps> & Readonly<{
+                        onChange?: ((val: import('element-plus').CheckboxValueType[]) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: import('element-plus').CheckboxGroupValueType) => any) | undefined;
+                    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        change: (val: import('element-plus').CheckboxValueType[]) => void;
+                        "update:modelValue": (val: import('element-plus').CheckboxGroupValueType) => void;
+                    }, string, {
+                        props: {
+                            value?: string;
+                            label?: string;
+                            disabled?: string;
+                        };
+                        type: "checkbox" | "button";
+                        disabled: boolean;
+                        modelValue: import('element-plus').CheckboxGroupValueType;
+                        validateEvent: boolean;
+                        tag: string;
+                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                        $slots: {
+                            default?: (props: {}) => any;
+                        };
+                    });
+                };
+                ElRadio: {
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').RadioProps> & Readonly<{
+                        onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        change: (val: string | number | boolean | undefined) => void;
+                        "update:modelValue": (val: string | number | boolean | undefined) => void;
+                    }, import('vue').PublicProps, {
+                        disabled: boolean;
+                        modelValue: string | number | boolean;
+                        name: string;
+                        value: string | number | boolean;
+                        border: boolean;
+                        label: string | number | boolean;
+                    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus').RadioProps> & Readonly<{
+                        onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                    }>, {}, {}, {}, {}, {
+                        disabled: boolean;
+                        modelValue: string | number | boolean;
+                        name: string;
+                        value: string | number | boolean;
+                        border: boolean;
+                        label: string | number | boolean;
+                    }>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').RadioProps> & Readonly<{
+                    onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                    "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    change: (val: string | number | boolean | undefined) => void;
+                    "update:modelValue": (val: string | number | boolean | undefined) => void;
+                }, string, {
+                    disabled: boolean;
+                    modelValue: string | number | boolean;
+                    name: string;
+                    value: string | number | boolean;
+                    border: boolean;
+                    label: string | number | boolean;
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                }) & import('vue').ObjectPlugin & {
+                    setPropsDefaults: (defaults: Partial<Omit<{
+                        readonly border?: boolean;
+                        readonly modelValue?: string | number | boolean;
+                        readonly size?: import('element-plus').ComponentSize;
+                        readonly disabled?: boolean;
+                        readonly label?: string | number | boolean;
+                        readonly value?: string | number | boolean;
+                        readonly name?: string;
+                        readonly onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                        readonly "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "onChange" | "onUpdate:modelValue" | keyof import('vue').VNodeProps | keyof import('vue').AllowedComponentProps>>) => void;
+                } & {
+                    RadioButton: {
+                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').RadioButtonProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                            disabled: boolean;
+                            modelValue: string | number | boolean;
+                            name: string;
+                            value: string | number | boolean;
+                            label: string | number | boolean;
+                        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import('element-plus').RadioButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
+                            disabled: boolean;
+                            modelValue: string | number | boolean;
+                            name: string;
+                            value: string | number | boolean;
+                            label: string | number | boolean;
+                        }>;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').RadioButtonProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                        disabled: boolean;
+                        modelValue: string | number | boolean;
+                        name: string;
+                        value: string | number | boolean;
+                        label: string | number | boolean;
+                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                        $slots: {
+                            default?: (props: {}) => any;
+                        };
+                    });
+                    RadioGroup: {
+                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').RadioGroupProps> & Readonly<{
+                            onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                            change: (val: string | number | boolean | undefined) => void;
+                            "update:modelValue": (val: string | number | boolean | undefined) => void;
+                        }, import('vue').PublicProps, {
+                            fill: string;
+                            props: import('element-plus').radioOptionProp;
+                            type: "radio" | "button";
+                            id: string;
+                            disabled: boolean;
+                            modelValue: string | number | boolean;
+                            validateEvent: boolean;
+                            name: string;
+                            textColor: string;
+                        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                            P: {};
+                            B: {};
+                            D: {};
+                            C: {};
+                            M: {};
+                            Defaults: {};
+                        }, Readonly<import('element-plus').RadioGroupProps> & Readonly<{
+                            onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                            "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                        }>, {}, {}, {}, {}, {
+                            fill: string;
+                            props: import('element-plus').radioOptionProp;
+                            type: "radio" | "button";
+                            id: string;
+                            disabled: boolean;
+                            modelValue: string | number | boolean;
+                            validateEvent: boolean;
+                            name: string;
+                            textColor: string;
+                        }>;
+                        __isFragment?: never;
+                        __isTeleport?: never;
+                        __isSuspense?: never;
+                    } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').RadioGroupProps> & Readonly<{
+                        onChange?: ((val: string | number | boolean | undefined) => any) | undefined;
+                        "onUpdate:modelValue"?: ((val: string | number | boolean | undefined) => any) | undefined;
+                    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        change: (val: string | number | boolean | undefined) => void;
+                        "update:modelValue": (val: string | number | boolean | undefined) => void;
+                    }, string, {
+                        fill: string;
+                        props: import('element-plus').radioOptionProp;
+                        type: "radio" | "button";
+                        id: string;
+                        disabled: boolean;
+                        modelValue: string | number | boolean;
+                        validateEvent: boolean;
+                        name: string;
+                        textColor: string;
+                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                        $slots: {
+                            default?: (props: {}) => any;
+                        };
+                    });
+                };
+                NodeContent: import('vue').DefineComponent<{}, {
+                    ns: {
+                        namespace: ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string) => string;
+                        m: (modifier?: string) => string;
+                        be: (blockSuffix?: string, element?: string) => string;
+                        em: (element?: string, modifier?: string) => string;
+                        bm: (blockSuffix?: string, modifier?: string) => string;
+                        bem: (blockSuffix?: string, element?: string, modifier?: string) => 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<{
+                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import('vue').ComponentOptionsBase<Readonly<import('element-plus').IconProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => 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>;
+    } & import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        border: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        inputWidth: {
+            type: NumberConstructor;
+            default: number;
+        };
+        renderLabel: import('vue').PropType<import('../cascader-panel/node').RenderLabel>;
+        modelValue: {
+            readonly type: import('vue').PropType<import('../utils/vue').EpPropMergeType<import('vue').PropType<import('../cascader-panel/node').CascaderValue>, unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        options: import('../utils/vue').EpPropFinalized<import('vue').PropType<import('.').CascaderOption[]>, unknown, unknown, () => import('.').CascaderOption[], boolean>;
+        props: import('../utils/vue').EpPropFinalized<import('vue').PropType<import('.').CascaderProps>, unknown, unknown, () => import('.').CascaderProps, boolean>;
+    }>> & Readonly<{
+        onChange?: (...args: any[]) => any;
+        "onUpdate:modelValue"?: (...args: any[]) => any;
+        onClose?: (...args: any[]) => any;
+        "onExpand-change"?: (...args: any[]) => any;
+    }>, {
+        ns: {
+            namespace: ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => 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: Ref<any[], any[]>;
+        menuRenderKey: Ref<number, number>;
+        menus: Ref<{
+            readonly uid: number;
+            readonly level: number;
+            readonly value: import('../cascader-panel/node').CascaderNodeValue;
+            readonly label: string;
+            readonly pathNodes: /*elided*/ any[];
+            readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+            readonly pathLabels: string[];
+            childrenData: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            }[];
+            children: /*elided*/ any[];
+            text: string;
+            loaded: boolean;
+            checked: boolean;
+            indeterminate: boolean;
+            loading: boolean;
+            readonly data: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            };
+            readonly config: {
+                expandTrigger: import('.').ExpandTrigger;
+                multiple: boolean;
+                checkStrictly: boolean;
+                emitPath: boolean;
+                lazy: boolean;
+                lazyLoad: import('../cascader-panel/node').LazyLoad;
+                value: string;
+                label: string;
+                children: string;
+                disabled: string | import('../cascader-panel/node').isDisabled;
+                leaf: string | import('../cascader-panel/node').isLeaf;
+                hoverThreshold: number;
+            };
+            readonly parent?: /*elided*/ any;
+            readonly root: boolean;
+            readonly isDisabled: boolean;
+            readonly isLeaf: boolean;
+            readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+            appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+            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;
+        }[][], import('.').CascaderNode[][] | {
+            readonly uid: number;
+            readonly level: number;
+            readonly value: import('../cascader-panel/node').CascaderNodeValue;
+            readonly label: string;
+            readonly pathNodes: /*elided*/ any[];
+            readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+            readonly pathLabels: string[];
+            childrenData: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            }[];
+            children: /*elided*/ any[];
+            text: string;
+            loaded: boolean;
+            checked: boolean;
+            indeterminate: boolean;
+            loading: boolean;
+            readonly data: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            };
+            readonly config: {
+                expandTrigger: import('.').ExpandTrigger;
+                multiple: boolean;
+                checkStrictly: boolean;
+                emitPath: boolean;
+                lazy: boolean;
+                lazyLoad: import('../cascader-panel/node').LazyLoad;
+                value: string;
+                label: string;
+                children: string;
+                disabled: string | import('../cascader-panel/node').isDisabled;
+                leaf: string | import('../cascader-panel/node').isLeaf;
+                hoverThreshold: number;
+            };
+            readonly parent?: /*elided*/ any;
+            readonly root: boolean;
+            readonly isDisabled: boolean;
+            readonly isLeaf: boolean;
+            readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+            appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+            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: Ref<{
+            readonly uid: number;
+            readonly level: number;
+            readonly value: import('../cascader-panel/node').CascaderNodeValue;
+            readonly label: string;
+            readonly pathNodes: /*elided*/ any[];
+            readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+            readonly pathLabels: string[];
+            childrenData: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            }[];
+            children: /*elided*/ any[];
+            text: string;
+            loaded: boolean;
+            checked: boolean;
+            indeterminate: boolean;
+            loading: boolean;
+            readonly data: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            };
+            readonly config: {
+                expandTrigger: import('.').ExpandTrigger;
+                multiple: boolean;
+                checkStrictly: boolean;
+                emitPath: boolean;
+                lazy: boolean;
+                lazyLoad: import('../cascader-panel/node').LazyLoad;
+                value: string;
+                label: string;
+                children: string;
+                disabled: string | import('../cascader-panel/node').isDisabled;
+                leaf: string | import('../cascader-panel/node').isLeaf;
+                hoverThreshold: number;
+            };
+            readonly parent?: /*elided*/ any;
+            readonly root: boolean;
+            readonly isDisabled: boolean;
+            readonly isLeaf: boolean;
+            readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+            appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+            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;
+        }[], import('.').CascaderNode[] | {
+            readonly uid: number;
+            readonly level: number;
+            readonly value: import('../cascader-panel/node').CascaderNodeValue;
+            readonly label: string;
+            readonly pathNodes: /*elided*/ any[];
+            readonly pathValues: import('../cascader-panel/node').CascaderNodeValue[];
+            readonly pathLabels: string[];
+            childrenData: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            }[];
+            children: /*elided*/ any[];
+            text: string;
+            loaded: boolean;
+            checked: boolean;
+            indeterminate: boolean;
+            loading: boolean;
+            readonly data: {
+                [x: string]: unknown;
+                label?: string;
+                value?: import('../cascader-panel/node').CascaderNodeValue;
+                children?: /*elided*/ any[];
+                disabled?: boolean;
+                leaf?: boolean;
+            };
+            readonly config: {
+                expandTrigger: import('.').ExpandTrigger;
+                multiple: boolean;
+                checkStrictly: boolean;
+                emitPath: boolean;
+                lazy: boolean;
+                lazyLoad: import('../cascader-panel/node').LazyLoad;
+                value: string;
+                label: string;
+                children: string;
+                disabled: string | import('../cascader-panel/node').isDisabled;
+                leaf: string | import('../cascader-panel/node').isLeaf;
+                hoverThreshold: number;
+            };
+            readonly parent?: /*elided*/ any;
+            readonly root: boolean;
+            readonly isDisabled: boolean;
+            readonly isLeaf: boolean;
+            readonly valueByOption: import('../cascader-panel/node').CascaderNodeValue | import('../cascader-panel/node').CascaderNodeValue[];
+            appendChild: (childData: import('.').CascaderOption) => import('.').CascaderNode;
+            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: import('.').CascaderNode, checked: boolean, emitClose?: boolean) => void;
+        getFlattedNodes: (leafOnly: boolean) => import('.').CascaderNode[];
+        getCheckedNodes: (leafOnly: boolean) => import('.').CascaderNode[];
+        clearCheckedNodes: () => void;
+        calculateCheckedValue: () => void;
+    }, {}, {}, {}, {
+        border: boolean;
+        props: import('.').CascaderProps;
+        options: import('.').CascaderOption[];
+        inputWidth: number;
+    }>;
+    suggestionPanel: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly distance?: number;
+            readonly height?: number | string;
+            readonly maxHeight?: number | string;
+            readonly native?: boolean;
+            readonly wrapStyle?: StyleValue;
+            readonly wrapClass?: string | string[];
+            readonly viewClass?: string | string[];
+            readonly viewStyle?: StyleValue;
+            readonly noresize?: boolean;
+            readonly tag?: keyof HTMLElementTagNameMap | (string & {});
+            readonly always?: boolean;
+            readonly minSize?: number;
+            readonly tabindex?: number | string;
+            readonly id?: string;
+            readonly role?: string;
+            readonly ariaLabel?: string;
+            readonly ariaOrientation?: "horizontal" | "vertical" | "undefined";
+            readonly onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            readonly "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "scroll", args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => void) & ((event: "end-reached", direction: import('element-plus').ScrollbarDirection) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('element-plus').ScrollbarProps> & Readonly<{
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+        }>, {
+            wrapRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            scroll: (args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void;
+            "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
+        }, string, {
+            tabindex: number | string;
+            height: number | string;
+            maxHeight: number | string;
+            tag: keyof HTMLElementTagNameMap | (string & {});
+            distance: number;
+            wrapStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            wrapClass: string | string[];
+            viewClass: string | string[];
+            viewStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+            minSize: number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        tabindex: number | string;
+        height: number | string;
+        maxHeight: number | string;
+        tag: keyof HTMLElementTagNameMap | (string & {});
+        distance: number;
+        wrapStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+        wrapClass: string | string[];
+        viewClass: string | string[];
+        viewStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+        minSize: number;
+    }> & Omit<Readonly<import('element-plus').ScrollbarProps> & Readonly<{
+        onScroll?: ((args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => any) | undefined;
+        "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+    }>, "height" | "maxHeight" | "tabindex" | "tag" | "distance" | "wrapStyle" | "wrapClass" | "viewClass" | "viewStyle" | "minSize" | "wrapRef" | "update" | "scrollTo" | "setScrollTop" | "setScrollLeft" | "handleScroll"> & {
+        wrapRef: HTMLDivElement;
+        update: () => void;
+        scrollTo: {
+            (xCord: number, yCord?: number): void;
+            (options: ScrollToOptions): void;
+        };
+        setScrollTop: (value: number) => void;
+        setScrollLeft: (value: number) => void;
+        handleScroll: () => void;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    };
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};