@eslamdevui/ui 3.2.0-beta.1

package/dist/runtime/composables/useResizable.d.ts

@@ -0,0 +1,27 @@
+import { type Ref } from 'vue';
+export type UseResizableProps = {
+    id?: string;
+    side?: 'left' | 'right';
+    minSize?: number;
+    maxSize?: number;
+    defaultSize?: number;
+    resizable?: boolean;
+    collapsible?: boolean;
+    collapsedSize?: number;
+    storage?: 'cookie' | 'local';
+    storageKey?: string;
+    persistent?: boolean;
+    unit?: '%' | 'rem' | 'px';
+};
+export type UseResizableReturn = {
+    el: Ref<HTMLElement | null>;
+    size: Ref<number>;
+    isDragging: Ref<boolean>;
+    isCollapsed: Ref<boolean>;
+    onMouseDown: (e: MouseEvent) => void;
+    onTouchStart: (e: TouchEvent) => void;
+    collapse: (value?: boolean) => void;
+};
+export declare const useResizable: (key: string, options?: Ref<UseResizableProps> | UseResizableProps, { collapsed }?: {
+    collapsed?: Ref<boolean>;
+}) => UseResizableReturn;

package/dist/runtime/composables/useResizable.js

@@ -0,0 +1,173 @@
+import {
+  ref,
+  computed,
+  unref,
+  isRef,
+  watch
+} from "vue";
+import { useStorage } from "@vueuse/core";
+import { useCookie } from "#imports";
+export const useResizable = (key, options = {}, { collapsed = ref(false) } = {}) => {
+  const el = ref(null);
+  const opts = computed(() => ({
+    id: "",
+    side: "left",
+    minSize: 0,
+    maxSize: 100,
+    defaultSize: 0,
+    storage: "cookie",
+    persistent: true,
+    collapsible: false,
+    collapsedSize: 0,
+    resizable: true,
+    unit: "%",
+    storageKey: "dashboard",
+    ...isRef(options) ? options.value : options
+  }));
+  const defaultStorageValue = {
+    size: opts.value.defaultSize,
+    collapsed: unref(collapsed) ?? false
+  };
+  const storageData = opts.value.persistent && (opts.value.resizable || opts.value.collapsible) ? opts.value.storage === "cookie" ? useCookie(key, { default: () => defaultStorageValue }) : useStorage(key, defaultStorageValue) : ref(defaultStorageValue);
+  const isCollapsed = computed({
+    get: () => storageData.value.collapsed,
+    set: (value) => {
+      if (!opts.value.collapsible) return;
+      if (isRef(collapsed)) {
+        collapsed.value = value;
+      }
+      storageData.value.collapsed = value;
+    }
+  });
+  const previousSize = ref(opts.value.defaultSize);
+  const size = computed({
+    get: () => storageData.value.size,
+    set: (value) => {
+      storageData.value.size = value;
+    }
+  });
+  const currentSize = computed(
+    () => isCollapsed.value ? opts.value.collapsedSize : size.value
+  );
+  const isDragging = ref(false);
+  const onMouseMove = (e, initialPos, initialSize) => {
+    if (!el.value || !opts.value.resizable) return;
+    const parentSize = el.value.parentElement?.offsetWidth || 1;
+    const delta = opts.value.side === "left" ? e.clientX - initialPos : initialPos - e.clientX;
+    const newSize = initialSize + delta;
+    let newValue;
+    switch (opts.value.unit) {
+      case "rem": {
+        const rootFontSize = Number.parseFloat(getComputedStyle(document.documentElement).fontSize);
+        newValue = newSize / rootFontSize;
+        break;
+      }
+      case "px":
+        newValue = newSize;
+        break;
+      default:
+        newValue = newSize / parentSize * 100;
+    }
+    if (opts.value.collapsible && newValue < opts.value.collapsedSize + 4) {
+      collapse(true);
+      return;
+    } else if (isCollapsed.value) {
+      collapse(false);
+    }
+    size.value = Math.min(opts.value.maxSize, Math.max(opts.value.minSize, newValue));
+  };
+  const onMouseDown = (e) => {
+    if (!el.value || !opts.value.resizable) return;
+    e.preventDefault();
+    e.stopPropagation();
+    const elWidth = el.value.getBoundingClientRect().width;
+    if (!elWidth) return;
+    const initialX = e.clientX;
+    const initialWidth = elWidth;
+    isDragging.value = true;
+    const handleMouseMove = (e2) => onMouseMove(e2, initialX, initialWidth);
+    const handleMouseUp = () => {
+      isDragging.value = false;
+      document.removeEventListener("mousemove", handleMouseMove);
+      document.removeEventListener("mouseup", handleMouseUp);
+    };
+    document.addEventListener("mousemove", handleMouseMove);
+    document.addEventListener("mouseup", handleMouseUp);
+  };
+  const onTouchMove = (e, initialPos, initialSize) => {
+    if (!el.value || !opts.value.resizable || !e.touches[0]) return;
+    const parentSize = el.value.parentElement?.offsetWidth || 1;
+    const delta = opts.value.side === "left" ? e.touches[0].clientX - initialPos : initialPos - e.touches[0].clientX;
+    const newSize = initialSize + delta;
+    let newValue;
+    switch (opts.value.unit) {
+      case "rem": {
+        const rootFontSize = Number.parseFloat(getComputedStyle(document.documentElement).fontSize);
+        newValue = newSize / rootFontSize;
+        break;
+      }
+      case "px":
+        newValue = newSize;
+        break;
+      default:
+        newValue = newSize / parentSize * 100;
+    }
+    if (opts.value.collapsible && newValue < opts.value.collapsedSize + 4) {
+      collapse(true);
+      return;
+    } else if (isCollapsed.value) {
+      collapse(false);
+    }
+    size.value = Math.min(opts.value.maxSize, Math.max(opts.value.minSize, newValue));
+  };
+  const onTouchStart = (e) => {
+    if (!el.value || !opts.value.resizable || !e.touches[0]) return;
+    e.preventDefault();
+    e.stopPropagation();
+    const elWidth = el.value.getBoundingClientRect().width;
+    if (!elWidth) return;
+    const initialX = e.touches[0].clientX;
+    const initialWidth = elWidth;
+    isDragging.value = true;
+    const handleTouchMove = (e2) => onTouchMove(e2, initialX, initialWidth);
+    const handleTouchEnd = () => {
+      isDragging.value = false;
+      document.removeEventListener("touchmove", handleTouchMove);
+      document.removeEventListener("touchend", handleTouchEnd);
+      document.removeEventListener("touchcancel", handleTouchEnd);
+    };
+    document.addEventListener("touchmove", handleTouchMove, { passive: false });
+    document.addEventListener("touchend", handleTouchEnd);
+    document.addEventListener("touchcancel", handleTouchEnd);
+  };
+  const collapse = (value) => {
+    if (!opts.value.collapsible) return;
+    const newCollapsed = value ?? !isCollapsed.value;
+    if (newCollapsed && !isCollapsed.value) {
+      previousSize.value = size.value;
+    } else if (!newCollapsed && isCollapsed.value) {
+      size.value = previousSize.value;
+    }
+    isCollapsed.value = newCollapsed;
+  };
+  if (isRef(collapsed) && storageData.value.collapsed) {
+    collapsed.value = storageData.value.collapsed;
+  }
+  if (isRef(collapsed)) {
+    watch(collapsed, (value) => {
+      if (!opts.value.collapsible) return;
+      if (storageData.value.collapsed !== value) {
+        storageData.value.collapsed = value;
+      }
+    });
+  }
+  return {
+    el,
+    size: currentSize,
+    isDragging,
+    isCollapsed,
+    onMouseDown,
+    onTouchStart,
+    collapse
+  };
+};

