@maas/vue-equipment 1.0.0-beta.4 → 1.0.0-beta.41

package/dist/plugins/MagicEmitter/src/types/index.d.ts

@@ -4,6 +4,7 @@ import type { DraggableEvents } from '../../../MagicDraggable/src/types/index.js
 import type { DrawerEvents } from '../../../MagicDrawer/src/types/index.js';
 import type { ModalEvents } from '../../../MagicModal/src/types/index.js';
 import type { MenuEvents } from '../../../MagicMenu/src/types/index.js';
+import type { PlayerEvents } from '../../../MagicPlayer/src/types/index.js';
 import type { ScrollEvents } from '../../../MagicScroll/src/types/index.js';
 import type { ToastEvents } from '../../../MagicToast/src/types/index.js';
 type MergeTypes<T, U> = {
@@ -17,6 +18,7 @@ export type MagicEmitterEvents = Merge<[
     DrawerEvents,
     ModalEvents,
     MenuEvents,
+    PlayerEvents,
     ScrollEvents,
     ToastEvents
 ]>;

package/dist/plugins/MagicError/index.d.ts

@@ -0,0 +1,5 @@
+import { useMagicError } from './src/composables/useMagicError.js';
+import { MagicError } from './src/class/MagicError.js';
+import type { UseMagicErrorReturn } from './src/composables/useMagicError.js';
+export { useMagicError, MagicError };
+export type { UseMagicErrorReturn };

package/dist/plugins/MagicError/index.mjs

@@ -0,0 +1,3 @@
+import { useMagicError } from "./src/composables/useMagicError.mjs";
+import { MagicError } from "./src/class/MagicError.mjs";
+export { useMagicError, MagicError };

package/dist/plugins/MagicError/nuxt.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/schema").NuxtModule<import("nuxt/schema").ModuleOptions, import("nuxt/schema").ModuleOptions, false>;
+export default _default;

package/dist/plugins/MagicError/nuxt.mjs

@@ -0,0 +1,12 @@
+import { defineNuxtModule, addImports } from "@nuxt/kit";
+export default defineNuxtModule({
+  meta: {
+    name: "@maas/vue-equipment/nuxt/MagicError"
+  },
+  setup() {
+    addImports({
+      from: "@maas/vue-equipment/plugins/MagicError",
+      name: "useMagicError"
+    });
+  }
+});

package/dist/plugins/MagicError/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@maas/magic-error",
+  "version": "0.0.0",
+  "description": "Vue composable for centralized error handling with custom error classes",
+  "keywords": [
+    "vue",
+    "composable",
+    "error",
+    "error-handling",
+    "typescript"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "build:types": "tsup --dts-only",
+    "dev": "tsup --watch",
+    "lint": "eslint . --ext .vue,.js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --fix --ignore-path .gitignore",
+    "test": "vitest",
+    "test:coverage": "vitest --coverage"
+  },
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "devDependencies": {
+    "@vue/tsconfig": "^0.8.1"
+  }
+}

package/dist/plugins/MagicError/src/class/MagicError.d.ts

@@ -0,0 +1,6 @@
+export declare class MagicError extends Error {
+    readonly errorCode: string | number;
+    readonly timestamp: number;
+    readonly source: string;
+    constructor(message: string, errorCode: string | number, source: string, options?: ErrorOptions);
+}

package/dist/plugins/MagicError/src/class/MagicError.mjs

@@ -0,0 +1,15 @@
+export class MagicError extends Error {
+  errorCode;
+  timestamp;
+  source;
+  constructor(message, errorCode, source, options) {
+    super(message, options);
+    this.name = "MagicError";
+    this.errorCode = errorCode;
+    this.timestamp = Date.now();
+    this.source = source;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, MagicError);
+    }
+  }
+}

package/dist/plugins/MagicError/src/composables/useMagicError.d.ts

