maz-ui 4.0.0-beta.9 → 4.0.0

package/dist/directives/vFullscreenImg/fullscreen-img.handler.d.ts

@@ -0,0 +1,36 @@
+import { DirectiveBinding } from 'vue';
+export interface VFullscreenImgOptions {
+    disabled?: boolean;
+    scaleOnHover?: boolean;
+    blurOnHover?: boolean;
+    zoom?: boolean;
+    offset?: number;
+    animation?: {
+        duration?: number;
+        easing?: string;
+    };
+}
+interface VFullscreenImgBindingOptions extends VFullscreenImgOptions {
+    src: string;
+    alt?: string | null;
+}
+export type VFullscreenImgBindingValue = string | VFullscreenImgBindingOptions | undefined;
+export type VFullscreenImgBinding = DirectiveBinding<VFullscreenImgBindingValue>;
+export declare class FullscreenImgHandler {
+    private options;
+    private defaultOptions;
+    private mouseEnterListener;
+    private mouseLeaveListener;
+    private renderPreviewListener;
+    private buildOptions;
+    get allInstances(): HTMLElement[];
+    private getImgSrc;
+    private getImgAlt;
+    create(el: HTMLElement, binding: VFullscreenImgBinding): void;
+    update(el: HTMLElement, binding: VFullscreenImgBinding): void;
+    remove(el: HTMLElement): void;
+    private renderPreview;
+    private mouseLeave;
+    private mouseEnter;
+}
+export {};

package/dist/directives/vFullscreenImg.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from 'vue';
+import { VFullscreenImgDirective } from './vFullscreenImg/fullscreen-img.directive';
+declare const plugin: Plugin;
+export { plugin as vFullscreenImgInstall };
+export { vFullscreenImg, type VFullscreenImgDirective } from './vFullscreenImg/fullscreen-img.directive';
+export type { VFullscreenImgBindingValue, VFullscreenImgOptions } from './vFullscreenImg/fullscreen-img.handler';
+declare module 'vue' {
+    interface GlobalDirectives {
+        vFullscreenImg: VFullscreenImgDirective;
+    }
+}

package/dist/directives/vFullscreenImg.js