package/dist/runtime/composables/useScrollspy.d.ts

@@ -0,0 +1,6 @@
+import type { Ref } from 'vue';
+export declare function useScrollspy(): {
+    visibleHeadings: Ref<string[]>;
+    activeHeadings: Ref<string[]>;
+    updateHeadings: (headings: Element[]) => void;
+};

package/dist/runtime/composables/useScrollspy.js

@@ -0,0 +1,38 @@
+import { ref, watch, onBeforeMount, onBeforeUnmount } from "vue";
+export function useScrollspy() {
+  const observer = ref(null);
+  const visibleHeadings = ref([]);
+  const activeHeadings = ref([]);
+  function observerCallback(entries) {
+    entries.forEach((entry) => {
+      const id = entry.target.id;
+      if (!id) return;
+      if (entry.isIntersecting) {
+        if (!visibleHeadings.value.includes(id)) {
+          visibleHeadings.value = [...visibleHeadings.value, id];
+        }
+      } else {
+        visibleHeadings.value = visibleHeadings.value.filter((h) => h !== id);
+      }
+    });
+  }
+  function updateHeadings(headings) {
+    headings.forEach((heading) => {
+      observer.value?.observe(heading);
+    });
+  }
+  watch(visibleHeadings, (val, oldVal) => {
+    activeHeadings.value = val.length === 0 ? oldVal : val;
+  });
+  onBeforeMount(() => {
+    observer.value = new IntersectionObserver(observerCallback);
+  });
+  onBeforeUnmount(() => {
+    observer.value?.disconnect();
+  });
+  return {
+    visibleHeadings,
+    activeHeadings,
+    updateHeadings
+  };
+}

