ele-admin-plus 1.3.1-beta.1 → 1.4.0-beta.1

package/lib/ele-cascader/index.d.ts

@@ -0,0 +1,366 @@
+import { ElCascaderInstance } from '../ele-app/el';
+import { CascaderOption } from './types';
+
+declare function __VLS_template(): Partial<Record<string, (_: any) => any>>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    options: import('vue').PropType<CascaderOption[] | import('./types').CascaderOptionFunction>;
+    multiple: BooleanConstructor;
+    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').CascaderNode, keyword: string) => boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: (node: import('element-plus').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: {
+        readonly type: import('vue').PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    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<import('element-plus').Placement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string;
+    };
+    fallbackPlacements: {
+        readonly type: import('vue').PropType<import('element-plus').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<"dark" | "light" | "plain">;
+        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;
+    };
+    props: {
+        readonly type: import('vue').PropType<import('element-plus').CascaderProps>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => import('element-plus').CascaderProps;
+    };
+}>, {
+    reloadOptions: (params?: any) => void;
+    cascaderRef: import('vue').Ref<ElCascaderInstance, ElCascaderInstance>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    focus: (evt: FocusEvent) => void;
+    blur: (evt: FocusEvent) => void;
+    clear: () => void;
+    "update:modelValue": (_: import('element-plus').CascaderValue) => void;
+    change: (_: import('element-plus').CascaderValue) => void;
+    visibleChange: (val: boolean) => void;
+    expandChange: (val: import('element-plus').CascaderValue) => void;
+    removeTag: (val: (string | number)[] | (string | number)) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    options: import('vue').PropType<CascaderOption[] | import('./types').CascaderOptionFunction>;
+    multiple: BooleanConstructor;
+    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').CascaderNode, keyword: string) => boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: (node: import('element-plus').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: {
+        readonly type: import('vue').PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    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<import('element-plus').Placement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string;
+    };
+    fallbackPlacements: {
+        readonly type: import('vue').PropType<import('element-plus').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<"dark" | "light" | "plain">;
+        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;
+    };
+    props: {
+        readonly type: import('vue').PropType<import('element-plus').CascaderProps>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => import('element-plus').CascaderProps;
+    };
+}>> & Readonly<{
+    onFocus?: ((evt: FocusEvent) => any) | undefined;
+    onBlur?: ((evt: FocusEvent) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((_: import('element-plus').CascaderValue) => any) | undefined;
+    onChange?: ((_: import('element-plus').CascaderValue) => any) | undefined;
+    onVisibleChange?: ((val: boolean) => any) | undefined;
+    onExpandChange?: ((val: import('element-plus').CascaderValue) => any) | undefined;
+    onRemoveTag?: ((val: (string | number)[] | (string | number)) => any) | undefined;
+}>, {
+    debounce: number;
+    placement: import('element-plus').Placement;
+    popperClass: string;
+    teleported: boolean;
+    clearable: boolean;
+    disabled: boolean;
+    separator: string;
+    valueOnClear: string | number | boolean | Function;
+    filterable: boolean;
+    filterMethod: (node: import('element-plus').CascaderNode, keyword: string) => boolean;
+    showAllLevels: boolean;
+    collapseTags: boolean;
+    maxCollapseTags: number;
+    collapseTagsTooltip: boolean;
+    beforeFilter: (value: string) => boolean | Promise<any>;
+    fallbackPlacements: import('element-plus').Placement[];
+    tagType: "primary" | "success" | "warning" | "info" | "danger";
+    tagEffect: "dark" | "light" | "plain";
+    validateEvent: boolean;
+    persistent: boolean;
+    props: import('element-plus').CascaderProps;
+    multiple: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/ele-cascader/props.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const elementPlus = require("element-plus");
+const cascaderProps = {
+  ...elementPlus.cascaderProps,
+  /** 选项数据 */
+  options: [Array, Function],
+  /** 是否多选 */
+  multiple: Boolean
+};
+Object.defineProperty(exports, "cascaderEmits", {
+  enumerable: true,
+  get: () => elementPlus.cascaderEmits
+});
+exports.cascaderProps = cascaderProps;

package/lib/ele-cascader/props.d.ts

@@ -0,0 +1,166 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { CascaderOption, CascaderOptionFunction } from './types';
+
+export { cascaderEmits } from 'element-plus';
+/**
+ * 属性
+ */
+export declare const cascaderProps: {
+    /** 选项数据 */
+    options: PropType<CascaderOption[] | CascaderOptionFunction>;
+    /** 是否多选 */
+    multiple: BooleanConstructor;
+    emptyValues: ArrayConstructor;
+    valueOnClear: {
+        readonly type: PropType<string | number | boolean | Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    size: {
+        readonly type: 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: PropType<(node: import('element-plus').CascaderNode, keyword: string) => boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: (node: import('element-plus').CascaderNode, keyword: string) => boolean;
+    };
+    separator: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string;
+    };
+    showAllLevels: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    collapseTags: BooleanConstructor;
+    maxCollapseTags: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: number;
+    };
+    collapseTagsTooltip: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    debounce: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: number;
+    };
+    beforeFilter: {
+        readonly type: PropType<(value: string) => boolean | Promise<any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => true;
+    };
+    placement: {
+        readonly type: PropType<import('element-plus').Placement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string;
+    };
+    fallbackPlacements: {
+        readonly type: PropType<import('element-plus').Placement[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string[];
+    };
+    popperClass: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: string;
+    };
+    teleported: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    tagType: {
+        default: string;
+        type: PropType<"primary" | "success" | "warning" | "info" | "danger">;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tagEffect: {
+        default: string;
+        type: PropType<"dark" | "light" | "plain">;
+        required: false;
+        validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    validateEvent: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    persistent: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: boolean;
+    };
+    modelValue: {
+        readonly type: PropType<(string | number)[] | (string | number) | ((string | number)[] | (string | number))[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    props: {
+        readonly type: PropType<import('element-plus').CascaderProps>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => import('element-plus').CascaderProps;
+    };
+};
+export type CascaderProps = ExtractPropTypes<typeof cascaderProps>;

package/lib/ele-cascader/style/index.cjs

@@ -0,0 +1,2 @@
+"use strict";
+require("element-plus/es/components/cascader/style/index");

package/lib/ele-cascader/style/index.d.ts

@@ -0,0 +1 @@
+

package/lib/ele-cascader/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 选项数据
+ */
+export type CascaderOption = Record<string, any>;
+
+/**
+ * 选项数据请求函数
+ */
+export type CascaderOptionFunction = () => Promise<CascaderOption[]>;

package/lib/ele-check-card/components/card-item.cjs

@@ -1,7 +1,8 @@
 "use strict";
 const vue = require("vue");
-const _sfc_main = vue.defineComponent({
-  name: "CardItem",
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...{ name: "CardItem" },
+  __name: "card-item",
   props: {
     /** 数据 */
     item: Object,
@@ -15,35 +16,29 @@ const _sfc_main = vue.defineComponent({
     arrow: Boolean,
     /** 选中箭头样式 */
     arrowStyle: Object
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass([
+          "ele-check-card",
+          { "is-bordered": __props.bordered },
+          { "is-checked": __props.checked },
+          { "is-disabled": __props.disabled }
+        ])
+      }, [
+        vue.renderSlot(_ctx.$slots, "default", {
+          item: __props.item,
+          checked: __props.checked,
+          disabled: __props.disabled
+        }),
+        __props.arrow ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 0,
+          class: "ele-check-card-arrow",
+          style: vue.normalizeStyle(__props.arrowStyle)
+        }, null, 4)) : vue.createCommentVNode("", true)
+      ], 2);
+    };
   }
 });
