ep-craft 0.1.34 → 0.1.35

package/dist/components/tree/src/model/useKeydown.js

@@ -0,0 +1,93 @@
+import { onMounted as f, onUpdated as b } from "vue";
+import { useEventListener as h } from "@vueuse/core";
+import { EVENT_CODE as c } from "../../../../constants/aria.js";
+import { useNamespace as x } from "../../../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import { getEventCode as y } from "../../../../utils/dom/event.js";
+import "@element-plus/icons-vue";
+import "../../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../../hooks/use-z-index/index.js";
+import "../../../../hooks/use-delayed-toggle/index.js";
+import "../../../../hooks/use-aria/index.js";
+import "../../../../hooks/use-model-toggle/index.js";
+import "../../../../hooks/use-empty-values/index.js";
+function L({ el$: u }, m) {
+  const s = x("tree");
+  f(() => {
+    p();
+  }), b(() => {
+    var r;
+    (r = u.value) == null || r.querySelectorAll("input[type=checkbox]").forEach((i) => {
+      i.setAttribute("tabindex", "-1");
+    });
+  });
+  function a(r, i) {
+    var t, o;
+    const n = m.value.getNode(r[i].dataset.key);
+    return n.canFocus && n.visible && (((t = n.parent) == null ? void 0 : t.expanded) || ((o = n.parent) == null ? void 0 : o.level) === 0);
+  }
+  h(u, "keydown", (r) => {
+    const i = r.target;
+    if (!i.className.includes(s.b("node"))) return;
+    const n = y(r), t = Array.from(
+      u.value.querySelectorAll(`.${s.is("focusable")}[role=treeitem]`)
+    ), o = t.indexOf(i);
+    let e;
+    if ([c.up, c.down].includes(n)) {
+      if (r.preventDefault(), n === c.up) {
+        e = o === -1 ? 0 : o !== 0 ? o - 1 : t.length - 1;
+        const l = e;
+        for (; !a(t, e); ) {
+          if (e--, e === l) {
+            e = -1;
+            break;
+          }
+          e < 0 && (e = t.length - 1);
+        }
+      } else {
+        e = o === -1 ? 0 : o < t.length - 1 ? o + 1 : 0;
+        const l = e;
+        for (; !a(t, e); ) {
+          if (e++, e === l) {
+            e = -1;
+            break;
+          }
+          e >= t.length && (e = 0);
+        }
+      }
+      e !== -1 && t[e].focus();
+    }
+    [c.left, c.right].includes(n) && (r.preventDefault(), i.click());
+    const d = i.querySelector(
+      '[type="checkbox"]'
+    );
+    [c.enter, c.numpadEnter, c.space].includes(
+      n
+    ) && d && (r.preventDefault(), d.click());
+  });
+  const p = () => {
+    var t;
+    if (!u.value) return;
+    const r = Array.from(
+      u.value.querySelectorAll(`.${s.is("focusable")}[role=treeitem]`)
+    );
+    Array.from(
+      u.value.querySelectorAll("input[type=checkbox]")
+    ).forEach((o) => {
+      o.setAttribute("tabindex", "-1");
+    });
+    const n = u.value.querySelectorAll(
+      `.${s.is("checked")}[role=treeitem]`
+    );
+    if (n.length) {
+      n[0].setAttribute("tabindex", "0");
+      return;
+    }
+    (t = r[0]) == null || t.setAttribute("tabindex", "0");
+  };
+}
+export {
+  L as useKeydown
+};

package/dist/components/tree/src/model/useNodeExpandEventBroadcast.d.ts

@@ -0,0 +1,9 @@
+import type Node from '../model/node';
+interface Props {
+    node?: Node;
+    accordion: boolean;
+}
+export declare function useNodeExpandEventBroadcast(props: Props): {
+    broadcastExpanded: (node?: Node) => void;
+};
+export {};

package/dist/components/tree/src/model/useNodeExpandEventBroadcast.js

@@ -0,0 +1,27 @@
+import { inject as c, onBeforeUnmount as i, provide as a } from "vue";
+import { TREE_NODE_MAP_INJECTION_KEY as t } from "../tokens.js";
+function E(o) {
+  const n = c(
+    t,
+    null
+  );
+  let e = {
+    treeNodeExpand: (r) => {
+      var d;
+      o.node !== r && ((d = o.node) == null || d.collapse());
+    },
+    children: /* @__PURE__ */ new Set()
+  };
+  return n && n.children.add(e), i(() => {
+    n && n.children.delete(e), e = null;
+  }), a(t, e), {
+    broadcastExpanded: (r) => {
+      if (o.accordion)
+        for (const d of e.children)
+          d.treeNodeExpand(r);
+    }
+  };
+}
+export {
+  E as useNodeExpandEventBroadcast
+};

package/dist/components/tree/src/model/util.d.ts