package/dist/runtime/composables/useToast.d.ts

@@ -0,0 +1,13 @@
+import type { ToastProps, ToastEmits } from '../types';
+import type { EmitsToProps } from '../types/utils';
+export interface Toast extends Omit<ToastProps, 'defaultOpen'>, EmitsToProps<ToastEmits> {
+    id: string | number;
+    onClick?: (toast: Toast) => void;
+}
+export declare function useToast(): {
+    toasts: import("vue").Ref<Toast[], Toast[]>;
+    add: (toast: Partial<Toast>) => Toast;
+    update: (id: string | number, toast: Omit<Partial<Toast>, "id">) => void;
+    remove: (id: string | number) => void;
+    clear: () => void;
+};

package/dist/runtime/composables/useToast.js

@@ -0,0 +1,62 @@
+import { ref, nextTick } from "vue";
+import { useState } from "#imports";
+export function useToast() {
+  const toasts = useState("toasts", () => []);
+  const maxToasts = 5;
+  const running = ref(false);
+  const queue = [];
+  const generateId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  async function processQueue() {
+    if (running.value || queue.length === 0) {
+      return;
+    }
+    running.value = true;
+    while (queue.length > 0) {
+      const toast = queue.shift();
+      await nextTick();
+      toasts.value = [...toasts.value, toast].slice(-maxToasts);
+    }
+    running.value = false;
+  }
+  function add(toast) {
+    const body = {
+      id: generateId(),
+      open: true,
+      ...toast
+    };
+    queue.push(body);
+    processQueue();
+    return body;
+  }
+  function update(id, toast) {
+    const index = toasts.value.findIndex((t) => t.id === id);
+    if (index !== -1) {
+      toasts.value[index] = {
+        ...toasts.value[index],
+        ...toast
+      };
+    }
+  }
+  function remove(id) {
+    const index = toasts.value.findIndex((t) => t.id === id);
+    if (index !== -1) {
+      toasts.value[index] = {
+        ...toasts.value[index],
+        open: false
+      };
+    }
+    setTimeout(() => {
+      toasts.value = toasts.value.filter((t) => t.id !== id);
+    }, 200);
+  }
+  function clear() {
+    toasts.value = [];
+  }
+  return {
+    toasts,
+    add,
+    update,
+    remove,
+    clear
+  };
+}

package/dist/runtime/index.css

