@maxtropy/v-components 0.1.12-beta.4 → 0.1.12-beta.6

package/es/common/request.d.ts

@@ -0,0 +1,30 @@
+import { ResponseCodeError } from './fetch';
+import 'element-plus/es/components/message-box/style/css';
+interface ErrorHandler {
+    (err: any): boolean;
+}
+export type PromiseWithErrorHandler<T> = Promise<T> & ErrorHandlerReceiver<T>;
+interface ErrorHandlerReceiver<T> {
+    onError(handler: ErrorHandler): PromiseWithErrorHandler<T>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+}
+export declare function defaultErrorHandling(err: any): boolean;
+export declare class ResponseError extends Error {
+    readonly cause: ResponseCodeError;
+    readonly error?: string;
+    readonly errorCode?: string;
+    readonly message: string;
+    readonly path?: string;
+    readonly status?: string;
+    readonly timestamp?: string;
+    constructor(cause: ResponseCodeError);
+}
+interface DefaultErrorHandler {
+    (err: any): boolean;
+}
+interface fetchConfigProps {
+    handler: DefaultErrorHandler;
+}
+export declare const createFetchInstance: (defaultConfig?: fetchConfigProps) => <T>(input: RequestInfo, init?: RequestInit) => PromiseWithErrorHandler<T>;
+declare const fetchInstance: <T>(input: RequestInfo, init?: RequestInit) => PromiseWithErrorHandler<T>;
+export { fetchInstance as fetch };

package/es/common/request.js

@@ -0,0 +1,107 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { ResponseCodeError, fetch as fetch$1 } from "./fetch";
+import "element-plus/es/components/message-box/style/css";
+import { ElMessage } from "element-plus";
+import "element-plus/es/components/message/style/css";
+async function fetch(input, init) {
+  try {
+    return await fetch$1(input, init);
+  } catch (e) {
+    if (e instanceof ResponseCodeError) {
+      throw new ResponseError(e);
+    } else {
+      throw e;
+    }
+  }
+}
+function defaultErrorHandling(err) {
+  let rce;
+  let defaultMessage = "未知错误！ 请联系管理员。";
+  if (err instanceof ResponseCodeError) {
+    rce = err;
+  } else if (err instanceof ResponseError) {
+    rce = err.cause;
+    defaultMessage = err.message || err.cause.errorMessage || defaultMessage;
+  }
+  if (rce) {
+    switch (rce.status) {
+      case 400:
+        ElMessage({
+          message: defaultMessage,
+          type: "error"
+        });
+        return true;
+      case 500:
+        ElMessage({
+          message: defaultMessage,
+          type: "error"
+        });
+        return true;
+    }
+  }
+  return false;
+}
+class ResponseError extends Error {
+  constructor(cause) {
+    var _a, _b, _c, _d, _e, _f;
+    super();
+    __publicField(this, "cause");
+    __publicField(this, "error");
+    __publicField(this, "errorCode");
+    __publicField(this, "message");
+    __publicField(this, "path");
+    __publicField(this, "status");
+    __publicField(this, "timestamp");
+    this.cause = cause;
+    this.error = (_a = cause == null ? void 0 : cause.body) == null ? void 0 : _a.error;
+    this.errorCode = (_b = cause == null ? void 0 : cause.body) == null ? void 0 : _b.error_code;
+    this.message = (_c = cause == null ? void 0 : cause.body) == null ? void 0 : _c.message;
+    this.path = (_d = cause == null ? void 0 : cause.body) == null ? void 0 : _d.path;
+    this.status = (_e = cause == null ? void 0 : cause.body) == null ? void 0 : _e.status;
+    this.timestamp = (_f = cause == null ? void 0 : cause.body) == null ? void 0 : _f.timestamp;
+  }
+}
+const createFetchInstance = (defaultConfig) => {
+  const { handler = defaultErrorHandling } = defaultConfig ?? {};
+  return function fetchWithDefaultErrorHandling(input, init) {
+    let errorHandler;
+    let callThen = true;
+    const result = fetch(input, init).catch((e) => {
+      if (errorHandler) {
+        callThen = !errorHandler(e);
+      } else {
+        callThen = !handler(e);
+      }
+      if (callThen) {
+        throw e;
+      }
+    });
+    const mergedResult = result;
+    mergedResult.onError = (handler2) => {
+      errorHandler = handler2;
+      return mergedResult;
+    };
+    const _then = mergedResult.then;
+    mergedResult.then = (onfulfilled, onrejected) => {
+      const fulfilled = (...args) => {
+        if (callThen) {
+          return onfulfilled(...args);
+        }
+      };
+      return _then.apply(mergedResult, [fulfilled, onrejected]);
+    };
+    return mergedResult;
+  };
+};
+const fetchInstance = /* @__PURE__ */ createFetchInstance();
+export {
+  ResponseError,
+  createFetchInstance,
+  defaultErrorHandling,
+  fetchInstance as fetch
+};