@@ -0,0 +1,7 @@
+import type Node from './node';
+import type { TreeEmits } from '../tree';
+import type { RootTreeType, TreeKey, TreeNodeData } from '../tree.type';
+export declare const NODE_KEY = "$treeNodeId";
+export declare const markNodeData: (node: Node, data: TreeNodeData | null) => void;
+export declare const getNodeKey: (key: TreeKey | undefined, data: TreeNodeData) => any;
+export declare const handleCurrentChange: (store: RootTreeType["store"], emit: TreeEmits, setCurrent: () => void) => void;

package/dist/components/tree/src/model/util.js

@@ -0,0 +1,19 @@
+const o = "$treeNodeId", c = function(r, e) {
+  !e || e[o] || Object.defineProperty(e, o, {
+    value: r.id,
+    enumerable: !1,
+    configurable: !1,
+    writable: !1
+  });
+}, l = (r, e) => e == null ? void 0 : e[r || o], f = (r, e, t) => {
+  const u = r.value.currentNode;
+  t();
+  const n = r.value.currentNode;
+  u !== n && e("current-change", n ? n.data : null, n);
+};
+export {
+  o as NODE_KEY,
+  l as getNodeKey,
+  f as handleCurrentChange,
+  c as markNodeData
+};

package/dist/components/tree/src/tokens.d.ts

@@ -0,0 +1,3 @@
+export declare const ROOT_TREE_INJECTION_KEY = "RootTree";
+export declare const NODE_INSTANCE_INJECTION_KEY = "NodeInstance";
+export declare const TREE_NODE_MAP_INJECTION_KEY = "TreeNodeMap";

package/dist/components/tree/src/tokens.js

@@ -0,0 +1,6 @@
+const E = "RootTree", N = "NodeInstance", _ = "TreeNodeMap";
+export {
+  N as NODE_INSTANCE_INJECTION_KEY,
+  E as ROOT_TREE_INJECTION_KEY,
+  _ as TREE_NODE_MAP_INJECTION_KEY
+};

package/dist/components/tree/src/tree-node-content.vue.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    node: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    renderContent: FunctionConstructor;
+}>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    node: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    renderContent: FunctionConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/tree/src/tree-node-content.vue.js

@@ -0,0 +1,43 @@
+import { defineComponent as a, inject as r, h as n, renderSlot as d } from "vue";
+import { EpText as c } from "../../text/index.js";
+import { useNamespace as u } from "../../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import "../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { NODE_INSTANCE_INJECTION_KEY as l, ROOT_TREE_INJECTION_KEY as E } from "./tokens.js";
+const g = a({
+  name: "EpTreeNodeContent",
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    },
+    renderContent: Function
+  },
+  setup(e) {
+    const m = u("tree"), p = r(
+      l
+    ), i = r(E);
+    return () => {
+      const t = e.node, { data: o, store: s } = t;
+      return e.renderContent ? e.renderContent(n, { _self: p, node: t, data: o, store: s }) : d(i.ctx.slots, "default", { node: t, data: o }, () => [
+        n(
+          c,
+          { tag: "span", truncated: !0, class: m.be("node", "label") },
+          () => [t.label]
+        )
+      ]);
+    };
+  }
+});
+export {
+  g as default
+};

package/dist/components/tree/src/tree-node-content2.vue.js

@@ -0,0 +1,4 @@
+import f from "./tree-node-content.vue.js";
+export {
+  f as default
+};

package/dist/components/tree/src/tree-node.vue.d.ts