@@ -0,0 +1 @@
+@import "#build/ui.css";@import "./keyframes.css";@variant light (&:where(.light, .light *));@variant dark (&:where(.dark, .dark *));@layer base{body{@apply antialiased text-default bg-default scheme-light dark:scheme-dark}.light,:root{--ui-text-dimmed:var(--ui-color-neutral-400);--ui-text-muted:var(--ui-color-neutral-500);--ui-text-toned:var(--ui-color-neutral-600);--ui-text:var(--ui-color-neutral-700);--ui-text-highlighted:var(--ui-color-neutral-900);--ui-text-inverted:var(--color-white);--ui-bg:var(--color-white);--ui-bg-muted:var(--ui-color-neutral-50);--ui-bg-elevated:var(--ui-color-neutral-100);--ui-bg-accented:var(--ui-color-neutral-200);--ui-bg-inverted:var(--ui-color-neutral-900);--ui-border:var(--ui-color-neutral-200);--ui-border-muted:var(--ui-color-neutral-200);--ui-border-accented:var(--ui-color-neutral-300);--ui-border-inverted:var(--ui-color-neutral-900);--ui-radius:0.25rem;--ui-container:var(--container-7xl)}.dark{--ui-text-dimmed:var(--ui-color-neutral-500);--ui-text-muted:var(--ui-color-neutral-400);--ui-text-toned:var(--ui-color-neutral-300);--ui-text:var(--ui-color-neutral-200);--ui-text-highlighted:var(--color-white);--ui-text-inverted:var(--ui-color-neutral-900);--ui-bg:var(--ui-color-neutral-900);--ui-bg-muted:var(--ui-color-neutral-800);--ui-bg-elevated:var(--ui-color-neutral-800);--ui-bg-accented:var(--ui-color-neutral-700);--ui-bg-inverted:var(--color-white);--ui-border:var(--ui-color-neutral-800);--ui-border-muted:var(--ui-color-neutral-700);--ui-border-accented:var(--ui-color-neutral-700);--ui-border-inverted:var(--color-white)}}

package/dist/runtime/inertia/components/Link.vue

@@ -0,0 +1,132 @@
+<script>
+import theme from "#build/ui/link";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { defu } from "defu";
+import { useForwardProps } from "reka-ui";
+import { reactiveOmit } from "@vueuse/core";
+import { usePage } from "@inertiajs/vue3";
+import { hasProtocol } from "ufo";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+import ULinkBase from "../../components/LinkBase.vue";
+defineOptions({ inheritAttrs: false });
+const props = defineProps({
+  as: { type: null, required: false, default: "button" },
+  type: { type: null, required: false, default: "button" },
+  disabled: { type: Boolean, required: false },
+  active: { type: Boolean, required: false, default: void 0 },
+  exact: { type: Boolean, required: false },
+  inactiveClass: { type: String, required: false, default: "" },
+  custom: { type: Boolean, required: false },
+  raw: { type: Boolean, required: false },
+  class: { type: null, required: false },
+  activeClass: { type: String, required: false, default: "" },
+  to: { type: String, required: false },
+  href: { type: String, required: false },
+  external: { type: Boolean, required: false },
+  target: { type: [String, Object, null], required: false },
+  ariaCurrentValue: { type: String, required: false },
+  data: { type: Object, required: false },
+  method: { type: String, required: false },
+  headers: { type: Object, required: false },
+  preserveScroll: { type: [Boolean, String, Function], required: false },
+  preserveState: { type: [Boolean, String, Function], required: false },
+  replace: { type: Boolean, required: false },
+  only: { type: Array, required: false },
+  except: { type: Array, required: false },
+  onCancelToken: { type: Function, required: false },
+  onBefore: { type: Function, required: false },
+  onStart: { type: Function, required: false },
+  onProgress: { type: Function, required: false },
+  onFinish: { type: Function, required: false },
+  onCancel: { type: Function, required: false },
+  onSuccess: { type: Function, required: false },
+  onError: { type: Function, required: false },
+  queryStringArrayFormat: { type: String, required: false },
+  async: { type: Boolean, required: false },
+  prefetch: { type: [Boolean, String, Array], required: false },
+  cacheFor: { type: [Number, String, Array], required: false }
+});
+defineSlots();
+const page = usePage();
+const appConfig = useAppConfig();
+const routerLinkProps = useForwardProps(reactiveOmit(props, "as", "type", "disabled", "active", "exact", "activeClass", "inactiveClass", "to", "href", "raw", "custom", "class"));
+const ui = computed(() => tv({
+  extend: tv(theme),
+  ...defu({
+    variants: {
+      active: {
+        true: props.activeClass,
+        false: props.inactiveClass
+      }
+    }
+  }, appConfig.ui?.link || {})
+}));
+const href = computed(() => props.to ?? props.href);
+const isExternal = computed(() => {
+  if (props.external) {
+    return true;
+  }
+  if (!href.value) {
+    return false;
+  }
+  return typeof href.value === "string" && hasProtocol(href.value, { acceptRelative: true });
+});
+const isLinkActive = computed(() => {
+  if (props.active !== void 0) {
+    return props.active;
+  }
+  if (!href.value) {
+    return false;
+  }
+  if (props.exact && page.url === href.value) {
+    return true;
+  }
+  if (!props.exact && page.url.startsWith(href.value)) {
+    return true;
+  }
+  return false;
+});
+const linkClass = computed(() => {
+  const active = isLinkActive.value;
+  if (props.raw) {
+    return [props.class, active ? props.activeClass : props.inactiveClass];
+  }
+  return ui.value({ class: props.class, active, disabled: props.disabled });
+});
+</script>
+
+<template>
+  <template v-if="custom">
+    <slot
+      v-bind="{
+  ...$attrs,
+  ...routerLinkProps,
+  as,
+  type,
+  disabled,
+  href,
+  active: isLinkActive,
+  isExternal
+}"
+    />
+  </template>
+  <ULinkBase
+    v-else
+    v-bind="{
+  ...$attrs,
+  ...routerLinkProps,
+  as,
+  type,
+  disabled,
+  href,
+  isExternal
+}"
+    :class="linkClass"
+  >
+    <slot :active="isLinkActive" />
+  </ULinkBase>
+</template>

