@nuxt/ui 2.17.0 → 2.18.0

package/dist/runtime/components/overlays/Tooltip.vue.d.ts

@@ -1,9 +1,45 @@
 import type { PropType } from 'vue';
-import type { PopperOptions } from '../../types';
+import type { PopperOptions, Strategy } from '../../types.js';
+declare const config: {
+    wrapper: string;
+    container: string;
+    width: string;
+    background: string;
+    color: string;
+    shadow: string;
+    rounded: string;
+    ring: string;
+    base: string;
+    shortcuts: string;
+    middot: string;
+    transition: {
+        enterActiveClass: string;
+        enterFromClass: string;
+        enterToClass: string;
+        leaveActiveClass: string;
+        leaveFromClass: string;
+        leaveToClass: string;
+    };
+    popper: {
+        strategy: string;
+    };
+    default: {
+        openDelay: number;
+        closeDelay: number;
+    };
+    arrow: {
+        base: string;
+        ring: string;
+        rounded: string;
+        background: string;
+        shadow: string;
+        placement: string;
+    };
+};
 declare const _default: import("vue").DefineComponent<{
     text: {
         type: StringConstructor;
-        default: null;
+        default: any;
     };
     prevent: {
         type: BooleanConstructor;
@@ -11,15 +47,15 @@ declare const _default: import("vue").DefineComponent<{
     };
     shortcuts: {
         type: PropType<string[]>;
-        default: () => never[];
+        default: () => any[];
     };
     openDelay: {
         type: NumberConstructor;
-        default: () => any;
+        default: () => number;
     };
     closeDelay: {
         type: NumberConstructor;
-        default: () => any;
+        default: () => number;
     };
     popper: {
         type: PropType<PopperOptions>;
@@ -30,11 +66,48 @@ declare const _default: import("vue").DefineComponent<{
         default: () => string;
     };
     ui: {
-        type: PropType<any>;
+        type: PropType<Partial<typeof config> & {
+            strategy?: Strategy;
+        }>;
         default: () => {};
     };
 }, {
-    ui: import("vue").ComputedRef<any>;
+    ui: import("vue").ComputedRef<{
+        wrapper: string;
+        container: string;
+        width: string;
+        background: string;
+        color: string;
+        shadow: string;
+        rounded: string;
+        ring: string;
+        base: string;
+        shortcuts: string;
+        middot: string;
+        transition: {
+            enterActiveClass: string;
+            enterFromClass: string;
+            enterToClass: string;
+            leaveActiveClass: string;
+            leaveFromClass: string;
+            leaveToClass: string;
+        };
+        popper: {
+            strategy: string;
+        };
+        default: {
+            openDelay: number;
+            closeDelay: number;
+        };
+        arrow: {
+            base: string;
+            ring: string;
+            rounded: string;
+            background: string;
+            shadow: string;
+            placement: string;
+        };
+    }>;
     attrs: import("vue").ComputedRef<Pick<{
         [x: string]: unknown;
     }, string>>;
@@ -47,7 +120,7 @@ declare const _default: import("vue").DefineComponent<{
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     text: {
         type: StringConstructor;
-        default: null;
+        default: any;
     };
     prevent: {
         type: BooleanConstructor;
@@ -55,15 +128,15 @@ declare const _default: import("vue").DefineComponent<{
     };
     shortcuts: {
         type: PropType<string[]>;
-        default: () => never[];
+        default: () => any[];
     };
     openDelay: {
         type: NumberConstructor;
-        default: () => any;
+        default: () => number;
     };
     closeDelay: {
         type: NumberConstructor;
-        default: () => any;
+        default: () => number;
     };
     popper: {
         type: PropType<PopperOptions>;
@@ -74,17 +147,19 @@ declare const _default: import("vue").DefineComponent<{
         default: () => string;
     };
     ui: {
-        type: PropType<any>;
+        type: PropType<Partial<typeof config> & {
+            strategy?: Strategy;
+        }>;
         default: () => {};
     };
 }>>, {
-    text: string;
+    ui: {};
+    shortcuts: string[];
     class: any;
     popper: PopperOptions;
-    ui: any;
+    text: string;
     openDelay: number;
     closeDelay: number;
     prevent: boolean;
-    shortcuts: string[];
 }, {}>;
 export default _default;

package/dist/runtime/composables/{defineShortcuts.mjs → defineShortcuts.js}

@@ -1,7 +1,7 @@
 import { ref, computed } from "vue";
 import { logicAnd, logicNot } from "@vueuse/math";
 import { useEventListener, useDebounceFn } from "@vueuse/core";
-import { useShortcuts } from "./useShortcuts.mjs";
+import { useShortcuts } from "./useShortcuts.js";
 const chainedShortcutRegex = /^[^-]+.*-.*[^-]+$/;
 const combinedShortcutRegex = /^[^_]+.*_.*[^_]+$/;
 export const defineShortcuts = (config, options = {}) => {

package/dist/runtime/composables/{useButtonGroup.mjs → useButtonGroup.js}

@@ -44,16 +44,15 @@ export function useInjectButtonGroup({ ui, props }) {
     groupContext?.value.unregister(instance);
   });
   return {
-    size: computed(() => groupContext?.value.size || props.size),
+    size: computed(() => {
+      if (!groupContext?.value) return props.size;
+      return groupContext?.value.size ?? ui.value.default.size;
+    }),
     rounded: computed(() => {
-      if (!groupContext || positionInGroup.value === -1)
-        return ui.value.rounded;
-      if (groupContext.value.children.length === 1)
-        return groupContext.value.ui.rounded;
-      if (positionInGroup.value === 0)
-        return groupContext.value.rounded.start;
-      if (positionInGroup.value === groupContext.value.children.length - 1)
-        return groupContext.value.rounded.end;
+      if (!groupContext || positionInGroup.value === -1) return ui.value.rounded;
+      if (groupContext.value.children.length === 1) return groupContext.value.ui.rounded;
+      if (positionInGroup.value === 0) return groupContext.value.rounded.start;
+      if (positionInGroup.value === groupContext.value.children.length - 1) return groupContext.value.rounded.end;
       return "rounded-none";
     })
   };

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

@@ -1,4 +1,4 @@
-import type { Notification } from '../types/notification';
+import type { Notification } from '../types/notification.js';
 export declare function useCopyToClipboard(options?: Partial<Notification>): {
     copy: (text: string, success?: {
         title?: string;

package/dist/runtime/composables/{useCopyToClipboard.mjs → useCopyToClipboard.js}

@@ -1,5 +1,5 @@
 import { useClipboard } from "@vueuse/core";
-import { useToast } from "./useToast.mjs";
+import { useToast } from "./useToast.js";
 export function useCopyToClipboard(options = {}) {
   const { copy: copyToClipboard, isSupported } = useClipboard();
   const toast = useToast();

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

@@ -7,12 +7,12 @@ type InputProps = {
     legend?: string | null;
 };
 export declare const useFormGroup: (inputProps?: InputProps, config?: any) => {
-    inputId: import("vue").ComputedRef<string | undefined>;
-    name: import("vue").ComputedRef<string | undefined>;
-    size: import("vue").ComputedRef<any>;
-    color: import("vue").ComputedRef<string | undefined>;
+    inputId: import("vue").ComputedRef<string>;
+    name: import("vue").ComputedRef<string>;
+    size: import("vue").ComputedRef<string | number | symbol>;
+    color: import("vue").ComputedRef<string>;
     emitFormBlur: () => void;
-    emitFormInput: import("@vueuse/core").PromisifyFn<() => void>;
+    emitFormInput: import("@vueuse/shared").PromisifyFn<() => void>;
     emitFormChange: () => void;
 };
 export {};

package/dist/runtime/composables/useFormGroup.js

@@ -0,0 +1,49 @@
+import { inject, ref, computed } from "vue";
+import { useDebounceFn } from "@vueuse/core";
+import { mergeConfig } from "../utils/index.js";
+import appConfig from "#build/app.config";
+import { formGroup } from "#ui/ui.config";
+const formGroupConfig = mergeConfig(appConfig.ui.strategy, appConfig.ui.formGroup, formGroup);
+export const useFormGroup = (inputProps, config) => {
+  const formBus = inject("form-events", void 0);
+  const formGroup2 = inject("form-group", void 0);
+  const formInputs = inject("form-inputs", void 0);
+  if (formGroup2) {
+    if (inputProps?.id) {
+      formGroup2.inputId.value = inputProps?.id;
+    }
+    if (formInputs) {
+      formInputs.value[formGroup2.name.value] = formGroup2.inputId.value;
+    }
+  }
+  const blurred = ref(false);
+  function emitFormEvent(type, path) {
+    if (formBus) {
+      formBus.emit({ type, path });
+    }
+  }
+  function emitFormBlur() {
+    emitFormEvent("blur", formGroup2?.name.value);
+    blurred.value = true;
+  }
+  function emitFormChange() {
+    emitFormEvent("change", formGroup2?.name.value);
+  }
+  const emitFormInput = useDebounceFn(() => {
+    if (blurred.value || formGroup2?.eagerValidation.value) {
+      emitFormEvent("input", formGroup2?.name.value);
+    }
+  }, 300);
+  return {
+    inputId: computed(() => inputProps?.id ?? formGroup2?.inputId.value),
+    name: computed(() => inputProps?.name ?? formGroup2?.name.value),
+    size: computed(() => {
+      const formGroupSize = config.size[formGroup2?.size.value] ? formGroup2?.size.value : null;
+      return inputProps?.size ?? formGroupSize ?? formGroupConfig?.default?.size;
+    }),
+    color: computed(() => formGroup2?.error?.value ? "red" : inputProps?.color),
+    emitFormBlur,
+    emitFormInput,
+    emitFormChange
+  };
+};

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

@@ -1,12 +1,12 @@
 import type { ShallowRef, Component, InjectionKey } from 'vue';
-import type { ComponentProps } from '../types/component';
-import type { Modal, ModalState } from '../types/modal';
+import type { ComponentProps } from '../types/component.js';
+import type { Modal, ModalState } from '../types/modal.js';
 export declare const modalInjectionKey: InjectionKey<ShallowRef<ModalState>>;
 declare function _useModal(): {
     open: <T extends Component>(component: T, props?: Modal & ComponentProps<T>) => void;
     close: () => Promise<void>;
     reset: () => void;
-    patch: <T_1 extends Component = {}>(props: Partial<Modal & ComponentProps<T_1>>) => void;
+    patch: <T extends Component = {}>(props: Partial<Modal & ComponentProps<T>>) => void;
     isOpen: import("vue").Ref<boolean>;
 };
 export declare const useModal: typeof _useModal;

package/dist/runtime/composables/{useModal.mjs → useModal.js}

@@ -15,8 +15,7 @@ function _useModal() {
     isOpen.value = true;
   }
   async function close() {
-    if (!modalState)
-      return;
+    if (!modalState) return;
     isOpen.value = false;
   }
   function reset() {
@@ -26,8 +25,7 @@ function _useModal() {
     };
   }
   function patch(props) {
-    if (!modalState)
-      return;
+    if (!modalState) return;
     modalState.value = {
       ...modalState.value,
       props: {

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

@@ -2,23 +2,23 @@ import type { Ref } from 'vue';
 import type { VirtualElement } from '@popperjs/core/lib/popper-lite';
 import type { Instance } from '@popperjs/core';
 import type { MaybeElement } from '@vueuse/core';
-import type { PopperOptions } from '../types/popper';
-export declare const createPopper: <TModifier extends Partial<import("@popperjs/core").Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<import("@popperjs/core").OptionsGeneric<TModifier>> | undefined) => Instance;
+import type { PopperOptions } from '../types/popper.js';
+export declare const createPopper: <TModifier extends Partial<import("@popperjs/core").Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<import("@popperjs/core").OptionsGeneric<TModifier>>) => Instance;
 export declare function usePopper({ locked, overflowPadding, offsetDistance, offsetSkid, gpuAcceleration, adaptive, scroll, resize, arrow, placement, strategy }: PopperOptions, virtualReference?: Ref<Element | VirtualElement>): readonly [Ref<MaybeElement>, Ref<MaybeElement>, Ref<{
     state: {
         elements: {
             reference: Element | {
                 getBoundingClientRect: () => ClientRect | DOMRect;
-                contextElement?: Element | undefined;
+                contextElement?: Element;
             };
             popper: HTMLElement;
-            arrow?: HTMLElement | undefined;
+            arrow?: HTMLElement;
         };
         options: {
             placement: import("@popperjs/core").Placement;
             modifiers: any[];
             strategy: import("@popperjs/core").PositioningStrategy;
-            onFirstUpdate?: ((arg0: Partial<import("@popperjs/core").State>) => void) | undefined;
+            onFirstUpdate?: (arg0: Partial<import("@popperjs/core").State>) => void;
         };
         placement: import("@popperjs/core").Placement;
         strategy: import("@popperjs/core").PositioningStrategy;
@@ -26,12 +26,12 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
             name: any;
             enabled: boolean;
             phase: import("@popperjs/core").ModifierPhases;
-            requires?: string[] | undefined;
-            requiresIfExists?: string[] | undefined;
-            fn: (arg0: import("@popperjs/core").ModifierArguments<any>) => void | import("@popperjs/core").State;
-            effect?: ((arg0: import("@popperjs/core").ModifierArguments<any>) => void | (() => void)) | undefined;
-            options?: Partial<any> | undefined;
-            data?: import("@popperjs/core").Obj | undefined;
+            requires?: Array<string>;
+            requiresIfExists?: Array<string>;
+            fn: (arg0: import("@popperjs/core").ModifierArguments<any>) => import("@popperjs/core").State | void;
+            effect?: (arg0: import("@popperjs/core").ModifierArguments<any>) => (() => void) | void;
+            options?: Partial<any>;
+            data?: import("@popperjs/core").Obj;
         }[];
         rects: {
             reference: {
@@ -64,20 +64,38 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
                 toString: () => "[object Window]";
                 devicePixelRatio: number;
                 visualViewport?: {
-                    addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
-                    dispatchEvent: (event: Event) => boolean;
-                    removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                    addEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                    removeEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    };
                     width: number;
                     height: number;
                     offsetLeft: number;
                     offsetTop: number;
                     scale: number;
-                } | undefined;
+                };
                 ShadowRoot: ShadowRoot;
             } | {
-                addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
-                dispatchEvent: (event: Event) => boolean;
-                removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                addEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                };
+                dispatchEvent: {
+                    (event: Event): boolean;
+                    (event: Event): boolean;
+                };
+                removeEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                };
                 width: number;
                 height: number;
                 offsetLeft: number;
@@ -100,20 +118,38 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
                 toString: () => "[object Window]";
                 devicePixelRatio: number;
                 visualViewport?: {
-                    addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
-                    dispatchEvent: (event: Event) => boolean;
-                    removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                    addEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                    removeEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    };
                     width: number;
                     height: number;
                     offsetLeft: number;
                     offsetTop: number;
                     scale: number;
-                } | undefined;
+                };
                 ShadowRoot: ShadowRoot;
             } | {
-                addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
-                dispatchEvent: (event: Event) => boolean;
-                removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                addEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                };
+                dispatchEvent: {
+                    (event: Event): boolean;
+                    (event: Event): boolean;
+                };
+                removeEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                };
                 width: number;
                 height: number;
                 offsetLeft: number;
@@ -132,10 +168,10 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
         modifiersData: {
             [x: string]: any;
             arrow?: {
-                x?: number | undefined;
-                y?: number | undefined;
+                x?: number;
+                y?: number;
                 centerOffset: number;
-            } | undefined;
+            };
             hide?: {
                 isReferenceHidden: boolean;
                 hasPopperEscaped: boolean;
@@ -151,77 +187,77 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
                     right: number;
                     bottom: number;
                 };
-            } | undefined;
+            };
             offset?: {
                 "bottom-end"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "bottom-start"?: {
                     y: number;
                     x: number;
-                } | undefined;
-                bottom?: {
+                };
+                auto?: {
                     y: number;
                     x: number;
-                } | undefined;
-                left?: {
+                };
+                right?: {
                     y: number;
                     x: number;
-                } | undefined;
-                right?: {
+                };
+                left?: {
                     y: number;
                     x: number;
-                } | undefined;
-                top?: {
+                };
+                "auto-start"?: {
                     y: number;
                     x: number;
-                } | undefined;
-                auto?: {
+                };
+                "auto-end"?: {
                     y: number;
                     x: number;
-                } | undefined;
-                "auto-start"?: {
+                };
+                top?: {
                     y: number;
                     x: number;
-                } | undefined;
-                "auto-end"?: {
+                };
+                bottom?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "top-start"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "top-end"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "right-start"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "right-end"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "left-start"?: {
                     y: number;
                     x: number;
-                } | undefined;
+                };
                 "left-end"?: {
                     y: number;
                     x: number;
-                } | undefined;
-            } | undefined;
+                };
+            };
             preventOverflow?: {
                 y: number;
                 x: number;
-            } | undefined;
+            };
             popperOffsets?: {
                 y: number;
                 x: number;
-            } | undefined;
+            };
         };
         reset: boolean;
     };