package/es/common/subject.d.ts

@@ -0,0 +1,20 @@
+import { Subscription } from 'rxjs';
+export interface ISubjectHolder<T> {
+    subscribe(callback: (data?: T) => void): Subscription;
+    current(): T | undefined;
+    resetData(): void;
+    refreshData(callback?: () => void): void;
+}
+export declare class SubjectHolder<T> implements ISubjectHolder<T> {
+    private readonly subject;
+    private data?;
+    private asyncGetData?;
+    private sending;
+    constructor(asyncGetData?: () => Promise<T>);
+    subscribe(callback: (data?: T) => void): Subscription;
+    private getData;
+    resetData(): void;
+    refreshData(callback?: () => void): void;
+    current(): T | undefined;
+}
+export declare function lazyHolderSingletonGetter<T>(supplier: () => ISubjectHolder<T>): () => ISubjectHolder<T>;

package/es/common/subject.js

@@ -0,0 +1,62 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { BehaviorSubject } from "rxjs";
+class SubjectHolder {
+  constructor(asyncGetData) {
+    __publicField(this, "subject", new BehaviorSubject(void 0));
+    __publicField(this, "data");
+    __publicField(this, "asyncGetData");
+    __publicField(this, "sending", false);
+    if (asyncGetData) {
+      this.asyncGetData = asyncGetData;
+    }
+    this.subscribe((data) => {
+      this.data = data;
+    });
+    this.getData();
+  }
+  subscribe(callback) {
+    return this.subject.subscribe(callback);
+  }
+  async getData(callback) {
+    if (this.sending)
+      return;
+    if (this.asyncGetData) {
+      this.sending = true;
+      try {
+        const res = await this.asyncGetData();
+        this.subject.next(res);
+        callback && callback();
+      } catch (e) {
+        console.error(e);
+      }
+      this.sending = false;
+    }
+  }
+  resetData() {
+    this.subject.next(void 0);
+  }
+  refreshData(callback) {
+    this.getData(callback);
+  }
+  current() {
+    return this.data;
+  }
+}
+function lazyHolderSingletonGetter(supplier) {
+  let instance;
+  return () => {
+    if (!instance) {
+      instance = supplier();
+    }
+    return instance;
+  };
+}
+export {
+  SubjectHolder,
+  lazyHolderSingletonGetter
+};

package/es/components/alert/MxAlert.css

@@ -0,0 +1,47 @@
+.mx-alert[data-v-3f2a0ebe] {
+  padding: 9px 16px;
+  border: 1px solid rgba(74, 144, 226, 0.5);
+}
+.mx-alert .el-alert__icon[data-v-3f2a0ebe] {
+  font-size: 16px;
+}
+.mx-alert[data-v-3f2a0ebe] .el-alert__content {
+  line-height: 22px;
+  padding: 0;
+}
+.mx-alert[data-v-3f2a0ebe] .el-alert__content .el-alert__title {
+  --el-alert-title-font-size: 14px;
+  line-height: 22px;
+  display: flex;
+}
+.mx-alert[data-v-3f2a0ebe] .el-alert__content .el-icon {
+  margin-right: 8px;
+  height: 22px;
+}
+.mx-alert[data-v-3f2a0ebe] .el-alert__content .el-alert__description {
+  margin-left: 24px;
+}
+.mx-alert[data-v-3f2a0ebe] .el-alert__close-btn {
+  --el-alert-close-font-size: 12px;
+  top: 14px;
+  right: 16px;
+}
+.mx-alert.el-alert--success[data-v-3f2a0ebe] {
+  --el-color-success: #52c41a;
+  --el-alert-bg-color: rgba(82, 196, 26, 0.1);
+  border-color: rgba(82, 196, 26, 0.5);
+}
+.mx-alert.el-alert--error[data-v-3f2a0ebe] {
+  --el-color-error: #e64242;
+  --el-alert-bg-color: rgba(230, 66, 66, 0.1);
+  border-color: rgba(230, 66, 66, 0.5);
+}
+.mx-alert.el-alert--info[data-v-3f2a0ebe] {
+  --el-color-info: #4a90e2;
+  --el-alert-bg-color: rgba(74, 144, 226, 0.1);
+}
+.mx-alert.el-alert--warning[data-v-3f2a0ebe] {
+  --el-color-info: #faad14;
+  --el-alert-bg-color: rgba(250, 173, 20, 0.1);
+  border-color: rgba(250, 173, 20, 0.5);
+}

package/es/components/alert/MxAlert.vue.d.ts