@@ -0,0 +1,377 @@
+import Node from './model/node';
+import type { ComponentInternalInstance, PropType } from 'vue';
+import type { RootTreeType, TreeNodeData, TreeOptionProps } from './tree.type';
+import type { CheckboxValueType } from '@element-plus/components/checkbox';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    node: {
+        type: typeof Node;
+        default: () => {};
+    };
+    props: {
+        type: PropType<TreeOptionProps>;
+        default: () => {};
+    };
+    accordion: BooleanConstructor;
+    renderContent: FunctionConstructor;
+    renderAfterExpand: BooleanConstructor;
+    showCheckbox: BooleanConstructor;
+}>, {
+    ns: {
+        namespace: import("vue").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;
+    };
+    node$: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    tree: RootTreeType;
+    expanded: import("vue").Ref<boolean, boolean>;
+    childNodeRendered: import("vue").Ref<boolean, boolean>;
+    oldChecked: import("vue").Ref<boolean | undefined, boolean | undefined>;
+    oldIndeterminate: import("vue").Ref<boolean | undefined, boolean | undefined>;
+    getNodeKey: (node: Node) => any;
+    getNodeClass: (node: Node) => {
+        [key: string]: boolean;
+    };
+    handleSelectChange: (checked: boolean, indeterminate: boolean) => void;
+    handleClick: (e: MouseEvent) => void;
+    handleContextMenu: (event: Event) => void;
+    handleExpandIconClick: () => void;
+    handleCheckChange: (value: CheckboxValueType) => void;
+    handleChildNodeExpand: (nodeData: TreeNodeData, node: Node, instance: ComponentInternalInstance) => void;
+    handleDragStart: (event: DragEvent) => void;
+    handleDragOver: (event: DragEvent) => void;
+    handleDrop: (event: DragEvent) => void;
+    handleDragEnd: (event: DragEvent) => void;
+    CaretRight: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "node-expand"[], "node-expand", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    node: {
+        type: typeof Node;
+        default: () => {};
+    };
+    props: {
+        type: PropType<TreeOptionProps>;
+        default: () => {};
+    };
+    accordion: BooleanConstructor;
+    renderContent: FunctionConstructor;
+    renderAfterExpand: BooleanConstructor;
+    showCheckbox: BooleanConstructor;
+}>> & Readonly<{
+    "onNode-expand"?: ((...args: any[]) => any) | undefined;
+}>, {
+    props: TreeOptionProps;
+    node: Node;
+    accordion: boolean;
+    renderAfterExpand: boolean;
+    showCheckbox: boolean;
+}, {}, {
+    ElCollapseTransition: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<{}> & 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;
+        };
+    }) & import("vue").Plugin;
+    ElCheckbox: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            ariaControls: StringConstructor;
+            modelValue: {
+                type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            label: {
+                type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            value: {
+                type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            indeterminate: BooleanConstructor;
+            disabled: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            checked: BooleanConstructor;
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            trueValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            trueLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            id: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            border: BooleanConstructor;
+            size: {
+                readonly type: PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tabindex: (NumberConstructor | StringConstructor)[];
+            validateEvent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            ariaLabel: StringConstructor;
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+            onChange?: ((val: CheckboxValueType) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (val: CheckboxValueType) => void;
+            change: (val: CheckboxValueType) => void;
+        }, import("vue").PublicProps, {
+            name: string;
+            border: boolean;
+            disabled: boolean;
+            label: string | number | boolean | Record<string, any>;
+            value: string | number | boolean | Record<string, any>;
+            id: string;
+            modelValue: string | number | boolean;
+            validateEvent: boolean;
+            indeterminate: boolean;
+            checked: boolean;
+            trueValue: string | number;
+            falseValue: string | number;
+            trueLabel: string | number;
+            falseLabel: string | number;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            ariaControls: StringConstructor;
+            modelValue: {
+                type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            label: {
+                type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            value: {
+                type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            indeterminate: BooleanConstructor;
+            disabled: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            checked: BooleanConstructor;
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            trueValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseValue: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            trueLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            falseLabel: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: undefined;
+            };
+            id: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            border: BooleanConstructor;
+            size: {
+                readonly type: PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            tabindex: (NumberConstructor | StringConstructor)[];
+            validateEvent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            ariaLabel: StringConstructor;
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+            onChange?: ((val: CheckboxValueType) => any) | undefined;
+        }>, {}, {}, {}, {}, {
+            name: string;
+            border: boolean;
+            disabled: boolean;
+            label: string | number | boolean | Record<string, any>;
+            value: string | number | boolean | Record<string, any>;
+            id: string;
+            modelValue: string | number | boolean;
+            validateEvent: boolean;
+            indeterminate: boolean;
+            checked: boolean;
+            trueValue: string | number;
+            falseValue: string | number;
+            trueLabel: string | number;
+            falseLabel: string | number;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        ariaControls: StringConstructor;
+        modelValue: {
+            type: (BooleanConstructor | NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        label: {
+            type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        value: {
+            type: (BooleanConstructor | ObjectConstructor | NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        indeterminate: BooleanConstructor;
+        disabled: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        checked: BooleanConstructor;
+        name: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        trueValue: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        falseValue: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        trueLabel: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        falseLabel: {
+            type: (NumberConstructor | StringConstructor)[];
+            default: undefined;
+        };
+        id: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        border: BooleanConstructor;
+        size: {
+            readonly type: PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        tabindex: (NumberConstructor | StringConstructor)[];
+        validateEvent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        ariaLabel: StringConstructor;
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((val: CheckboxValueType) => any) | undefined;
+        onChange?: ((val: CheckboxValueType) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (val: CheckboxValueType) => void;
+        change: (val: CheckboxValueType) => void;
+    }, string, {
+        name: string;
+        border: boolean;
+        disabled: boolean;
+        label: string | number | boolean | Record<string, any>;
+        value: string | number | boolean | Record<string, any>;
+        id: string;
+        modelValue: string | number | boolean;
+        validateEvent: boolean;
+        indeterminate: boolean;
+        checked: boolean;
+        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").Plugin;
+    NodeContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        node: {
+            type: ObjectConstructor;
+            required: true;
+        };
+        renderContent: FunctionConstructor;
+    }>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        node: {
+            type: ObjectConstructor;
+            required: true;
+        };
+        renderContent: FunctionConstructor;
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    ElIcon: import("@element-plus/utils").SFCWithInstall<{
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("@element-plus/components/icon").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/components/icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("@element-plus/components/icon").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;
+        };
+    })>;
+    Loading: 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>;
+export default _default;