package/dist/runtime/inertia/components/Link.vue.d.ts

@@ -0,0 +1,63 @@
+import type { ButtonHTMLAttributes } from 'vue';
+import type { InertiaLinkProps } from '@inertiajs/vue3';
+interface NuxtLinkProps extends Omit<InertiaLinkProps, 'href' | 'onClick'> {
+    activeClass?: string;
+    /**
+     * Route Location the link should navigate to when clicked on.
+     */
+    to?: string;
+    /**
+     * An alias for `to`. If used with `to`, `href` will be ignored
+     */
+    href?: NuxtLinkProps['to'];
+    /**
+     * Forces the link to be considered as external (true) or internal (false). This is helpful to handle edge-cases
+     */
+    external?: boolean;
+    /**
+     * Where to display the linked URL, as the name for a browsing context.
+     */
+    target?: '_blank' | '_parent' | '_self' | '_top' | (string & {}) | null;
+    ariaCurrentValue?: string;
+}
+export interface LinkProps extends NuxtLinkProps {
+    /**
+     * The element or component this component should render as when not a link.
+     * @defaultValue 'button'
+     */
+    as?: any;
+    /**
+     * The type of the button when not a link.
+     * @defaultValue 'button'
+     */
+    type?: ButtonHTMLAttributes['type'];
+    disabled?: boolean;
+    /** Force the link to be active independent of the current route. */
+    active?: boolean;
+    /** Will only be active if the current route is an exact match. */
+    exact?: boolean;
+    /** The class to apply when the link is inactive. */
+    inactiveClass?: string;
+    custom?: boolean;
+    /** When `true`, only styles from `class`, `activeClass`, and `inactiveClass` will be applied. */
+    raw?: boolean;
+    class?: any;
+}
+export interface LinkSlots {
+    default(props: {
+        active: boolean;
+    }): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {
+    type: "reset" | "submit" | "button";
+    as: any;
+    activeClass: string;
+    active: boolean;
+    inactiveClass: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/inertia/components/LinkBase.vue

@@ -0,0 +1,68 @@
+<script>
+
+</script>
+
+<script setup>
+import { Primitive } from "reka-ui";
+import { Link as InertiaLink } from "@inertiajs/vue3";
+defineOptions({ inheritAttrs: false });
+const props = defineProps({
+  as: { type: String, required: false, default: "button" },
+  type: { type: String, required: false, default: "button" },
+  disabled: { type: Boolean, required: false },
+  onClick: { type: [Function, Array], required: false },
+  href: { type: String, required: false },
+  target: { type: [String, Object, null], required: false },
+  active: { type: Boolean, required: false },
+  isExternal: { type: Boolean, required: false }
+});
+function onClickWrapper(e) {
+  if (props.disabled) {
+    e.stopPropagation();
+    e.preventDefault();
+    return;
+  }
+  if (props.onClick) {
+    for (const onClick of Array.isArray(props.onClick) ? props.onClick : [props.onClick]) {
+      onClick(e);
+    }
+  }
+}
+</script>
+
+<template>
+  <InertiaLink
+    v-if="!!href && !isExternal && !disabled"
+    :href="href"
+    v-bind="{
+  target: target || (isExternal ? '_blank' : void 0),
+  ...$attrs
+}"
+    @click="onClickWrapper"
+  >
+    <slot />
+  </InertiaLink>
+  <Primitive
+    v-else
+    v-bind="href ? {
+  'as': 'a',
+  'href': disabled ? void 0 : href,
+  'aria-disabled': disabled ? 'true' : void 0,
+  'role': disabled ? 'link' : void 0,
+  'tabindex': disabled ? -1 : void 0,
+  'target': target || (isExternal ? '_blank' : void 0),
+  ...$attrs
+} : as === 'button' ? {
+  as,
+  type,
+  disabled,
+  ...$attrs
+} : {
+  as,
+  ...$attrs
+}"
+    @click="onClickWrapper"
+  >
+    <slot />
+  </Primitive>
+</template>