@@ -0,0 +1,63 @@
+export declare const TypeComponentsMap: {
+    success: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+    warning: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+    error: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+    info: import("vue").Raw<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>>;
+};
+export declare const keysOf: <T extends object>(object: T) => string[];
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    type: {
+        type: StringConstructor;
+        values: string[];
+        default: string;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    showIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    closable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    closeText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    center: BooleanConstructor;
+    effect: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "light" | "dark", unknown, "light", boolean>;
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    type: {
+        type: StringConstructor;
+        values: string[];
+        default: string;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    showIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    description: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    closable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    closeText: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    center: BooleanConstructor;
+    effect: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "light" | "dark", unknown, "light", boolean>;
+}>>, {
+    title: string;
+    type: string;
+    showIcon: boolean;
+    description: string;
+    closable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    closeText: string;
+    center: boolean;
+    effect: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "light" | "dark", unknown>;
+}, {}>, Partial<Record<NonNullable<string | number>, (_: {}) => any>> & {
+    title?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/components/alert/MxAlert.vue.js

@@ -0,0 +1,82 @@
+import { markRaw, defineComponent, computed, resolveComponent, openBlock, createBlock, mergeProps, createSlots, withCtx, resolveDynamicComponent, createCommentVNode, renderSlot, createTextVNode, toDisplayString, renderList } from "vue";
+import { SuccessFilled, WarningFilled, CircleCloseFilled } from "@element-plus/icons-vue";
+import { alertProps } from "element-plus";
+import InfoSvg from "../../assets/svg/InfoSvg.vue";
+const TypeComponentsMap = {
+  success: SuccessFilled,
+  warning: WarningFilled,
+  error: CircleCloseFilled,
+  info: markRaw(InfoSvg)
+};
+const keysOf = (object) => Object.keys(object);
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MxAlert",
+  props: {
+    ...alertProps,
+    type: {
+      type: String,
+      values: keysOf(TypeComponentsMap),
+      default: "info"
+    },
+    title: {
+      type: String,
+      default: ""
+    },
+    showIcon: {
+      type: Boolean,
+      default: true
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const iconComponent = computed(() => TypeComponentsMap[props.type]);
+    return (_ctx, _cache) => {
+      const _component_el_icon = resolveComponent("el-icon");
+      const _component_ElAlert = resolveComponent("ElAlert");
+      return openBlock(), createBlock(_component_ElAlert, mergeProps(props, {
+        class: "mx-alert",
+        closable: false,
+        "show-icon": false
+      }), createSlots({
+        title: withCtx(() => [
+          __props.showIcon && iconComponent.value ? (openBlock(), createBlock(_component_el_icon, {
+            key: 0,
+            size: 16
+          }, {
+            default: withCtx(() => [
+              (openBlock(), createBlock(resolveDynamicComponent(iconComponent.value)))
+            ]),
+            _: 1
+          })) : createCommentVNode("", true),
+          renderSlot(_ctx.$slots, "title", {}, () => [
+            createTextVNode(toDisplayString(__props.title), 1)
+          ], true)
+        ]),
+        _: 2
+      }, [
+        renderList(_ctx.$slots, (item, key, index) => {
+          return {
+            name: key,
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, key, {}, void 0, true)
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const MxAlert_vue_vue_type_style_index_0_scoped_3f2a0ebe_lang = "";
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const MxAlert = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-3f2a0ebe"]]);
+export {
+  TypeComponentsMap,
+  MxAlert as default,
+  keysOf
+};

package/es/components/alert/index.d.ts

@@ -0,0 +1,7 @@
+import MxAlert from './MxAlert.vue';
+declare module 'vue' {
+    interface GlobalComponents {
+        MxAlert: typeof MxAlert;
+    }
+}
+export default MxAlert;

package/es/components/alert/index.js

@@ -0,0 +1,8 @@
+import MxAlert from "./MxAlert.vue";
+import { default as default2 } from "./MxAlert.vue";
+MxAlert.install = (app) => {
+  app.component(MxAlert.__name, MxAlert);
+};
+export {
+  default2 as default
+};

package/es/components/authorizedpermission/AuthorizedPermission.css

@@ -0,0 +1,14 @@
+.not-authorized[data-v-0e210937] {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  color: white;
+}
+.not-authorized .img[data-v-0e210937] {
+  width: 80px;
+  height: 80px;
+  margin-bottom: 16px;
+}

package/es/components/authorizedpermission/AuthorizedPermission.vue.d.ts

@@ -0,0 +1,10 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>, {
+    default?(_: {}): any;
+    error?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/components/authorizedpermission/AuthorizedPermission.vue.js

@@ -0,0 +1,51 @@
+import { defineComponent, ref, computed, renderSlot, openBlock, createElementBlock, Fragment, createElementVNode, unref, createCommentVNode, pushScopeId, popScopeId } from "vue";
+import { useRoute } from "vue-router";
+import { useIntegratedAuthorityList } from "../../utils/hooks";
+import notAuthorizedImg from "../../assets/images/notAuthorized.png";
+const _withScopeId = (n) => (pushScopeId("data-v-0e210937"), n = n(), popScopeId(), n);
+const _hoisted_1 = {
+  key: 0,
+  class: "not-authorized"
+};
+const _hoisted_2 = ["src"];
+const _hoisted_3 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("div", null, "您没有本页面的操作权限，请联系系统管理员，为您开通对应权限。", -1));
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "AuthorizedPermission",
+  setup(__props) {
+    const route = useRoute();
+    const authorityList = ref([]);
+    useIntegratedAuthorityList((val) => {
+      authorityList.value = val || [];
+    });
+    const hasPermission = computed(() => {
+      var _a, _b;
+      if (!((_a = route == null ? void 0 : route.meta) == null ? void 0 : _a.permission))
+        return false;
+      return authorityList.value.includes((_b = route == null ? void 0 : route.meta) == null ? void 0 : _b.permission);
+    });
+    return (_ctx, _cache) => {
+      return hasPermission.value ? renderSlot(_ctx.$slots, "default", { key: 0 }, void 0, true) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+        renderSlot(_ctx.$slots, "error", {}, void 0, true),
+        !_ctx.$slots.error ? (openBlock(), createElementBlock("div", _hoisted_1, [
+          createElementVNode("img", {
+            src: unref(notAuthorizedImg),
+            class: "img"
+          }, null, 8, _hoisted_2),
+          _hoisted_3
+        ])) : createCommentVNode("", true)
+      ], 64));
+    };
+  }
+});
+const AuthorizedPermission_vue_vue_type_style_index_0_scoped_0e210937_lang = "";
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const AuthorizedPermission = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-0e210937"]]);
+export {
+  AuthorizedPermission as default
+};

package/es/components/authorizedpermission/index.d.ts

@@ -0,0 +1,7 @@
+import AuthorizedPermission from './AuthorizedPermission.vue';
+declare module 'vue' {
+    interface GlobalComponents {
+        AuthorizedPermission: typeof AuthorizedPermission;
+    }
+}
+export default AuthorizedPermission;

package/es/components/authorizedpermission/index.js

@@ -0,0 +1,8 @@
+import AuthorizedPermission from "./AuthorizedPermission.vue";
+import { default as default2 } from "./AuthorizedPermission.vue";
+AuthorizedPermission.install = (app) => {
+  app.component(AuthorizedPermission.__name, AuthorizedPermission);
+};
+export {
+  default2 as default
+};

package/es/components/basiclayout/BasicLayout.css

@@ -0,0 +1,44 @@
+.maxtropy-basic-layout {
+  min-width: 1366px;
+  min-height: 768px;
+}
+.maxtropy-basic-layout .header-wrapper {
+  width: 100%;
+  height: 50px;
+  display: flex;
+  padding: 0 10px 0 5px;
+  align-items: center;
+  flex-direction: row;
+  background-color: #1b1b1b;
+  border-bottom: 2px solid rgba(0, 0, 0, 0);
+  border-image: linear-gradient(to left, transparent, #0277bd 45%, #2cc4f9, #0277bd 55%, transparent);
+  border-image-slice: 1;
+}
+.maxtropy-basic-layout .divider {
+  border-left: 1px solid rgba(255, 255, 255, 0.12);
+}
+.maxtropy-basic-layout .header-left {
+  display: flex;
+  align-items: center;
+}
+.maxtropy-basic-layout .middle {
+  flex: 1 1;
+  min-width: 0;
+}
+.maxtropy-basic-layout .header-right {
+  display: flex;
+  align-items: center;
+  gap: 3px;
+}
+.maxtropy-basic-layout .content-wrapper {
+  display: flex;
+  justify-content: flex-start;
+  height: calc(100vh - 50px);
+}
+.maxtropy-basic-layout .page-content {
+  width: 100%;
+  padding: 8px 13px;
+  position: relative;
+  background-color: #29292c;
+  overflow-y: auto;
+}

package/es/components/basiclayout/BasicLayout.vue.d.ts

@@ -0,0 +1,45 @@
+import { Router } from 'vue-router';
+import { MenuItem } from '../../common/entity';
+interface Props {
+    customClass?: string;
+    devMenu?: MenuItem;
+    router: Router;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    customClass: string;
+    devMenu: undefined;
+    router: () => Router;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    customClass: string;
+    devMenu: undefined;
+    router: () => Router;
+}>>>, {
+    customClass: string;
+    devMenu: MenuItem;
+    router: Router;
+}, {}>, {
+    "router-view"?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};