@merkaly/nuxt 0.6.1 → 0.6.4

package/dist/runtime/components/format/FormatNumber.vue

@@ -0,0 +1,38 @@
+<script setup>
+import { computed, toRef } from "vue";
+import { useCounterUp } from "../../composables/useCounterUp";
+const props = defineProps({
+  currency: { type: String, default: () => "USD" },
+  tag: { type: String, default: "span" },
+  value: { type: Number, default: 0 },
+  type: { type: String, default: void 0 },
+  maxFractionDigits: {
+    type: Number,
+    default: void 0
+  }
+});
+const counter = useCounterUp(toRef(props, "value"), {
+  decimals: props.maxFractionDigits ?? 0
+});
+const number = computed(
+  () => Intl.NumberFormat("en-US", {
+    currency: props.currency,
+    maximumFractionDigits: props.maxFractionDigits,
+    notation: "compact",
+    style: props.type
+  }).format(counter.value)
+);
+</script>
+
+<template>
+  <component :is="tag" class="format-number">
+    <span v-text="number" />
+  </component>
+</template>
+
+<style scoped>
+.format-number {
+  font-variant-numeric: tabular-nums;
+  font-feature-settings: "tnum";
+}
+</style>

package/dist/runtime/components/format/FormatNumber.vue.d.ts

