@fangzhongya/fang-ui 0.0.12 → 0.0.13

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

@@ -0,0 +1,545 @@
+declare const Cascader: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+        refEl: import('vue').Ref<any, any>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {} | {
+        [x: string]: any;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        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, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {
+        refEl: import('vue').Ref<any, any>;
+    }, {}, {}, {}, {} | {
+        [x: string]: any;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {
+    refEl: import('vue').Ref<any, any>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {} | {
+    [x: string]: any;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Partial<Record<string, (_: {}) => any>>;
+}) & import('vue').Plugin;
+export { Cascader, Cascader as default };

package/dist/components/cascader/index.js

@@ -0,0 +1,7 @@
+import { withInstall } from "../../utils/vues/withInstall.js";
+import _sfc_main from "./src/index.js";
+const Cascader = withInstall(_sfc_main, "Cascader");
+export {
+  Cascader,
+  Cascader as default
+};

package/dist/components/cascader/src/data.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const buildProps = require("../../../utils/vues/buildProps.cjs");
+const dataProps = buildProps.buildProps({});
+const dataEmits = [];
+const dataExpose = {};
+exports.dataEmits = dataEmits;
+exports.dataExpose = dataExpose;
+exports.dataProps = dataProps;

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

@@ -0,0 +1,14 @@
+import { ExtractPropTypes } from 'vue';
+/**
+ * @title {h2} Cascader 级联选择器
+ * @text 目前完全继承 element-plus 中 el-cascader
+ */
+export declare const dataProps: any;
+export type DataProps = ExtractPropTypes<typeof dataProps>;
+export declare const dataEmits: never[];
+export type DataEmits = typeof dataEmits;
+export declare const dataSlot: {};
+/**
+ * @expose refEl 获取当前组件在element-plus中暴露的方法
+ */
+export declare const dataExpose: {};

package/dist/components/cascader/src/data.js

@@ -0,0 +1,9 @@
+import { buildProps } from "../../../utils/vues/buildProps.js";
+const dataProps = buildProps({});
+const dataEmits = [];
+const dataExpose = {};
+export {
+  dataEmits,
+  dataExpose,
+  dataProps
+};

package/dist/components/cascader/src/index.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const require$$0 = require("vue");
+const data = require("./data.cjs");
+const index$1 = require("../../../hooks/cssname/index.cjs");
+require("@fangzhongya/utils/basic/string/splitUpper");
+require("@fangzhongya/utils/basic/array/isArray");
+require("@fangzhongya/utils/basic/object/isObject");
+require("@fangzhongya/utils/basic/string/firstLower");
+require("@fangzhongya/utils/basic/object/hasOwn");
+require("@fangzhongya/utils/basic/string/firstUpper");
+require("@fangzhongya/utils/name/lineToLargeHump");
+require("@fangzhongya/utils/name/lineToSmallHump");
+require("@fangzhongya/utils/name/humpToLine");
+require("@fangzhongya/utils/basic/object/deepCopy");
+require("@fangzhongya/utils/basic/Array/toggleArray");
+require("@fangzhongya/utils/basic/object/objValue");
+require("../../../hooks/global-config/index.cjs");
+const index$2 = require("../../../hooks/locale/index.cjs");
+const index = require("../../../hooks/inherit/index.cjs");
+const elementPlus = require("element-plus");
+const _sfc_main = /* @__PURE__ */ require$$0.defineComponent({
+  ...{ inheritAttrs: false },
+  __name: "index",
+  props: data.dataProps,
+  emits: data.dataEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const refEl = require$$0.ref();
+    const attrs = index.useInherit();
+    const slots = require$$0.useSlots();
+    const cs = index$1.useCssName("cascader");
+    index$2.useLocale();
+    __expose({
+      ...data.dataExpose,
+      refEl
+    });
+    return (_ctx, _cache) => {
+      return require$$0.openBlock(), require$$0.createElementBlock("div", require$$0.mergeProps({
+        class: [require$$0.unref(cs).z()]
+      }, require$$0.unref(attrs).root), [
+        require$$0.createVNode(require$$0.unref(elementPlus.ElCascader), require$$0.mergeProps(require$$0.unref(attrs).assem, {
+          ref_key: "refEl",
+          ref: refEl
+        }), require$$0.createSlots({ _: 2 }, [
+          require$$0.renderList(Object.keys(require$$0.unref(slots)), (k, index2) => {
+            return {
+              name: k,
+              fn: require$$0.withCtx(() => [
+                require$$0.renderSlot(_ctx.$slots, k)
+              ])
+            };
+          })
+        ]), 1040)
+      ], 16);
+    };
+  }
+});
+exports.default = _sfc_main;