@@ -0,0 +1,18 @@
+import { MagicError } from '../class/MagicError.js';
+export interface UseMagicErrorArgs {
+    prefix?: string;
+    source?: string;
+}
+export interface ThrowErrorArgs {
+    message: string;
+    errorCode: string | number;
+    cause?: unknown;
+}
+export interface UseMagicErrorReturn {
+    assert<T>(value: T, args: ThrowErrorArgs): asserts value is NonNullable<T>;
+    throwError(args: ThrowErrorArgs): never;
+    logError(message: string): void;
+    logWarning(message: string): void;
+    MagicError: typeof MagicError;
+}
+export declare function useMagicError(args?: UseMagicErrorArgs): UseMagicErrorReturn;

package/dist/plugins/MagicError/src/composables/useMagicError.mjs

@@ -0,0 +1,31 @@
+import { MagicError } from "../class/MagicError.mjs";
+export function useMagicError(args = {}) {
+  const { prefix = "MagicError", source = "vue-equipment" } = args;
+  function logError(message) {
+    console.error(`[${prefix}]:`, message);
+  }
+  function logWarning(message) {
+    console.warn(`[${prefix}]:`, message);
+  }
+  function throwError(args2) {
+    const { message, errorCode, cause } = args2;
+    const mappedMessage = `[${prefix}]: ${message}`;
+    const error = new MagicError(mappedMessage, errorCode, source, {
+      cause
+    });
+    logError(message);
+    throw error;
+  }
+  function assert(value, args2) {
+    if (value === void 0 || value === null) {
+      throwError(args2);
+    }
+  }
+  return {
+    assert,
+    throwError,
+    logError,
+    logWarning,
+    MagicError
+  };
+}

package/dist/plugins/MagicMarquee/nuxt.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("@nuxt/schema").NuxtModule<import("@nuxt/schema").ModuleOptions, import("@nuxt/schema").ModuleOptions, false>;
+declare const _default: import("nuxt/schema").NuxtModule<import("nuxt/schema").ModuleOptions, import("nuxt/schema").ModuleOptions, false>;
 export default _default;

package/dist/plugins/MagicMarquee/src/components/MagicMarquee.d.vue.ts

@@ -0,0 +1,21 @@
+import { type MaybeRef } from 'vue';
+import type { MagicMarqueeOptions } from '../types/index.js';
+interface MagicMarqueeProps {
+    id: MaybeRef<string>;
+    options?: MagicMarqueeOptions;
+}
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<MagicMarqueeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicMarqueeProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/plugins/MagicMarquee/src/components/MagicMarquee.vue