@@ -0,0 +1,52 @@
+import type { PropType } from 'vue';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    currency: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+    type: {
+        type: PropType<Intl.NumberFormatOptions["style"]>;
+        default: undefined;
+    };
+    maxFractionDigits: {
+        type: PropType<Intl.NumberFormatOptions["maximumFractionDigits"]>;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    currency: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+    type: {
+        type: PropType<Intl.NumberFormatOptions["style"]>;
+        default: undefined;
+    };
+    maxFractionDigits: {
+        type: PropType<Intl.NumberFormatOptions["maximumFractionDigits"]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    type: keyof Intl.NumberFormatOptionsStyleRegistry | undefined;
+    value: number;
+    currency: string;
+    tag: string;
+    maxFractionDigits: number | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/format/FormatText.d.vue.ts

@@ -1,3 +1,4 @@
+import type { PropType } from 'vue';
 declare var __VLS_9: string, __VLS_10: {};
 type __VLS_Slots = {} & {
     [K in NonNullable<typeof __VLS_9>]?: (props: typeof __VLS_10) => any;
@@ -6,6 +7,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     fallback: {
         type: StringConstructor;
         required: false;
+        default: () => undefined;
     };
     tag: {
         type: StringConstructor;
@@ -16,13 +18,15 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
     values: {
-        type: PropType<Record<string, unknown>>;
+        type: PropType<object>;
         required: false;
+        default: () => {};
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     fallback: {
         type: StringConstructor;
         required: false;
+        default: () => undefined;
     };
     tag: {
         type: StringConstructor;
@@ -33,12 +37,14 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
     values: {
-        type: PropType<Record<string, unknown>>;
+        type: PropType<object>;
         required: false;
+        default: () => {};
     };
 }>> & Readonly<{}>, {
-    values: any;
+    values: object;
     tag: string;
+    fallback: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/format/FormatText.vue

@@ -1,10 +1,10 @@
 <script setup>
 import { computed, useSlots } from "vue";
 const props = defineProps({
-  fallback: { type: String, required: false },
+  fallback: { type: String, required: false, default: () => void 0 },
   tag: { type: String, default: () => "span" },
   template: { type: String, required: true },
-  values: { type: Object, required: false }
+  values: { type: Object, required: false, default: () => ({}) }
 });
 const slots = useSlots();
 const contentParts = computed(() => {

package/dist/runtime/components/format/FormatText.vue.d.ts

@@ -1,3 +1,4 @@
+import type { PropType } from 'vue';
 declare var __VLS_9: string, __VLS_10: {};
 type __VLS_Slots = {} & {
     [K in NonNullable<typeof __VLS_9>]?: (props: typeof __VLS_10) => any;
@@ -6,6 +7,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     fallback: {
         type: StringConstructor;
         required: false;
+        default: () => undefined;
     };
     tag: {
         type: StringConstructor;
@@ -16,13 +18,15 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
     values: {
-        type: PropType<Record<string, unknown>>;
+        type: PropType<object>;
         required: false;
+        default: () => {};
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     fallback: {
         type: StringConstructor;
         required: false;
+        default: () => undefined;
     };
     tag: {
         type: StringConstructor;
@@ -33,12 +37,14 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
     values: {
-        type: PropType<Record<string, unknown>>;
+        type: PropType<object>;
         required: false;
+        default: () => {};
     };
 }>> & Readonly<{}>, {
-    values: any;
+    values: object;
     tag: string;
+    fallback: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/input/InputAddress.d.vue.ts

@@ -81,8 +81,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
 }>, {
     mode: PlaceTypes;
     disabled: boolean;
-    placeholder: string;
     countries: string[];
+    placeholder: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/input/InputAddress.vue.d.ts

@@ -81,8 +81,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
 }>, {
     mode: PlaceTypes;
     disabled: boolean;
-    placeholder: string;
     countries: string[];
+    placeholder: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/input/InputDateRange.vue

@@ -15,10 +15,10 @@ const presets = [
   { key: "lastMonth", label: "Last month", icon: "calendar-xmark" }
 ];
 const selectedPreset = ref(model.value?.preset || props.preset);
-const getDateRange = (preset) => {
+const getDateRange = (key) => {
   const now = /* @__PURE__ */ new Date();
   const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-  switch (preset) {
+  switch (key) {
     case "today":
       return { start: today, end: today };
     case "yesterday": {
@@ -81,11 +81,11 @@ onBeforeMount(() => selectPreset(props.preset));
       <span class="fs-7 fw-bold text-gray-800">Date Range</span>
     </div>
 
-    <template v-for="preset in presets" :key="preset.key">
-      <BDropdownItem :active="selectedPreset === preset.key" @click="selectPreset(preset.key)">
+    <template v-for="item in presets" :key="item.key">
+      <BDropdownItem :active="selectedPreset === item.key" @click="selectPreset(item.key)">
         <div class="d-flex align-items-center gap-2">
-          <FormatIcon :name="preset.icon" class="text-gray-500" />
-          <span v-text="preset.label" />
+          <FormatIcon :name="item.icon" class="text-gray-500" />
+          <span v-text="item.label" />
         </div>
       </BDropdownItem>
     </template>

package/dist/runtime/components/input/InputDropzone.vue

@@ -41,7 +41,7 @@ function handleFileChange(files) {
         class="d-none"
         type="file"
         @change="(e) => handleFileChange(e.target.files)"
-    />
+    >
 
     <div class="dz-message needsclick" @click="triggerInput">
       <i class="ki-duotone ki-file-up text-primary fs-3x">

package/dist/runtime/components/input/InputMoney.d.vue.ts

@@ -74,9 +74,9 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((value: Numberish) => any) | undefined;
 }>, {
-    decimal: string;
     min: number;
     max: number;
+    decimal: string;
     placeholder: string;
     precision: number;
     prefix: string;

package/dist/runtime/components/input/InputMoney.vue.d.ts

@@ -74,9 +74,9 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((value: Numberish) => any) | undefined;
 }>, {
-    decimal: string;
     min: number;
     max: number;
+    decimal: string;
     placeholder: string;
     precision: number;
     prefix: string;

package/dist/runtime/components/input/InputSelect.d.vue.ts

@@ -14,18 +14,19 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
         };
         fieldDisabled: {
             type: PropType<(item: T) => boolean>;
+            default: undefined;
         };
         fieldSort: {
             type: PropType<(item: T) => string>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         fieldText: {
             type: PropType<(item: T) => string>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         fieldValue: {
             type: PropType<(item: T) => unknown>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         filterable: {
             type: BooleanConstructor;
@@ -53,15 +54,16 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
         };
         placeholder: {
             type: StringConstructor;
-        };
-        selectedItem: {
-            type: PropType<T>;
-            default: undefined;
+            default: () => undefined;
         };
         required: {
             type: BooleanConstructor;
             default: () => boolean;
         };
+        selectedItem: {
+            type: PropType<T>;
+            default: undefined;
+        };
         size: {
             type: PropType<Size>;
             default: () => undefined;
@@ -82,10 +84,7 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
             selectedOption: boolean;
         }) => any;
     };
-    emit: {
-        (e: "search", v: string): any;
-        (e: "request:selected", v: string): any;
-    } & ((evt: "update:modelValue", value: any) => void);
+    emit: ((e: "request:selected" | "search", v: string) => unknown) & ((event: "update:modelValue", value: any) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/runtime/components/input/InputSelect.vue

@@ -3,11 +3,11 @@ import { computed, onBeforeMount } from "vue";
 import { useDebounceFn } from "@vueuse/core";
 import VSelect from "vue-select";
 import FormatIcon from "../format/FormatIcon.vue";
-const emit = defineEmits(["search", "request:selected"]);
+const emit = defineEmits(["request:selected", "search"]);
 const props = defineProps({
   debounce: { type: Number, default: () => 250 },
   disabled: { type: Boolean, default: () => false },
-  fieldDisabled: { type: Function },
+  fieldDisabled: { type: Function, default: void 0 },
   fieldSort: { type: Function, default: (it) => it.fieldText },
   fieldText: { type: Function, default: ((it) => it.name) },
   fieldValue: { type: Function, default: ((it) => it._id) },
@@ -17,12 +17,12 @@ const props = defineProps({
   noClear: { type: Boolean, default: () => false },
   noCloseOnSelect: { type: Boolean, default: () => false },
   options: { type: Array, default: () => [] },
-  placeholder: { type: String },
-  selectedItem: { type: Object, default: void 0 },
+  placeholder: { type: String, default: () => void 0 },
   required: { type: Boolean, default: () => false },
+  selectedItem: { type: Object, default: void 0 },
   size: { type: String, default: () => void 0 }
 });
-const model = defineModel({ type: null, ...{ type: [String, Object, Number, Boolean, Array], default: null } });
+const model = defineModel({ type: [String, Object, Number, Boolean, Array], default: null });
 onBeforeMount(() => {
   if (props.selectedItem) return;
   if (model.value) {
@@ -79,17 +79,25 @@ const bindAttrs = computed(() => ({
 }));
 const bindOn = {
   search: (value) => {
-    value && debouncedFn(value);
+    if (value) debouncedFn(value);
     return value;
   }
 };
 const debouncedFn = useDebounceFn((value) => emit("search", value), props.debounce);
+const isRequired = computed(() => {
+  const isEmpty = props.multiple ? !model.value?.length : !model.value;
+  return props.required && isEmpty ? true : void 0;
+});
 </script>
 
 <template>
   <VSelect v-model="model" v-bind="bindAttrs" v-on="bindOn">
     <template #search="scope">
-      <input class="vs__search" v-bind="scope.attributes" v-on="scope.events" />
+      <input
+        :required="isRequired"
+        class="vs__search"
+        v-bind="scope.attributes"
+        v-on="scope.events">
     </template>
 
     <template #option="scope">
@@ -108,12 +116,12 @@ const debouncedFn = useDebounceFn((value) => emit("search", value), props.deboun
       <span :required="props.required || void 0" />
     </template>
 
-    <template #spinner="{ loading }">
-      <BSpinner v-if="loading" class="spinner" variant="primary" />
+    <template #spinner="{ loading: isLoading }">
+      <BSpinner v-if="isLoading" class="spinner" variant="primary" />
     </template>
 
-    <template #no-options="{ search, searching, loading }">
-      <span v-if="loading">Searching for "{{ search }}"</span>
+    <template #no-options="{ search, searching, loading: isLoading }">
+      <span v-if="isLoading">Searching for "{{ search }}"</span>
       <span v-else-if="searching">No results for "{{ search }}"</span>
       <span v-else>Type to search</span>
     </template>

package/dist/runtime/components/input/InputSelect.vue.d.ts

@@ -14,18 +14,19 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
         };
         fieldDisabled: {
             type: PropType<(item: T) => boolean>;
+            default: undefined;
         };
         fieldSort: {
             type: PropType<(item: T) => string>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         fieldText: {
             type: PropType<(item: T) => string>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         fieldValue: {
             type: PropType<(item: T) => unknown>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         filterable: {
             type: BooleanConstructor;
@@ -53,15 +54,16 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
         };
         placeholder: {
             type: StringConstructor;
-        };
-        selectedItem: {
-            type: PropType<T>;
-            default: undefined;
+            default: () => undefined;
         };
         required: {
             type: BooleanConstructor;
             default: () => boolean;
         };
+        selectedItem: {
+            type: PropType<T>;
+            default: undefined;
+        };
         size: {
             type: PropType<Size>;
             default: () => undefined;
@@ -82,10 +84,7 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
             selectedOption: boolean;
         }) => any;
     };
-    emit: {
-        (e: "search", v: string): any;
-        (e: "request:selected", v: string): any;
-    } & ((evt: "update:modelValue", value: any) => void);
+    emit: ((e: "request:selected" | "search", v: string) => unknown) & ((event: "update:modelValue", value: any) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/runtime/components/table/TableDatagrid.d.vue.ts

@@ -76,7 +76,7 @@ declare const __VLS_export: <G>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
     emit: {
         (e: "fetch", reason: "sort" | "filter" | "search" | "paginate" | "refresh"): void;
         (e: "toggle:item", item: G, expanded: boolean): void;
-    } & ((evt: "update:modelValue", value: DataGrid<G>) => void);
+    } & ((event: "update:modelValue", value: DataGrid<G>) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/runtime/components/table/TableDatagrid.vue

@@ -221,7 +221,7 @@ function getRowAttrs(item, idx) {
         </BTd>
       </BTbody>
 
-      <BTbody v-else class="fw-semibold text-gray-600 text-nowrap">
+      <BTbody v-else class="fw-semibold text-nowrap">
         <template v-for="(item, idx) in visibleItems" :key="getRowKey(item, idx)">
           <BTr v-bind="getRowAttrs(item, idx)">
             <BTd v-if="hasDetailsSlot" class="p-0 w-25px">

package/dist/runtime/components/table/TableDatagrid.vue.d.ts

@@ -76,7 +76,7 @@ declare const __VLS_export: <G>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
     emit: {
         (e: "fetch", reason: "sort" | "filter" | "search" | "paginate" | "refresh"): void;
         (e: "toggle:item", item: G, expanded: boolean): void;
-    } & ((evt: "update:modelValue", value: DataGrid<G>) => void);
+    } & ((event: "update:modelValue", value: DataGrid<G>) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

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

@@ -0,0 +1,8 @@
+import type { MaybeRefOrGetter } from 'vue';
+type UseCounterUpOptions = {
+    duration?: number;
+    decimals?: number;
+    ease?: string;
+};
+export declare function useCounterUp(target: MaybeRefOrGetter<number>, options?: UseCounterUpOptions): import("vue").ComputedRef<number>;
+export {};

package/dist/runtime/composables/useCounterUp.js

@@ -0,0 +1,30 @@
+import { watchImmediate } from "@vueuse/core";
+import gsap from "gsap";
+import { computed, onBeforeUnmount, reactive, toValue } from "vue";
+export function useCounterUp(target, options = {}) {
+  const { duration = 0.8, decimals = 0, ease = "power2.out" } = options;
+  const counter = reactive({
+    value: toValue(target) || 0
+  });
+  let tween;
+  let initialized = false;
+  watchImmediate(
+    () => toValue(target),
+    (value) => {
+      const nextValue = Number(value) || 0;
+      if (!initialized) {
+        counter.value = nextValue;
+        initialized = true;
+        return;
+      }
+      tween?.kill();
+      tween = gsap.to(counter, {
+        value: nextValue,
+        duration,
+        ease
+      });
+    }
+  );
+  onBeforeUnmount(() => tween?.kill());
+  return computed(() => Number(counter.value.toFixed(decimals)));
+}

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

@@ -0,0 +1,19 @@
+export interface NotifyOptions {
+    title?: string;
+    message?: string;
+    variant: 'success' | 'danger' | 'warning' | 'info';
+}
+export interface NotifyConfirmOptions extends NotifyOptions {
+    cancelText?: string;
+    confirmText?: string;
+    onConfirm?: () => void;
+}
+export interface NotifyAlertOptions extends NotifyOptions {
+    okText?: string;
+}
+export interface NotifyApi {
+    alert(options: NotifyAlertOptions): void;
+    confirm(options: NotifyConfirmOptions): void;
+    toast(options: NotifyOptions): unknown;
+}
+export declare function useNotify(): NotifyApi;

package/dist/runtime/composables/useNotify.js

@@ -0,0 +1,40 @@
+import { push } from "notivue";
+import { useModal } from "bootstrap-vue-next";
+export function useNotify() {
+  const $modal = useModal();
+  function toast(options) {
+    const toastByVariant = {
+      success: push.success,
+      danger: push.error,
+      warning: push.warning,
+      info: push.info
+    };
+    return toastByVariant[options.variant]({
+      title: options.title,
+      message: options.message
+    });
+  }
+  function alert(options) {
+    const instance = $modal.create({
+      body: options.message,
+      centered: true,
+      okOnly: true,
+      okTitle: options.okText || "OK",
+      title: options.title || "Alert"
+    });
+    instance.show();
+  }
+  function confirm(options) {
+    const instance = $modal.create({
+      body: options.message,
+      cancelTitle: options.cancelText || "Cancel",
+      cancelVariant: "secondary",
+      okTitle: options.confirmText || "OK",
+      okVariant: options.variant || "primary",
+      onOk: options.onConfirm,
+      title: options.title || "Confirm"
+    });
+    instance.show();
+  }
+  return { toast, alert, confirm };
+}

package/dist/runtime/middleware/auth.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("nuxt/app").RouteMiddleware;
+declare const _default: import("#app").RouteMiddleware;
 export default _default;

package/dist/runtime/plugins/api.global.d.ts

@@ -46,5 +46,5 @@ export interface ParamsOptions {
 export type ApiOptions<TData = unknown, TMeta = Record<string, unknown>, TParams = object> = ParamsOptions & HooksOptions<TData, TMeta, TParams> & RefOptions & {
     params?: TParams;
 };
-declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/plugins/auth0.client.d.ts

@@ -1,6 +1,6 @@
-declare const _default: import("nuxt/app").Plugin<{
+declare const _default: import("#app").Plugin<{
     auth0: import("@auth0/auth0-spa-js").Auth0Client;
-}> & import("nuxt/app").ObjectPlugin<{
+}> & import("#app").ObjectPlugin<{
     auth0: import("@auth0/auth0-spa-js").Auth0Client;
 }>;
 export default _default;

package/dist/runtime/plugins/sentry.global.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/types/nuxt.d.ts

@@ -5,7 +5,7 @@ declare module '#app' {
   interface NuxtApp {
     $auth0: Auth0Client;
     $api: (url: string, options?: ApiOptions) => Promise<void>;
-    $gmap: any;
+    $gmap: never;
   }
 
   interface RuntimeNuxtHooks {

package/dist/types.d.mts

@@ -10,4 +10,4 @@ export { type ApiOptions, type HooksOptions, type ParamsOptions, type RefOptions
 
 export { default } from './module.mjs'
 
-export { type MerkalyModuleOptions } from './module.mjs'
+export { type MerkalyI18nLocale, type MerkalyModuleOptions } from './module.mjs'