package/dist/runtime/inertia/components/LinkBase.vue.d.ts

@@ -0,0 +1,25 @@
+import type { LinkProps } from '../../types';
+export interface LinkBaseProps {
+    as?: string;
+    type?: string;
+    disabled?: boolean;
+    onClick?: ((e: MouseEvent) => void | Promise<void>) | Array<((e: MouseEvent) => void | Promise<void>)>;
+    href?: string;
+    target?: LinkProps['target'];
+    active?: boolean;
+    isExternal?: boolean;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<LinkBaseProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkBaseProps> & Readonly<{}>, {
+    type: string;
+    as: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/inertia/stubs.d.ts

@@ -0,0 +1,43 @@
+import type { Ref } from 'vue';
+import type { NuxtApp } from '#app';
+export { useHead } from '@unhead/vue';
+export { useAppConfig } from '../vue/composables/useAppConfig';
+export { defineShortcuts } from '../composables/defineShortcuts';
+export { defineLocale } from '../composables/defineLocale';
+export { useLocale } from '../composables/useLocale';
+export declare const useRoute: () => {
+    fullPath: string;
+};
+export declare const useRouter: () => void;
+export declare const useColorMode: () => {
+    forced: boolean;
+    preference?: undefined;
+    readonly value?: undefined;
+} | {
+    preference: "system" | "light" | "dark";
+    readonly value: import("@vueuse/core").BasicColorMode;
+    forced: boolean;
+};
+export declare const useCookie: <T = string>(_name: string, _options?: Record<string, any>) => {
+    value: Ref<T, T>;
+    get: () => T;
+    set: () => void;
+    update: () => void;
+    refresh: () => Promise<Awaited<T>>;
+    remove: () => void;
+};
+export declare const useState: <T>(key: string, init: () => T) => Ref<T>;
+export declare function useNuxtApp(): {
+    isHydrating: boolean;
+    payload: {
+        serverRendered: boolean;
+    };
+    hooks: import("hookable").Hookable<Record<string, any>, string>;
+    hook: <NameT extends string>(name: NameT, function_: any, options?: {
+        allowDeprecated?: boolean;
+    }) => () => void;
+};
+export declare function useRuntimeHook(name: string, fn: (...args: any[]) => void): void;
+export declare function defineNuxtPlugin(plugin: (nuxtApp: NuxtApp) => void): {
+    install(app: import("vue").App<any>): void;
+};