@@ -1,77 +1,43 @@
-<script>
-import { defineComponent as _defineComponent } from "vue";
-import { renderSlot as _renderSlot, createElementVNode as _createElementVNode, unref as _unref, renderList as _renderList, Fragment as _Fragment, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
-const _hoisted_1 = { class: "magic-marquee__track" };
-import { ref, onMounted, onBeforeUnmount } from "vue";
+<template>
+  <div ref="parent" class="magic-marquee">
+    <div class="magic-marquee__track">
+      <div ref="child" class="magic-marquee__content">
+        <slot />
+      </div>
+      <div
+        v-for="duplicate in duplicates"
+        :key="duplicate"
+        class="magic-marquee__content"
+        :aria-hidden="true"
+      >
+        <slot />
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { useTemplateRef, onMounted, onBeforeUnmount } from "vue";
 import { useMarqueeApi } from "../composables/private/useMarqueeApi";
 import { useMarqueeState } from "../composables/private/useMarqueeState";
-export default /* @__PURE__ */ _defineComponent({
-  __name: "MagicMarquee",
-  props: {
-    id: { type: null, required: true },
-    options: { type: Object, required: false }
-  },
-  setup(__props) {
-    const { deleteState, initializeState } = useMarqueeState(__props.id);
-    initializeState(__props.options);
-    const parentRef = ref(void 0);
-    const childRef = ref(void 0);
-    const { duplicates, initialize } = useMarqueeApi({
-      child: childRef,
-      parent: parentRef,
-      instanceId: __props.id
-    });
-    onMounted(() => {
-      initialize();
-    });
-    onBeforeUnmount(() => {
-      deleteState();
-    });
-    return (_ctx, _cache) => {
-      return _openBlock(), _createElementBlock(
-        "div",
-        {
-          ref_key: "parentRef",
-          ref: parentRef,
-          class: "magic-marquee"
-        },
-        [
-          _createElementVNode("div", _hoisted_1, [
-            _createElementVNode(
-              "div",
-              {
-                ref_key: "childRef",
-                ref: childRef,
-                class: "magic-marquee__content"
-              },
-              [
-                _renderSlot(_ctx.$slots, "default")
-              ],
-              512
-              /* NEED_PATCH */
-            ),
-            (_openBlock(true), _createElementBlock(
-              _Fragment,
-              null,
-              _renderList(_unref(duplicates), (duplicate) => {
-                return _openBlock(), _createElementBlock("div", {
-                  key: duplicate,
-                  class: "magic-marquee__content",
-                  "aria-hidden": true
-                }, [
-                  _renderSlot(_ctx.$slots, "default")
-                ]);
-              }),
-              128
-              /* KEYED_FRAGMENT */
-            ))
-          ])
-        ],
-        512
-        /* NEED_PATCH */
-      );
-    };
-  }
+const { id, options } = defineProps({
+  id: { type: null, required: true },
+  options: { type: Object, required: false }
+});
+const { deleteState, initializeState } = useMarqueeState(id);
+initializeState(options);
+const parentRef = useTemplateRef("parent");
+const childRef = useTemplateRef("child");
+const { duplicates, initialize } = useMarqueeApi({
+  child: childRef,
+  parent: parentRef,
+  instanceId: id
+});
+onMounted(() => {
+  initialize();
+});
+onBeforeUnmount(() => {
+  deleteState();
 });
 </script>
 

package/dist/plugins/MagicMarquee/src/components/MagicMarquee.vue.d.ts

@@ -4,32 +4,17 @@ interface MagicMarqueeProps {
     id: MaybeRef<string>;
     options?: MagicMarqueeOptions;
 }
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {}): any;
-        default?(_: {}): any;
-    };
-    refs: {
-        parentRef: HTMLDivElement;
-        childRef: HTMLDivElement;
-    };
-    rootEl: HTMLDivElement;
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_3) => any;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicMarqueeProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicMarqueeProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+declare const __VLS_base: import("vue").DefineComponent<MagicMarqueeProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicMarqueeProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<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_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/plugins/MagicMarquee/src/composables/private/useMarqueeApi.d.ts