@@ -229,4 +265,4 @@ export declare function usePopper({ locked, overflowPadding, offsetDistance, off
     forceUpdate: () => void;
     update: () => Promise<Partial<import("@popperjs/core").State>>;
     setOptions: (setOptionsAction: Partial<import("@popperjs/core").OptionsGeneric<any>> | ((prev: Partial<import("@popperjs/core").OptionsGeneric<any>>) => Partial<import("@popperjs/core").OptionsGeneric<any>>)) => Promise<Partial<import("@popperjs/core").State>>;
-} | null>];
+}>];

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

@@ -1,12 +1,12 @@
 export declare const _useShortcuts: () => {
-    macOS: import("vue").ComputedRef<false | "" | RegExpMatchArray | null | undefined>;
+    macOS: import("vue").ComputedRef<RegExpMatchArray>;
     metaSymbol: import("vue").Ref<string>;
-    activeElement: import("vue").Ref<HTMLElement | null | undefined>;
+    activeElement: import("vue").Ref<HTMLElement>;
     usingInput: import("vue").ComputedRef<string | boolean>;
 };
 export declare const useShortcuts: () => {
-    macOS: import("vue").ComputedRef<false | "" | RegExpMatchArray | null | undefined>;
+    macOS: import("vue").ComputedRef<RegExpMatchArray>;
     metaSymbol: import("vue").Ref<string>;
-    activeElement: import("vue").Ref<HTMLElement | null | undefined>;
+    activeElement: import("vue").Ref<HTMLElement>;
     usingInput: import("vue").ComputedRef<string | boolean>;
 };

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