@@ -1,4 +1,4 @@
-import { d as directive } from "../chunks/fullscreen-img.directive.Be383en8.js";
+import { d as directive } from "../chunks/fullscreen-img.directive.D9oQ3Gni.js";
 const plugin = {
   install(app) {
     app.directive("fullscreen-img", directive);

package/dist/directives/vLazyImg/lazy-img.directive.d.ts

@@ -0,0 +1,5 @@
+import { ObjectDirective } from 'vue';
+import { VLazyImgBindingValue } from './lazy-img.handler';
+export type VLazyImgDirective = ObjectDirective<HTMLElement, VLazyImgBindingValue>;
+declare const directive: VLazyImgDirective;
+export { directive as vLazyImg };

package/dist/directives/vLazyImg/lazy-img.handler.d.ts

@@ -0,0 +1,38 @@
+import { ClassOptions, VLazyImgBinding, VLazyImgOptions } from './types';
+export * from './types';
+export declare const DEFAULT_OPTIONS: ClassOptions;
+export declare class LazyImg {
+    private observers;
+    private readonly defaultOptions;
+    private options;
+    private onImgLoadedCallback;
+    private onImgErrorCallback;
+    private hasImgLoaded;
+    constructor(opts?: VLazyImgOptions);
+    private loadErrorPhoto;
+    private buildOptions;
+    private removeClass;
+    private addClass;
+    private removeAllStateClasses;
+    private setBaseClass;
+    private imageIsLoading;
+    private imageIsLoaded;
+    private imageHasError;
+    private getSrc;
+    private getImageUrl;
+    private setPictureSourceUrls;
+    private hasBgImgMode;
+    private isPictureElement;
+    private getImgElement;
+    private setDefaultPhoto;
+    private addEventListenerToImg;
+    private loadImage;
+    setImgSrc(el: HTMLElement, src: string): void;
+    private handleIntersectionObserver;
+    private createObserver;
+    private imageHandler;
+    private bindUpdateHandler;
+    add(el: HTMLElement, binding: VLazyImgBinding): Promise<void>;
+    update(el: HTMLElement, binding: VLazyImgBinding): Promise<void>;
+    remove(el: HTMLElement, binding: VLazyImgBinding): void;
+}

package/dist/directives/vLazyImg/types.d.ts

@@ -0,0 +1,29 @@
+import { DirectiveBinding, ObjectDirective } from 'vue';
+export interface ClassOptions {
+    baseClass: string;
+    loadingClass: string;
+    loadedClass: string;
+    errorClass: string;
+    fallbackClass: string;
+    observerOnce: boolean;
+    loadOnce: boolean;
+    observerOptions: {
+        root?: HTMLElement | null;
+        threshold: number;
+        rootMargin?: string;
+    };
+    fallbackSrc?: string | false;
+    onLoading?: (el: Element) => unknown;
+    onLoaded?: (el: Element) => unknown;
+    onError?: (el: Element) => unknown;
+    onIntersecting?: (el: Element) => unknown;
+}
+export type VLazyImgOptions = Partial<ClassOptions>;
+interface VLazyImgBindingOptions extends VLazyImgOptions {
+    src?: string;
+    disabled?: boolean;
+}
+export type VLazyImgBindingValue = string | VLazyImgBindingOptions;
+export type VLazyImgBinding = DirectiveBinding<VLazyImgBindingValue>;
+export type VLazyImgDirective = ObjectDirective<HTMLElement, VLazyImgBinding>;
+export {};

package/dist/directives/vLazyImg.d.ts

@@ -0,0 +1,12 @@
+import { Plugin } from 'vue';
+import { VLazyImgDirective } from './vLazyImg/lazy-img.directive';
+import { VLazyImgOptions } from './vLazyImg/types';
+declare const plugin: Plugin<[VLazyImgOptions?]>;
+export { vLazyImg, type VLazyImgDirective } from './vLazyImg/lazy-img.directive';
+export { plugin as vLazyImgInstall };
+export type { VLazyImgBindingValue, VLazyImgOptions } from './vLazyImg/types';
+declare module 'vue' {
+    interface GlobalDirectives {
+        vLazyImg: VLazyImgDirective;
+    }
+}

package/dist/directives/vTooltip.d.ts

@@ -0,0 +1,54 @@
+import { DirectiveBinding, ObjectDirective, Plugin } from 'vue';
+import { MazPopoverPosition, MazPopoverProps, MazPopoverTrigger } from '../components/MazPopover.vue';
+interface VTooltipOptions extends Partial<Omit<MazPopoverProps, 'modelValue'>> {
+    /**
+     * Text to display in the tooltip
+     */
+    text?: string;
+    /**
+     * HTML content (alternative to text)
+     */
+    html?: string;
+    /**
+     * Color variant of the tooltip
+     * @default contrast
+     */
+    color?: MazPopoverProps['color'];
+    /**
+     * Position of the tooltip
+     * The preferred position is set to 'top' if no position is provided
+     * @default top
+     */
+    position?: MazPopoverPosition;
+    /**
+     * Trigger of the tooltip
+     * @default hover
+     */
+    trigger?: MazPopoverTrigger;
+    /**
+     * Close on click outside
+     * @default false
+     */
+    closeOnClickOutside?: boolean;
+    /**
+     * Close on escape
+     * @default false
+     */
+    closeOnEscape?: boolean;
+    /**
+     * Open the tooltip
+     * @default false
+     */
+    open?: boolean;
+}
+type VTooltipBindingValue = string | VTooltipOptions;
+export type TooltipBinding = DirectiveBinding<VTooltipBindingValue, NonNullable<MazPopoverProps['position']>>;
+export type VTooltipDirective = ObjectDirective<HTMLElement, VTooltipBindingValue, NonNullable<MazPopoverProps['position']>>;
+declare const directive: VTooltipDirective;
+declare const plugin: Plugin<[Partial<VTooltipOptions>?]>;
+export { directive as vTooltip, type VTooltipBindingValue, plugin as vTooltipInstall, type VTooltipOptions, };
+declare module 'vue' {
+    interface GlobalDirectives {
+        vTooltip: VTooltipDirective;
+    }
+}

package/dist/directives/vTooltip.js

@@ -21,11 +21,11 @@ class TooltipHandler {
     return typeof binding.value == "string" ? {
       ...baseOptions,
       text: binding.value,
-      position: this.getPositionFromModifiers(binding) || baseOptions.position
+      position: this.getPositionFromModifiers(binding) || baseOptions.position || "top"
     } : {
       ...baseOptions,
       ...binding.value,
-      position: this.getPositionFromModifiers(binding) || binding.value.position || baseOptions.position
+      position: this.getPositionFromModifiers(binding) || binding.value.position || baseOptions.position || "top"
     };
   }
   getPositionFromModifiers(binding) {
@@ -49,14 +49,12 @@ class TooltipHandler {
         return modifier;
   }
   mount(el, binding) {
-    this.unmount(el);
     const tooltipProps = this.getTooltipProps(binding);
     if (!tooltipProps.text && !tooltipProps.html) {
       console.warn("[maz-ui](vTooltip) No text or html content provided");
       return;
     }
-    const isOpen = ref(!!tooltipProps.open), tooltipContainer = document.createElement("div");
-    document.body.appendChild(tooltipContainer);
+    const isOpen = ref(!!tooltipProps.open);
     let vNodeInstance = null;
     const createTooltip = () => {
       const popoverProps = {
@@ -71,23 +69,17 @@ class TooltipHandler {
           tooltipProps.panelClass
         ].filter(Boolean).join(" "),
         modelValue: isOpen.value,
-        positionReference: el
-        // Use original element as reference
+        positionReference: el,
+        onAfterCloseAnimation: () => {
+          vNodeInstance?.destroy(), vNodeInstance = null;
+        }
       };
-      vNodeInstance && vNodeInstance.destroy(), vNodeInstance = useMountComponent(MazPopover, {
-        props: {
-          ...popoverProps,
-          modelValue: isOpen.value,
-          "onUpdate:modelValue": (value) => {
-            isOpen.value = value;
-          }
-        },
+      vNodeInstance = useMountComponent(MazPopover, {
+        props: popoverProps,
         children: {
-          // Use a dummy trigger since we control positioning via positionReference
-          // trigger: () => h('div', { style: 'display: none;' }),
           default: () => tooltipProps.html ? h("div", { innerHTML: tooltipProps.html }) : tooltipProps.text || ""
         },
-        element: tooltipContainer
+        element: el
       });
     };
     function isTouchDevice() {
@@ -112,12 +104,12 @@ class TooltipHandler {
       mouseEnterHandler && (el.removeEventListener("mouseenter", mouseEnterHandler), mouseEnterHandler = null), mouseLeaveHandler && (el.removeEventListener("mouseleave", mouseLeaveHandler), mouseLeaveHandler = null), clickHandler && (el.removeEventListener("click", clickHandler), clickHandler = null);
     }
     nextTick(() => {
-      createTooltip(), setupTriggers();
-    }), watch(isOpen, () => {
-      createTooltip();
-    });
+      setupTriggers();
+    }), watch(isOpen, (value) => {
+      value ? createTooltip() : vNodeInstance && vNodeInstance?.vNode.component?.exposed?.close();
+    }, { immediate: !0 });
     function destroy() {
-      cleanupTriggers(), vNodeInstance && (vNodeInstance.destroy(), vNodeInstance = null), tooltipContainer.parentNode && tooltipContainer.parentNode.removeChild(tooltipContainer);
+      cleanupTriggers(), vNodeInstance && (vNodeInstance.destroy(), vNodeInstance = null);
     }
     function updateProps(newProps) {
       const oldTrigger = tooltipProps.trigger;

package/dist/directives/vZoomImg/style.d.ts

@@ -0,0 +1 @@
+export declare const style = "\n.maz-zoom-img {\n  position: fixed;\n  top: 0;\n  bottom: 0;\n  left: 0;\n  right: 0;\n  padding: 1rem;\n  z-index: 1050;\n  background-color: hsla(238, 15%, 40%, 0.7);\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  flex-direction: column;\n}\n\n.maz-zoom-img,\n.maz-zoom-img * {\n  box-sizing: border-box;\n}\n\n.maz-zoom-img .maz-zoom-img__wrapper {\n  position: relative;\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  min-width: 0;\n  min-height: 0;\n  max-width: 100%;\n  max-height: 100%;\n  transition: all 300ms ease-in-out;\n  opacity: 0;\n  transform: scale(0.5);\n}\n\n.maz-zoom-img.maz-animate .maz-zoom-img__wrapper {\n  opacity: 1;\n  transform: scale(1);\n}\n\n.maz-zoom-img.maz-animate .maz-zoom-img__loader {\n  position: absolute;\n  top: 0;\n  bottom: 0;\n  left: 0;\n  right: 0;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  background-color: hsla(238, 15%, 40%, 0.7);\n  border-radius: 1rem;\n  z-index: 2;\n  min-width: 60px;\n  min-height: 60px;\n}\n.maz-zoom-img.maz-animate .maz-zoom-img__loader[hidden] {\n  display: none;\n}\n\n@-webkit-keyframes spin {\n  0% { transform: rotate(0deg); }\n  100% { transform: rotate(360deg); }\n}\n\n@keyframes spin {\n  0% { transform: rotate(0deg); }\n  100% { transform: rotate(360deg); }\n}\n\n.maz-zoom-img.maz-animate .maz-zoom-img__loader__svg {\n  animation: spin .6s linear infinite;\n}\n\n.maz-zoom-img img {\n  max-width: 100%;\n  max-height: 100%;\n  min-width: 0;\n  border-radius: 1rem;\n}\n\n.maz-zoom-img .maz-zoom-btn {\n  margin: 0 auto;\n  border: none;\n  background-color: hsla(0, 0%, 7%, 0.5);\n  box-shadow: 0 0 0.5rem 0 hsla(0, 0%, 0%, 0.2);\n  height: 2.2rem;\n  min-height: 2.2rem;\n  width: 2.2rem;\n  min-width: 2.2rem;\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  border-radius: 2.2rem;\n  cursor: pointer;\n  flex: 0 0 auto;\n  outline: none;\n}\n\n.maz-zoom-img .maz-zoom-btn svg {\n  fill: white;\n}\n\n.maz-zoom-img .maz-zoom-btn.maz-zoom-btn--close {\n  position: absolute;\n  top: 0.5rem;\n  right: 0.5rem;\n  z-index: 1;\n}\n\n.maz-zoom-img .maz-zoom-btn.maz-zoom-btn--previous {\n  position: absolute;\n  left: 0.5rem;\n  z-index: 1;\n}\n\n.maz-zoom-img .maz-zoom-btn.maz-zoom-btn--next {\n  position: absolute;\n  right: 0.5rem;\n  z-index: 1;\n}\n\n.maz-zoom-img .maz-zoom-btn:hover {\n  background-color: hsl(0, 0%, 0%);\n}";

package/dist/directives/vZoomImg/svgs.d.ts

@@ -0,0 +1,3 @@
+export declare const svgs: {
+    [key: string]: string;
+};

package/dist/directives/vZoomImg/zoom-img.directive.d.ts

@@ -0,0 +1,8 @@
+import { ObjectDirective } from 'vue';
+import { VZoomImgBindingValue } from './zoom-img.handler';
+export type VZoomImgDirective = ObjectDirective<HTMLElement, VZoomImgBindingValue>;
+export declare const vZoomImg: {
+    created(el: HTMLElement, binding: import('vue').DirectiveBinding<VZoomImgBindingValue, string, string>): void;
+    updated(_el: HTMLElement, binding: import('vue').DirectiveBinding<VZoomImgBindingValue, string, string>): void;
+    unmounted(el: HTMLElement): void;
+};

package/dist/directives/vZoomImg/zoom-img.handler.d.ts

@@ -0,0 +1,46 @@
+import { DirectiveBinding } from 'vue';
+export interface VZoomImgOptions {
+    disabled?: boolean;
+    scale?: boolean;
+    blur?: boolean;
+}
+interface VZoomImgBindingOptions extends VZoomImgOptions {
+    src: string;
+    alt?: string;
+}
+export type VZoomImgBindingValue = string | VZoomImgBindingOptions;
+export type VZoomImgBinding = DirectiveBinding<VZoomImgBindingValue>;
+export declare class ZoomImgHandler {
+    private options;
+    private loader;
+    private wrapper;
+    private img;
+    private keydownHandler;
+    private onImgLoadedCallback;
+    private buttonsAdded;
+    private defaultOptions;
+    private mouseEnterListener;
+    private mouseLeaveListener;
+    private renderPreviewListener;
+    constructor(binding: VZoomImgBinding);
+    private buildOptions;
+    get allInstances(): HTMLElement[];
+    create(el: HTMLElement): void;
+    update(binding: VZoomImgBinding): void;
+    remove(el: HTMLElement): void;
+    private renderPreview;
+    private onImgLoaded;
+    private getLoader;
+    private mouseLeave;
+    private mouseEnter;
+    private keydownLister;
+    private getButton;
+    private closePreview;
+    private getNewInstanceIndex;
+    private nextPreviousImage;
+    private useNextInstance;
+    private addStyle;
+    private keyboardEventHandler;
+    private imgEventHandler;
+}
+export {};

package/dist/directives/vZoomImg.d.ts

@@ -0,0 +1,10 @@
+import { Plugin } from 'vue';
+import { VZoomImgDirective, vZoomImg } from './vZoomImg/zoom-img.directive';
+declare const plugin: Plugin;
+export { vZoomImg, type VZoomImgDirective, plugin as vZoomImgInstall };
+export type { VZoomImgBindingValue } from './vZoomImg/zoom-img.handler';
+declare module 'vue' {
+    interface GlobalDirectives {
+        vZoomImg: VZoomImgDirective;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from '@maz-ui/utils';

package/dist/plugins/aos.d.ts

@@ -0,0 +1,81 @@
+import { Plugin } from 'vue';
+import { Router } from 'vue-router';
+export interface AosOptions {
+    animation?: {
+        /**
+         * The delay of the animation
+         * @default 0
+         */
+        delay?: number;
+        /**
+         * The duration of the animation
+         * @default 300
+         */
+        duration?: number;
+        /**
+         * If true, the animation will be triggered only once
+         * @default true
+         */
+        once?: boolean;
+    };
+    /**
+     * The delay before the animation starts
+     * @default 100
+     */
+    delay?: number;
+    /**
+     * The observer options
+     * @default {
+     *   root: undefined,
+     *   rootMargin: '0px',
+     *   threshold: 0.2,
+     * }
+     */
+    observer?: IntersectionObserverInit;
+    /**
+     * The router instance to trigger the animation on route change
+     * @default undefined
+     */
+    router?: Router;
+}
+interface ClassOptions extends Omit<AosOptions, 'router'> {
+    animation: {
+        delay: number;
+        duration: number;
+        once: boolean;
+    };
+    delay: number;
+    observer: IntersectionObserverInit & {
+        rootMargin: string;
+        threshold: number | number[];
+    };
+}
+export declare class AosHandler {
+    options: ClassOptions;
+    constructor(options?: Omit<AosOptions, 'router'>);
+    private handleIntersect;
+    private handleObserver;
+    runAnimations(): Promise<void> | undefined;
+}
+export declare const AosPlugin: Plugin<[AosOptions?]>;
+declare module '@vue/runtime-core' {
+    interface ComponentCustomProperties {
+        /**
+         * Aos handler instance
+         * @description You should install the plugin to use this property
+         * @examl
+         * ```ts
+         * import { AosPlugin } from 'maz-ui/plugins/aos'
+         * import { createApp } from 'vue'
+         *
+         * const app = createApp(App)
+         * app.use(AosPlugin)
+         *
+         * const aos = useAos()
+         * aos.runAnimations()
+         */
+        $mazAos: AosHandler;
+    }
+}
+export declare function getAosInstance(): AosHandler;
+export {};

package/dist/plugins/aos.js

@@ -1,5 +1,5 @@
-import { i as isClient } from "../chunks/isClient.WI4oSt66.js";
-import { s as sleep } from "../chunks/sleep.BLRH1qZG.js";
+import { e } from "../chunks/isClient.8V3qjGdO.js";
+import { n } from "../chunks/sleep.Ci7GE4BQ.js";
 const DEFAULT_OPTIONS = {
   delay: 100,
   observer: {
@@ -56,7 +56,7 @@ class AosHandler {
     }
   }
   async handleObserver() {
-    await sleep(this.options.delay);
+    await n(this.options.delay);
     const observer = new IntersectionObserver(this.handleIntersect.bind(this), this.options.observer);
     for (const element of document.querySelectorAll("[data-maz-aos]")) {
       const anchorAttr = element.getAttribute("data-maz-aos-anchor");
@@ -68,7 +68,7 @@ class AosHandler {
     }
   }
   runAnimations() {
-    if (isClient())
+    if (e())
       return this.handleObserver();
     console.warn("[MazAos](runAnimations) should be executed on client side");
   }
@@ -76,7 +76,7 @@ class AosHandler {
 let instance;
 const AosPlugin = {
   install: (app, options) => {
-    instance = new AosHandler(options), app.provide("mazAos", instance), app.config.globalProperties.$mazAos = instance, isClient() && (options?.router ? options.router.afterEach(() => {
+    instance = new AosHandler(options), app.provide("mazAos", instance), app.config.globalProperties.$mazAos = instance, e() && (options?.router ? options.router.afterEach(() => {
       instance.runAnimations();
     }) : instance.runAnimations());
   }

package/dist/plugins/dialog/DialogHandler.d.ts

@@ -0,0 +1,16 @@
+import { App } from 'vue';
+import { MazDialogConfirmProps } from '../../components/MazDialogConfirm.vue';
+export type DialogOptions = Partial<Omit<MazDialogConfirmProps, 'modelValue' | 'variant' | 'justify'>> & {
+    onClose?: () => unknown;
+    onAccept?: (response: unknown) => unknown;
+    onReject?: (response: unknown) => unknown;
+};
+export declare class DialogHandler {
+    private readonly app;
+    readonly globalOptions: DialogOptions;
+    constructor(app: App, globalOptions?: DialogOptions);
+    open(options: DialogOptions): {
+        destroy: () => void;
+        close: () => void;
+    };
+}

package/dist/plugins/dialog.d.ts

@@ -0,0 +1,26 @@
+import { Plugin } from 'vue';
+import { DialogOptions, DialogHandler } from './dialog/DialogHandler';
+export declare const DialogPlugin: Plugin<[DialogOptions?]>;
+declare module '@vue/runtime-core' {
+    interface ComponentCustomProperties {
+        /**
+         * Dialog handler instance
+         * @description You should install the plugin to use this property
+         * @examl
+         * ```ts
+         * import { DialogPlugin } from 'maz-ui/plugins/dialog'
+         * import { createApp } from 'vue'
+         *
+         * const app = createApp(App)
+         * app.use(DialogPlugin)
+         *
+         * const dialog = useDialog()
+         * dialog.open({
+         *   title: 'Hello',
+         *   message: 'This is a dialog',
+         * })
+         */
+        $mazDialog: Omit<DialogHandler, 'app'>;
+    }
+}
+export { DialogHandler, type DialogOptions } from './dialog/DialogHandler';

package/dist/plugins/dialog.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main, u as useMazDialogConfirm } from "../chunks/MazDialogConfirm.vue_vue_type_script_setup_true_lang.-K3NpiFL.js";
+import { _ as _sfc_main, u as useMazDialogConfirm } from "../chunks/MazDialogConfirm.vue_vue_type_script_setup_true_lang.DuEcluOw.js";
 import { useMountComponent } from "../composables/useMountComponent.js";
 const DEFAULT_OPTIONS = {
   identifier: "main-dialog"

package/dist/plugins/index.d.ts

@@ -0,0 +1,5 @@
+export { AosHandler, type AosOptions, AosPlugin, getAosInstance } from './aos';
+export { type DialogOptions, DialogPlugin } from './dialog';
+export { MazUi, type MazUiOptions } from './maz-ui';
+export { ToastHandler, type ToastOptions, ToastPlugin, type ToastPosition } from './toast';
+export { WaitHandler, waitInstance, WaitPlugin } from './wait';

package/dist/plugins/maz-ui.d.ts

@@ -0,0 +1,43 @@
+import { MazUiThemeOptions } from '@maz-ui/themes/plugin';
+import { MazUiTranslationsOptions } from '@maz-ui/translations';
+import { Plugin } from 'vue';
+export interface MazUiOptions {
+    /**
+     * The theme configurations
+     * Can not be disabled
+     */
+    theme: MazUiThemeOptions;
+    /**
+     * The translations configurations
+     * Can not be disabled
+     */
+    translations?: MazUiTranslationsOptions;
+}
+/**
+ * @example
+ * ```ts
+ * import { MazUi } from 'maz-ui/plugins/maz-ui'
+ * import { mazUi as mazUiPreset } from '@maz-ui/themes/presets/mazUi'
+ * import 'maz-ui/styles'
+ *
+ * app.use(MazUi, {
+ *   theme: {
+ *     preset: mazUiPreset,
+ *     strategy: 'hybrid',
+ *     darkMode: 'class',
+ *   },
+ *   translations: {
+ *     locale: 'en',
+ *     translations: {
+ *       en: {
+ *         ...
+ *       },
+ *       fr: {
+ *         ...
+ *       },
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export declare const MazUi: Plugin<[MazUiOptions]>;