@@ -5,7 +5,7 @@ export type UseMarqueeApiParams = {
     instanceId: MaybeRef<string>;
 };
 export declare function useMarqueeApi({ child, parent, instanceId, }: UseMarqueeApiParams): {
-    duplicates: import("vue").Ref<number, number>;
+    duplicates: import("vue").ShallowRef<number, number>;
     play: () => void;
     pause: () => void;
     initialize: () => Promise<void>;

package/dist/plugins/MagicMarquee/src/composables/private/useMarqueeApi.mjs

@@ -1,4 +1,10 @@
-import { ref, computed, nextTick, watch, toValue } from "vue";
+import {
+  shallowRef,
+  computed,
+  nextTick,
+  watch,
+  toValue
+} from "vue";
 import { useElementBounding, useElementSize, useThrottleFn } from "@vueuse/core";
 import { useMarqueeState } from "./useMarqueeState.mjs";
 export function useMarqueeApi({
@@ -8,7 +14,7 @@ export function useMarqueeApi({
 }) {
   const { initializeState } = useMarqueeState(instanceId);
   const state = initializeState();
-  const duplicates = ref(1);
+  const duplicates = shallowRef(1);
   const childRect = useElementBounding(child);
   const parentRect = useElementBounding(parent);
   const { width } = useElementSize(parent);

package/dist/plugins/MagicMarquee/src/composables/useMagicMarquee.d.ts

@@ -1,6 +1,6 @@
 import { type MaybeRef } from 'vue';
 export declare function useMagicMarquee(id: MaybeRef<string>): {
-    state: import("../types").MarqueeState;
+    state: import("../types/index.js").MarqueeState;
     isPlaying: import("vue").ComputedRef<boolean>;
     play: () => void;
     pause: () => void;

package/dist/plugins/MagicMenu/nuxt.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("@nuxt/schema").NuxtModule<import("@nuxt/schema").ModuleOptions, import("@nuxt/schema").ModuleOptions, false>;
+declare const _default: import("nuxt/schema").NuxtModule<import("nuxt/schema").ModuleOptions, import("nuxt/schema").ModuleOptions, false>;
 export default _default;

package/dist/plugins/MagicMenu/src/components/MagicMenuChannel.d.vue.ts

@@ -0,0 +1,17 @@
+interface MagicMenuChannelProps {
+    id: string;
+    transition?: string;
+}
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<MagicMenuChannelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicMenuChannelProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/plugins/MagicMenu/src/components/MagicMenuChannel.vue

@@ -1,8 +1,21 @@
-<script>
-import { defineComponent as _defineComponent } from "vue";
-import { unref as _unref, renderSlot as _renderSlot, openBlock as _openBlock, createElementBlock as _createElementBlock, createCommentVNode as _createCommentVNode, Transition as _Transition, withCtx as _withCtx, createBlock as _createBlock } from "vue";
-const _hoisted_1 = ["id", "data-initialized", "data-id"];
+<template>
+  <transition :name="mappedTransition">
+    <div
+      v-if="channel.active"
+      class="magic-menu-channel"
+      :data-initialized="state.active"
+      :data-id="mappedId"
+    >
+      <slot />
+    </div>
+  </transition>
+</template>
+
+<script setup>
 import { computed, inject, provide } from "vue";
+import {
+  useMagicError
+} from "@maas/vue-equipment/plugins/MagicError";
 import { useMenuChannel } from "../composables/private/useMenuChannel";
 import {
   MagicMenuInstanceId,
@@ -12,65 +25,52 @@ import {
   MagicMenuChannelActive
 } from "../symbols";
 import { useMenuState } from "../composables/private/useMenuState";
-export default /* @__PURE__ */ _defineComponent({
-  __name: "MagicMenuChannel",
-  props: {
-    id: { type: String, required: true },
-    transition: { type: String, required: false }
-  },
-  setup(__props) {
-    const instanceId = inject(MagicMenuInstanceId, void 0);
-    const viewId = inject(MagicMenuViewId, void 0);
-    const contentId = inject(MagicMenuContentId, void 0);
-    if (!instanceId) {
-      throw new Error("MagicMenuChannel must be nested inside MagicMenuProvider");
-    }
-    if (!viewId) {
-      throw new Error("MagicMenuChannel must be nested inside MagicMenuView");
-    }
-    if (!__props.id) {
-      throw new Error("MagicMenuChannel requires an id");
-    }
-    const { initializeState } = useMenuState(instanceId);
-    const state = initializeState();
-    if (!contentId) {
-      if (state.options.debug) {
-        console.warn("MagicMenuChannel is not nested inside MagicMenuContent");
-      }
-    }
-    const mappedId = computed(() => `magic-menu-channel-${__props.id}`);
-    const mappedActive = computed(() => channel.active);
-    const mappedTransition = computed(
-      () => __props.transition ?? state.options.transition.channel
+const { transition, id } = defineProps({
+  id: { type: String, required: true },
+  transition: { type: String, required: false }
+});
+const magicError = useMagicError({
+  prefix: "MagicMenu",
+  source: "MagicMenu"
+});
+const instanceId = inject(MagicMenuInstanceId, void 0);
+const viewId = inject(MagicMenuViewId, void 0);
+const contentId = inject(MagicMenuContentId, void 0);
+magicError.assert(instanceId, {
+  message: "MagicMenuChannel must be nested inside MagicMenuProvider",
+  errorCode: "missing_instance_id"
+});
+magicError.assert(viewId, {
+  message: "MagicMenuChannel must be nested inside MagicMenuView",
+  errorCode: "missing_view_id"
+});
+magicError.assert(id, {
+  message: "MagicMenuChannel requires an id",
+  errorCode: "id_required"
+});
+const { initializeState } = useMenuState(instanceId);
+const state = initializeState();
+if (!contentId) {
+  if (state.options.debug) {
+    magicError.logWarning(
+      "MagicMenuChannel is not nested inside MagicMenuContent"
     );
-    const { initializeChannel } = useMenuChannel({
-      instanceId,
-      viewId
-    });
-    const channel = initializeChannel({
-      id: mappedId.value
-    });
-    provide(MagicMenuChannelId, mappedId.value);
-    provide(MagicMenuChannelActive, mappedActive);
-    return (_ctx, _cache) => {
-      return _openBlock(), _createBlock(_Transition, { name: mappedTransition.value }, {
-        default: _withCtx(() => [
-          _unref(channel).active ? (_openBlock(), _createElementBlock("div", {
-            key: 0,
-            id: _ctx.id,
-            class: "magic-menu-channel",
-            "data-initialized": _unref(state).active,
-            "data-id": mappedId.value
-          }, [
-            _renderSlot(_ctx.$slots, "default")
-          ], 8, _hoisted_1)) : _createCommentVNode("v-if", true)
-        ]),
-        _: 3
-        /* FORWARDED */
-      }, 8, ["name"]);
-    };
   }
+}
+const mappedId = computed(() => `magic-menu-channel-${id}`);
+const mappedTransition = computed(
+  () => transition ?? state.options.transition.channel
+);
+const { initializeChannel } = useMenuChannel({
+  instanceId,
+  viewId
+});
+const channel = initializeChannel({
+  id: mappedId.value
 });
+const mappedActive = computed(() => channel.active);
+provide(MagicMenuChannelId, mappedId.value);
+provide(MagicMenuChannelActive, mappedActive);
 </script>
 
 <style>

package/dist/plugins/MagicMenu/src/components/MagicMenuChannel.vue.d.ts

@@ -2,28 +2,15 @@ interface MagicMenuChannelProps {
     id: string;
     transition?: string;
 }
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {}): any;
-    };
-    refs: {};
-    rootEl: any;
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicMenuChannelProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicMenuChannelProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+declare const __VLS_base: import("vue").DefineComponent<MagicMenuChannelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicMenuChannelProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<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_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/plugins/MagicMenu/src/components/MagicMenuContent.d.vue.ts

@@ -0,0 +1,25 @@
+import { type MaybeRef, type ComponentPublicInstance } from 'vue';
+import type { Middleware } from '@floating-ui/vue';
+import '@maas/vue-equipment/utils/css/keyframes/fade-in.css';
+import '@maas/vue-equipment/utils/css/keyframes/fade-out.css';
+interface MagicMenuContentProps {
+    arrow?: boolean | undefined;
+    middleware?: Middleware[];
+    transition?: string;
+    referenceEl?: MaybeRef<HTMLElement | ComponentPublicInstance>;
+}
+declare var __VLS_25: {}, __VLS_28: {};
+type __VLS_Slots = {} & {
+    arrow?: (props: typeof __VLS_25) => any;
+} & {
+    default?: (props: typeof __VLS_28) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<MagicMenuContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicMenuContentProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};