-const _export_sfc = (sfc, props) => {
-  const target = sfc.__vccOpts || sfc;
-  for (const [key, val] of props) {
-    target[key] = val;
-  }
-  return target;
-};
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  return vue.openBlock(), vue.createElementBlock("div", {
-    class: vue.normalizeClass([
-      "ele-check-card",
-      { "is-bordered": _ctx.bordered },
-      { "is-checked": _ctx.checked },
-      { "is-disabled": _ctx.disabled }
-    ])
-  }, [
-    vue.renderSlot(_ctx.$slots, "default", {
-      item: _ctx.item,
-      checked: _ctx.checked,
-      disabled: _ctx.disabled
-    }),
-    _ctx.arrow ? (vue.openBlock(), vue.createElementBlock("div", {
-      key: 0,
-      class: "ele-check-card-arrow",
-      style: vue.normalizeStyle(_ctx.arrowStyle)
-    }, null, 4)) : vue.createCommentVNode("", true)
-  ], 2);
-}
-const cardItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
-module.exports = cardItem;
+module.exports = _sfc_main;

package/lib/ele-check-card/components/card-item.d.ts

@@ -2,7 +2,14 @@ import { PropType } from 'vue';
 import { StyleValue } from '../../ele-app/types';
 import { CheckCardItem } from '../types';
 
-declare const _default: import('vue').DefineComponent<{
+declare function __VLS_template(): {
+    default?(_: {
+        item: CheckCardItem | undefined;
+        checked: boolean;
+        disabled: boolean;
+    }): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     /** 数据 */
     item: PropType<CheckCardItem>;
     /** 是否选中 */
@@ -15,7 +22,7 @@ declare const _default: import('vue').DefineComponent<{
     arrow: BooleanConstructor;
     /** 选中箭头样式 */
     arrowStyle: PropType<StyleValue>;
-}, unknown, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
     /** 数据 */
     item: PropType<CheckCardItem>;
     /** 是否选中 */
@@ -28,10 +35,16 @@ declare const _default: import('vue').DefineComponent<{
     arrow: BooleanConstructor;
     /** 选中箭头样式 */
     arrowStyle: PropType<StyleValue>;
-}>>, {
+}>> & Readonly<{}>, {
     disabled: boolean;
     bordered: boolean;
     checked: boolean;
     arrow: boolean;
-}, {}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};