@@ -1,12 +1,12 @@
 import type { ShallowRef, Component, InjectionKey } from 'vue';
-import type { ComponentProps } from '../types/component';
-import type { Slideover, SlideoverState } from '../types/slideover';
+import type { ComponentProps } from '../types/component.js';
+import type { Slideover, SlideoverState } from '../types/slideover.js';
 export declare const slidOverInjectionKey: InjectionKey<ShallowRef<SlideoverState>>;
 declare function _useSlideover(): {
     open: <T extends Component>(component: T, props?: Slideover & ComponentProps<T>) => void;
     close: () => Promise<void>;
     reset: () => void;
-    patch: <T_1 extends Component = {}>(props: Partial<Slideover & ComponentProps<T_1>>) => void;
+    patch: <T extends Component = {}>(props: Partial<Slideover & ComponentProps<T>>) => void;
     isOpen: import("vue").Ref<boolean>;
 };
 export declare const useSlideover: typeof _useSlideover;

package/dist/runtime/composables/{useSlideover.mjs → useSlideover.js}

@@ -15,8 +15,7 @@ function _useSlideover() {
     isOpen.value = true;
   }
   async function close() {
-    if (!slideoverState)
-      return;
+    if (!slideoverState) return;
     isOpen.value = false;
   }
   function reset() {
@@ -26,8 +25,7 @@ function _useSlideover() {
     };
   }
   function patch(props) {
-    if (!slideoverState)
-      return;
+    if (!slideoverState) return;
     slideoverState.value = {
       ...slideoverState.value,
       props: {

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

@@ -4,5 +4,5 @@ export declare function useTimer(cb: (...args: unknown[]) => any, interval: numb
     stop: () => void;
     pause: () => void;
     resume: () => void;
-    remaining: import("vue-demi").ComputedRef<number>;
+    remaining: import("vue").ComputedRef<number>;
 };