@fangzhongya/fang-ui 0.0.12 → 0.0.13

package/dist/components/cascader/src/index.d.ts

@@ -0,0 +1,1053 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: {}) => any>>;
+    refs: {
+        refEl: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                disabled: boolean;
+                separator: string;
+                props: import('element-plus/es/index').CascaderProps;
+                placement: any;
+                options: import('element-plus/es/index').CascaderOption[];
+                valueOnClear: string | number | boolean | Function;
+                validateEvent: boolean;
+                clearable: boolean;
+                fallbackPlacements: Placement[];
+                popperClass: string;
+                teleported: boolean;
+                persistent: boolean;
+                debounce: number;
+                filterable: boolean;
+                filterMethod: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+                showAllLevels: boolean;
+                collapseTags: boolean;
+                maxCollapseTags: number;
+                collapseTagsTooltip: boolean;
+                beforeFilter: (value: string) => boolean | Promise<any>;
+                tagType: "primary" | "success" | "warning" | "info" | "danger";
+                tagEffect: "plain" | "dark" | "light";
+            }> & Omit<{
+                readonly props: import('element-plus/es/index').CascaderProps;
+                readonly disabled: boolean;
+                readonly popperClass: string;
+                readonly teleported: boolean;
+                readonly validateEvent: boolean;
+                readonly persistent: boolean;
+                readonly placement: any;
+                readonly fallbackPlacements: Placement[];
+                readonly options: import('element-plus/es/index').CascaderOption[];
+                readonly clearable: boolean;
+                readonly filterable: boolean;
+                readonly filterMethod: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+                readonly separator: string;
+                readonly showAllLevels: boolean;
+                readonly collapseTags: boolean;
+                readonly maxCollapseTags: number;
+                readonly collapseTagsTooltip: boolean;
+                readonly debounce: number;
+                readonly beforeFilter: (value: string) => boolean | Promise<any>;
+                readonly tagType: "primary" | "success" | "warning" | "info" | "danger";
+                readonly tagEffect: "plain" | "dark" | "light";
+                readonly size?: ("" | "small" | "default" | "large") | undefined;
+                readonly modelValue?: ((string | number)[] | (string | number) | ((string | number)[] | (string | number))[]) | undefined;
+                readonly emptyValues?: unknown[] | undefined;
+                readonly valueOnClear?: (string | number | boolean | Function) | undefined;
+                readonly placeholder?: string | undefined;
+                readonly maxCollapseTagsTooltipHeight?: (string | number) | undefined;
+                "onUpdate:modelValue"?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined | undefined;
+                onChange?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined | undefined;
+                onFocus?: ((evt: FocusEvent) => any) | undefined | undefined;
+                onBlur?: ((evt: FocusEvent) => any) | undefined | undefined;
+                onClear?: (() => any) | undefined | undefined;
+                onVisibleChange?: ((val: boolean) => any) | undefined | undefined;
+                onExpandChange?: ((val: import('element-plus/es/index').CascaderValue) => any) | undefined | undefined;
+                onRemoveTag?: ((val: (string | number) | (string | number)[]) => any) | undefined | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "props" | "disabled" | "valueOnClear" | "popperClass" | "teleported" | "validateEvent" | "persistent" | "placement" | "fallbackPlacements" | "options" | "clearable" | "filterable" | "filterMethod" | "separator" | "showAllLevels" | "collapseTags" | "maxCollapseTags" | "collapseTagsTooltip" | "debounce" | "beforeFilter" | "tagType" | "tagEffect">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "clear") => void) & ((event: "change", value: import('element-plus/es/index').CascaderValue) => void) & ((event: "update:modelValue", value: import('element-plus/es/index').CascaderValue) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "visibleChange", val: boolean) => void) & ((event: "expandChange", val: import('element-plus/es/index').CascaderValue) => void) & ((event: "removeTag", val: (string | number)[] | (string | number)) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                emptyValues: ArrayConstructor;
+                valueOnClear: {
+                    readonly type: import('vue').PropType<string | number | boolean | Function>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                size: {
+                    readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                placeholder: StringConstructor;
+                disabled: BooleanConstructor;
+                clearable: BooleanConstructor;
+                filterable: BooleanConstructor;
+                filterMethod: {
+                    readonly type: import('vue').PropType<(node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+                };
+                separator: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: string;
+                };
+                showAllLevels: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: boolean;
+                };
+                collapseTags: BooleanConstructor;
+                maxCollapseTags: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: number;
+                };
+                collapseTagsTooltip: BooleanConstructor;
+                maxCollapseTagsTooltipHeight: {
+                    readonly type: import('vue').PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                debounce: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: number;
+                };
+                beforeFilter: {
+                    readonly type: import('vue').PropType<(value: string) => boolean | Promise<any>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => true;
+                };
+                placement: {
+                    readonly type: import('vue').PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: string;
+                };
+                fallbackPlacements: {
+                    readonly type: import('vue').PropType<Placement[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: string[];
+                };
+                popperClass: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: string;
+                };
+                teleported: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                tagType: {
+                    default: string;
+                    type: import('vue').PropType<"primary" | "success" | "warning" | "info" | "danger">;
+                    required: false;
+                    validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                tagEffect: {
+                    default: string;
+                    type: import('vue').PropType<"plain" | "dark" | "light">;
+                    required: false;
+                    validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                validateEvent: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: boolean;
+                };
+                persistent: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: boolean;
+                };
+                modelValue: {
+                    readonly type: import('vue').PropType<(string | number)[] | (string | number) | ((string | number)[] | (string | number))[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                options: {
+                    readonly type: import('vue').PropType<import('element-plus/es/index').CascaderOption[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => import('element-plus/es/index').CascaderOption[];
+                };
+                props: {
+                    readonly type: import('vue').PropType<import('element-plus/es/index').CascaderProps>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => import('element-plus/es/index').CascaderProps;
+                };
+            }>> & {
+                "onUpdate:modelValue"?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined;
+                onChange?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined;
+                onFocus?: ((evt: FocusEvent) => any) | undefined;
+                onBlur?: ((evt: FocusEvent) => any) | undefined;
+                onClear?: (() => any) | undefined;
+                onVisibleChange?: ((val: boolean) => any) | undefined;
+                onExpandChange?: ((val: import('element-plus/es/index').CascaderValue) => any) | undefined;
+                onRemoveTag?: ((val: (string | number) | (string | number)[]) => any) | undefined;
+            }, {
+                getCheckedNodes: (leafOnly: boolean) => import('element-plus/es/index').CascaderNode[] | undefined;
+                cascaderPanelRef: import('vue').Ref<import('element-plus/es/index').CascaderPanelInstance | null>;
+                togglePopperVisible: (visible?: boolean) => void;
+                contentRef: import('vue').ComputedRef<HTMLElement | undefined>;
+                presentText: import('vue').ComputedRef<string>;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                clear: () => void;
+                "update:modelValue": (value: import('element-plus/es/index').CascaderValue) => void;
+                change: (value: import('element-plus/es/index').CascaderValue) => void;
+                blur: (evt: FocusEvent) => void;
+                focus: (evt: FocusEvent) => void;
+                visibleChange: (val: boolean) => void;
+                expandChange: (val: import('element-plus/es/index').CascaderValue) => void;
+                removeTag: (val: (string | number) | (string | number)[]) => void;
+            }, string, {
+                disabled: boolean;
+                separator: string;
+                props: import('element-plus/es/index').CascaderProps;
+                placement: any;
+                options: import('element-plus/es/index').CascaderOption[];
+                valueOnClear: string | number | boolean | Function;
+                validateEvent: boolean;
+                clearable: boolean;
+                fallbackPlacements: Placement[];
+                popperClass: string;
+                teleported: boolean;
+                persistent: boolean;
+                debounce: number;
+                filterable: boolean;
+                filterMethod: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+                showAllLevels: boolean;
+                collapseTags: boolean;
+                maxCollapseTags: number;
+                collapseTagsTooltip: boolean;
+                beforeFilter: (value: string) => boolean | Promise<any>;
+                tagType: "primary" | "success" | "warning" | "info" | "danger";
+                tagEffect: "plain" | "dark" | "light";
+            }, {}, 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 import('vue').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<{
+            disabled: boolean;
+            separator: string;
+            props: import('element-plus/es/index').CascaderProps;
+            placement: any;
+            options: import('element-plus/es/index').CascaderOption[];
+            valueOnClear: string | number | boolean | Function;
+            validateEvent: boolean;
+            clearable: boolean;
+            fallbackPlacements: Placement[];
+            popperClass: string;
+            teleported: boolean;
+            persistent: boolean;
+            debounce: number;
+            filterable: boolean;
+            filterMethod: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+            showAllLevels: boolean;
+            collapseTags: boolean;
+            maxCollapseTags: number;
+            collapseTagsTooltip: boolean;
+            beforeFilter: (value: string) => boolean | Promise<any>;
+            tagType: "primary" | "success" | "warning" | "info" | "danger";
+            tagEffect: "plain" | "dark" | "light";
+        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+            emptyValues: ArrayConstructor;
+            valueOnClear: {
+                readonly type: import('vue').PropType<string | number | boolean | Function>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            size: {
+                readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            placeholder: StringConstructor;
+            disabled: BooleanConstructor;
+            clearable: BooleanConstructor;
+            filterable: BooleanConstructor;
+            filterMethod: {
+                readonly type: import('vue').PropType<(node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+            };
+            separator: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            showAllLevels: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            collapseTags: BooleanConstructor;
+            maxCollapseTags: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            collapseTagsTooltip: BooleanConstructor;
+            maxCollapseTagsTooltipHeight: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            debounce: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            beforeFilter: {
+                readonly type: import('vue').PropType<(value: string) => boolean | Promise<any>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => true;
+            };
+            placement: {
+                readonly type: import('vue').PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            fallbackPlacements: {
+                readonly type: import('vue').PropType<Placement[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string[];
+            };
+            popperClass: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            teleported: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            tagType: {
+                default: string;
+                type: import('vue').PropType<"primary" | "success" | "warning" | "info" | "danger">;
+                required: false;
+                validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tagEffect: {
+                default: string;
+                type: import('vue').PropType<"plain" | "dark" | "light">;
+                required: false;
+                validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            validateEvent: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            persistent: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            modelValue: {
+                readonly type: import('vue').PropType<(string | number)[] | (string | number) | ((string | number)[] | (string | number))[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            options: {
+                readonly type: import('vue').PropType<import('element-plus/es/index').CascaderOption[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => import('element-plus/es/index').CascaderOption[];
+            };
+            props: {
+                readonly type: import('vue').PropType<import('element-plus/es/index').CascaderProps>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => import('element-plus/es/index').CascaderProps;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined;
+            onChange?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined;
+            onFocus?: ((evt: FocusEvent) => any) | undefined;
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onClear?: (() => any) | undefined;
+            onVisibleChange?: ((val: boolean) => any) | undefined;
+            onExpandChange?: ((val: import('element-plus/es/index').CascaderValue) => any) | undefined;
+            onRemoveTag?: ((val: (string | number) | (string | number)[]) => any) | undefined;
+        }, "props" | "disabled" | "valueOnClear" | "popperClass" | "teleported" | "validateEvent" | "persistent" | "placement" | "contentRef" | "fallbackPlacements" | "options" | "getCheckedNodes" | "clearable" | "filterable" | "filterMethod" | "separator" | "showAllLevels" | "collapseTags" | "maxCollapseTags" | "collapseTagsTooltip" | "debounce" | "beforeFilter" | "tagType" | "tagEffect" | "cascaderPanelRef" | "togglePopperVisible" | "presentText"> & import('vue').ShallowUnwrapRef<{
+            getCheckedNodes: (leafOnly: boolean) => import('element-plus/es/index').CascaderNode[] | undefined;
+            cascaderPanelRef: import('vue').Ref<import('element-plus/es/index').CascaderPanelInstance | null>;
+            togglePopperVisible: (visible?: boolean) => void;
+            contentRef: import('vue').ComputedRef<HTMLElement | undefined>;
+            presentText: import('vue').ComputedRef<string>;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                prefix?(_: {}): any;
+                tag?(_: {
+                    data: import('element-plus/es/index').Tag[];
+                    deleteTag: (tag: import('element-plus/es/index').Tag) => void;
+                }): any;
+                empty?(_: {}): any;
+                empty?(_: {}): any;
+                "suggestion-item"?(_: {
+                    item: import('element-plus/es/index').CascaderNode;
+                }): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {
+    refEl: import('vue').Ref<any, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {} | {
+    [x: string]: any;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    refEl: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            disabled: boolean;
+            separator: string;
+            props: import('element-plus/es/index').CascaderProps;
+            placement: any;
+            options: import('element-plus/es/index').CascaderOption[];
+            valueOnClear: string | number | boolean | Function;
+            validateEvent: boolean;
+            clearable: boolean;
+            fallbackPlacements: Placement[];
+            popperClass: string;
+            teleported: boolean;
+            persistent: boolean;
+            debounce: number;
+            filterable: boolean;
+            filterMethod: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+            showAllLevels: boolean;
+            collapseTags: boolean;
+            maxCollapseTags: number;
+            collapseTagsTooltip: boolean;
+            beforeFilter: (value: string) => boolean | Promise<any>;
+            tagType: "primary" | "success" | "warning" | "info" | "danger";
+            tagEffect: "plain" | "dark" | "light";
+        }> & Omit<{
+            readonly props: import('element-plus/es/index').CascaderProps;
+            readonly disabled: boolean;
+            readonly popperClass: string;
+            readonly teleported: boolean;
+            readonly validateEvent: boolean;
+            readonly persistent: boolean;
+            readonly placement: any;
+            readonly fallbackPlacements: Placement[];
+            readonly options: import('element-plus/es/index').CascaderOption[];
+            readonly clearable: boolean;
+            readonly filterable: boolean;
+            readonly filterMethod: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+            readonly separator: string;
+            readonly showAllLevels: boolean;
+            readonly collapseTags: boolean;
+            readonly maxCollapseTags: number;
+            readonly collapseTagsTooltip: boolean;
+            readonly debounce: number;
+            readonly beforeFilter: (value: string) => boolean | Promise<any>;
+            readonly tagType: "primary" | "success" | "warning" | "info" | "danger";
+            readonly tagEffect: "plain" | "dark" | "light";
+            readonly size?: ("" | "small" | "default" | "large") | undefined;
+            readonly modelValue?: ((string | number)[] | (string | number) | ((string | number)[] | (string | number))[]) | undefined;
+            readonly emptyValues?: unknown[] | undefined;
+            readonly valueOnClear?: (string | number | boolean | Function) | undefined;
+            readonly placeholder?: string | undefined;
+            readonly maxCollapseTagsTooltipHeight?: (string | number) | undefined;
+            "onUpdate:modelValue"?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined | undefined;
+            onChange?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined | undefined;
+            onFocus?: ((evt: FocusEvent) => any) | undefined | undefined;
+            onBlur?: ((evt: FocusEvent) => any) | undefined | undefined;
+            onClear?: (() => any) | undefined | undefined;
+            onVisibleChange?: ((val: boolean) => any) | undefined | undefined;
+            onExpandChange?: ((val: import('element-plus/es/index').CascaderValue) => any) | undefined | undefined;
+            onRemoveTag?: ((val: (string | number) | (string | number)[]) => any) | undefined | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "props" | "disabled" | "valueOnClear" | "popperClass" | "teleported" | "validateEvent" | "persistent" | "placement" | "fallbackPlacements" | "options" | "clearable" | "filterable" | "filterMethod" | "separator" | "showAllLevels" | "collapseTags" | "maxCollapseTags" | "collapseTagsTooltip" | "debounce" | "beforeFilter" | "tagType" | "tagEffect">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "clear") => void) & ((event: "change", value: import('element-plus/es/index').CascaderValue) => void) & ((event: "update:modelValue", value: import('element-plus/es/index').CascaderValue) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "visibleChange", val: boolean) => void) & ((event: "expandChange", val: import('element-plus/es/index').CascaderValue) => void) & ((event: "removeTag", val: (string | number)[] | (string | number)) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            emptyValues: ArrayConstructor;
+            valueOnClear: {
+                readonly type: import('vue').PropType<string | number | boolean | Function>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            size: {
+                readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            placeholder: StringConstructor;
+            disabled: BooleanConstructor;
+            clearable: BooleanConstructor;
+            filterable: BooleanConstructor;
+            filterMethod: {
+                readonly type: import('vue').PropType<(node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+            };
+            separator: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            showAllLevels: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            collapseTags: BooleanConstructor;
+            maxCollapseTags: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            collapseTagsTooltip: BooleanConstructor;
+            maxCollapseTagsTooltipHeight: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            debounce: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: number;
+            };
+            beforeFilter: {
+                readonly type: import('vue').PropType<(value: string) => boolean | Promise<any>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => true;
+            };
+            placement: {
+                readonly type: import('vue').PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            fallbackPlacements: {
+                readonly type: import('vue').PropType<Placement[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string[];
+            };
+            popperClass: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: string;
+            };
+            teleported: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            tagType: {
+                default: string;
+                type: import('vue').PropType<"primary" | "success" | "warning" | "info" | "danger">;
+                required: false;
+                validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tagEffect: {
+                default: string;
+                type: import('vue').PropType<"plain" | "dark" | "light">;
+                required: false;
+                validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            validateEvent: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            persistent: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            modelValue: {
+                readonly type: import('vue').PropType<(string | number)[] | (string | number) | ((string | number)[] | (string | number))[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            options: {
+                readonly type: import('vue').PropType<import('element-plus/es/index').CascaderOption[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => import('element-plus/es/index').CascaderOption[];
+            };
+            props: {
+                readonly type: import('vue').PropType<import('element-plus/es/index').CascaderProps>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => import('element-plus/es/index').CascaderProps;
+            };
+        }>> & {
+            "onUpdate:modelValue"?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined;
+            onChange?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined;
+            onFocus?: ((evt: FocusEvent) => any) | undefined;
+            onBlur?: ((evt: FocusEvent) => any) | undefined;
+            onClear?: (() => any) | undefined;
+            onVisibleChange?: ((val: boolean) => any) | undefined;
+            onExpandChange?: ((val: import('element-plus/es/index').CascaderValue) => any) | undefined;
+            onRemoveTag?: ((val: (string | number) | (string | number)[]) => any) | undefined;
+        }, {
+            getCheckedNodes: (leafOnly: boolean) => import('element-plus/es/index').CascaderNode[] | undefined;
+            cascaderPanelRef: import('vue').Ref<import('element-plus/es/index').CascaderPanelInstance | null>;
+            togglePopperVisible: (visible?: boolean) => void;
+            contentRef: import('vue').ComputedRef<HTMLElement | undefined>;
+            presentText: import('vue').ComputedRef<string>;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            clear: () => void;
+            "update:modelValue": (value: import('element-plus/es/index').CascaderValue) => void;
+            change: (value: import('element-plus/es/index').CascaderValue) => void;
+            blur: (evt: FocusEvent) => void;
+            focus: (evt: FocusEvent) => void;
+            visibleChange: (val: boolean) => void;
+            expandChange: (val: import('element-plus/es/index').CascaderValue) => void;
+            removeTag: (val: (string | number) | (string | number)[]) => void;
+        }, string, {
+            disabled: boolean;
+            separator: string;
+            props: import('element-plus/es/index').CascaderProps;
+            placement: any;
+            options: import('element-plus/es/index').CascaderOption[];
+            valueOnClear: string | number | boolean | Function;
+            validateEvent: boolean;
+            clearable: boolean;
+            fallbackPlacements: Placement[];
+            popperClass: string;
+            teleported: boolean;
+            persistent: boolean;
+            debounce: number;
+            filterable: boolean;
+            filterMethod: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+            showAllLevels: boolean;
+            collapseTags: boolean;
+            maxCollapseTags: number;
+            collapseTagsTooltip: boolean;
+            beforeFilter: (value: string) => boolean | Promise<any>;
+            tagType: "primary" | "success" | "warning" | "info" | "danger";
+            tagEffect: "plain" | "dark" | "light";
+        }, {}, 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 import('vue').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<{
+        disabled: boolean;
+        separator: string;
+        props: import('element-plus/es/index').CascaderProps;
+        placement: any;
+        options: import('element-plus/es/index').CascaderOption[];
+        valueOnClear: string | number | boolean | Function;
+        validateEvent: boolean;
+        clearable: boolean;
+        fallbackPlacements: Placement[];
+        popperClass: string;
+        teleported: boolean;
+        persistent: boolean;
+        debounce: number;
+        filterable: boolean;
+        filterMethod: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+        showAllLevels: boolean;
+        collapseTags: boolean;
+        maxCollapseTags: number;
+        collapseTagsTooltip: boolean;
+        beforeFilter: (value: string) => boolean | Promise<any>;
+        tagType: "primary" | "success" | "warning" | "info" | "danger";
+        tagEffect: "plain" | "dark" | "light";
+    }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+        emptyValues: ArrayConstructor;
+        valueOnClear: {
+            readonly type: import('vue').PropType<string | number | boolean | Function>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        size: {
+            readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        placeholder: StringConstructor;
+        disabled: BooleanConstructor;
+        clearable: BooleanConstructor;
+        filterable: BooleanConstructor;
+        filterMethod: {
+            readonly type: import('vue').PropType<(node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: (node: import('element-plus/es/index').CascaderNode, keyword: string) => boolean;
+        };
+        separator: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: string;
+        };
+        showAllLevels: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        collapseTags: BooleanConstructor;
+        maxCollapseTags: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: number;
+        };
+        collapseTagsTooltip: BooleanConstructor;
+        maxCollapseTagsTooltipHeight: {
+            readonly type: import('vue').PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        debounce: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: number;
+        };
+        beforeFilter: {
+            readonly type: import('vue').PropType<(value: string) => boolean | Promise<any>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => true;
+        };
+        placement: {
+            readonly type: import('vue').PropType<any>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: string;
+        };
+        fallbackPlacements: {
+            readonly type: import('vue').PropType<Placement[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: string[];
+        };
+        popperClass: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: string;
+        };
+        teleported: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        tagType: {
+            default: string;
+            type: import('vue').PropType<"primary" | "success" | "warning" | "info" | "danger">;
+            required: false;
+            validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        tagEffect: {
+            default: string;
+            type: import('vue').PropType<"plain" | "dark" | "light">;
+            required: false;
+            validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        validateEvent: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        persistent: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        modelValue: {
+            readonly type: import('vue').PropType<(string | number)[] | (string | number) | ((string | number)[] | (string | number))[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        options: {
+            readonly type: import('vue').PropType<import('element-plus/es/index').CascaderOption[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => import('element-plus/es/index').CascaderOption[];
+        };
+        props: {
+            readonly type: import('vue').PropType<import('element-plus/es/index').CascaderProps>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => import('element-plus/es/index').CascaderProps;
+        };
+    }>> & {
+        "onUpdate:modelValue"?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined;
+        onChange?: ((value: import('element-plus/es/index').CascaderValue) => any) | undefined;
+        onFocus?: ((evt: FocusEvent) => any) | undefined;
+        onBlur?: ((evt: FocusEvent) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onVisibleChange?: ((val: boolean) => any) | undefined;
+        onExpandChange?: ((val: import('element-plus/es/index').CascaderValue) => any) | undefined;
+        onRemoveTag?: ((val: (string | number) | (string | number)[]) => any) | undefined;
+    }, "props" | "disabled" | "valueOnClear" | "popperClass" | "teleported" | "validateEvent" | "persistent" | "placement" | "contentRef" | "fallbackPlacements" | "options" | "getCheckedNodes" | "clearable" | "filterable" | "filterMethod" | "separator" | "showAllLevels" | "collapseTags" | "maxCollapseTags" | "collapseTagsTooltip" | "debounce" | "beforeFilter" | "tagType" | "tagEffect" | "cascaderPanelRef" | "togglePopperVisible" | "presentText"> & import('vue').ShallowUnwrapRef<{
+        getCheckedNodes: (leafOnly: boolean) => import('element-plus/es/index').CascaderNode[] | undefined;
+        cascaderPanelRef: import('vue').Ref<import('element-plus/es/index').CascaderPanelInstance | null>;
+        togglePopperVisible: (visible?: boolean) => void;
+        contentRef: import('vue').ComputedRef<HTMLElement | undefined>;
+        presentText: import('vue').ComputedRef<string>;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            prefix?(_: {}): any;
+            tag?(_: {
+                data: import('element-plus/es/index').Tag[];
+                deleteTag: (tag: import('element-plus/es/index').Tag) => void;
+            }): any;
+            empty?(_: {}): any;
+            empty?(_: {}): any;
+            "suggestion-item"?(_: {
+                item: import('element-plus/es/index').CascaderNode;
+            }): any;
+        };
+    }) | null;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};