maz-ui 3.11.0 → 3.11.2

package/types/modules/directives/v-lazy-img/lazy-img-handler.d.ts

@@ -0,0 +1,38 @@
+import type { ClassOptions, LazyImgBinding, 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 imageHasNoPhoto;
+    private imageIsLoaded;
+    private imageHasError;
+    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: LazyImgBinding): Promise<void>;
+    update(el: HTMLElement, binding: LazyImgBinding): Promise<void>;
+    remove(el: HTMLElement, binding: LazyImgBinding): void;
+}

package/types/modules/directives/v-lazy-img/lazy-img.d.ts

@@ -0,0 +1,5 @@
+export declare const vLazyImg: {
+    created(el: HTMLElement, binding: import("vue").DirectiveBinding<import("./types").vLazyImgBinding>): void;
+    updated(el: HTMLElement, binding: import("vue").DirectiveBinding<import("./types").vLazyImgBinding>): void;
+    unmounted(el: HTMLElement, binding: import("vue").DirectiveBinding<import("./types").vLazyImgBinding>): void;
+};

package/types/modules/directives/v-lazy-img/types.d.ts

@@ -0,0 +1,31 @@
+import type { DirectiveBinding, ObjectDirective } from 'vue';
+export interface ClassOptions {
+    baseClass: string;
+    loadingClass: string;
+    loadedClass: string;
+    errorClass: string;
+    noPhotoClass: string;
+    noPhoto: boolean;
+    noUseErrorPhoto: boolean;
+    observerOnce: boolean;
+    loadOnce: boolean;
+    observerOptions: {
+        root?: HTMLElement | null;
+        threshold: number;
+        rootMargin?: string;
+    };
+    errorPhoto?: string;
+    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 vLazyImgBinding = string | vLazyImgBindingOptions;
+export type LazyImgBinding = DirectiveBinding<vLazyImgBinding>;
+export type LazyImgDirective = ObjectDirective<HTMLElement, vLazyImgBinding>;
+export {};

package/types/modules/directives/v-zoom-img/index.d.ts

@@ -0,0 +1,7 @@
+import type { App } from 'vue';
+declare const plugin: {
+    install(app: App): void;
+};
+export { plugin as vZoomImgInstall };
+export { vZoomImg } from './zoom-img';
+export type { vZoomImgBinding, vZoomImgOptions } from './zoom-img.handler';

package/types/modules/directives/v-zoom-img/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/types/modules/directives/v-zoom-img/svgs.d.ts

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

package/types/modules/directives/v-zoom-img/zoom-img.d.ts

@@ -0,0 +1,2 @@
+import type { Directive } from 'vue';
+export declare const vZoomImg: Directive;

package/types/modules/directives/v-zoom-img/zoom-img.handler.d.ts

@@ -0,0 +1,48 @@
+import type { DirectiveBinding } from 'vue';
+export interface vZoomImgOptions {
+    disabled?: boolean;
+    scale?: boolean;
+    blur?: boolean;
+}
+interface vZoomImgBindingOptions extends vZoomImgOptions {
+    src: string;
+    alt?: string;
+}
+export type vZoomImgBinding = string | vZoomImgBindingOptions;
+export interface BindingData extends DirectiveBinding {
+    value: vZoomImgBinding;
+}
+export declare class VueZoomImg {
+    private options;
+    private loader;
+    private wrapper;
+    private img;
+    private keydownHandler;
+    private onImgLoadedCallback;
+    private buttonsAdded;
+    private defaultOptions;
+    private mouseEnterListener;
+    private mouseLeaveListener;
+    private renderPreviewListener;
+    constructor(binding: BindingData);
+    private buildOptions;
+    get allInstances(): HTMLElement[];
+    create(el: HTMLElement): void;
+    update(binding: BindingData): 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/types/modules/filters/capitalize.d.ts

@@ -0,0 +1 @@
+export declare const capitalize: (value: string) => string;

package/types/modules/filters/currency.d.ts

@@ -0,0 +1,4 @@
+export interface FilterCurrencyOptions extends Intl.NumberFormatOptions {
+    round?: boolean;
+}
+export declare const currency: (number: number | string, locale: string, options: FilterCurrencyOptions) => string;

package/types/modules/filters/date.d.ts

@@ -0,0 +1 @@
+export declare const date: (date: string | number | Date, locale: string, options?: Intl.DateTimeFormatOptions) => string;

package/types/modules/filters/index.d.ts

@@ -0,0 +1,16 @@
+import type { App } from 'vue';
+declare const filters: {
+    capitalize: (value: string) => string;
+    currency: (number: string | number, locale: string, options: import("./currency").FilterCurrencyOptions) => string;
+    date: (date: string | number | Date, locale: string, options?: Intl.DateTimeFormatOptions | undefined) => string;
+    number: (number: string | number, locale: string, options?: Intl.NumberFormatOptions | undefined) => string;
+};
+export type Filters = typeof filters;
+declare const installFilters: {
+    install(app: App): void;
+};
+export { installFilters };
+export * from './capitalize';
+export * from './currency';
+export * from './date';
+export * from './number';

package/types/modules/filters/number.d.ts

@@ -0,0 +1 @@
+export declare const number: (number: number | string, locale: string, options?: Intl.NumberFormatOptions) => string;

package/types/modules/filters/telephone.d.ts

@@ -0,0 +1 @@
+export declare const telephone: (telephone: string) => string;

package/types/modules/helpers/debounce.d.ts

@@ -0,0 +1,7 @@
+type ArgumentTypes<F extends (...args: any[]) => void> = F extends (...args: infer A) => any ? A : never;
+type MethodTypes = {
+    cancel: () => void;
+    flush: () => void;
+};
+export declare function debounce<T extends (...args: any[]) => void>(fn: T, wait?: number, callFirst?: boolean): ((...args: ArgumentTypes<T>) => void) & MethodTypes;
+export {};

package/types/modules/helpers/idle-timeout/idle-timeout-handler.d.ts

@@ -0,0 +1,29 @@
+import type { IdleTimeoutOptions, IdleTimeoutCallback } from './types';
+export declare class IdleTimeout {
+    private readonly callback;
+    private readonly defaultOptions;
+    private options;
+    private timeoutHandler?;
+    private isIdle;
+    private isDestroy;
+    private startTime;
+    private remainingTime;
+    private lastClientX;
+    private lastClientY;
+    private eventNames;
+    constructor(callback: IdleTimeoutCallback, options?: IdleTimeoutOptions);
+    get element(): HTMLElement | Document;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    reset(): void;
+    destroy(): void;
+    private resetTimeout;
+    private handleEvent;
+    private handleTimeout;
+    get destroyed(): boolean;
+    get timeout(): number;
+    set timeout(value: number);
+    get idle(): boolean;
+    set idle(value: boolean);
+}

package/types/modules/helpers/idle-timeout/index.d.ts

@@ -0,0 +1,2 @@
+export type { IdleTimeoutOptions, IdleTimeoutCallback } from './types';
+export { IdleTimeout } from './idle-timeout-handler';

package/types/modules/helpers/idle-timeout/types.d.ts

@@ -0,0 +1,12 @@
+export type IdleTimeoutCallback = ({ isIdle, eventType, }: {
+    isIdle: boolean;
+    eventType?: string;
+}) => void;
+export interface IdleTimeoutStrictOption {
+    element?: HTMLElement | Document;
+    timeout: number;
+    once: boolean;
+    immediate: boolean;
+    ssr: boolean;
+}
+export type IdleTimeoutOptions = Partial<IdleTimeoutStrictOption>;

package/types/modules/helpers/index.d.ts

@@ -0,0 +1,9 @@
+export * from './inject-strict';
+export * from './debounce';
+export * from './truthy-filter';
+export * from './mount-component';
+export * from './idle-timeout';
+export * from './user-visibility';
+export * from './sleep';
+export * from './is-client';
+export * from './script-loader';

package/types/modules/helpers/inject-strict.d.ts

@@ -0,0 +1 @@
+export declare function injectStrict<T>(key: string, fallback?: T): NonNullable<T>;

package/types/modules/helpers/is-client.d.ts

@@ -0,0 +1 @@
+export declare function isClient(): boolean;

package/types/modules/helpers/mount-component.d.ts

@@ -0,0 +1,13 @@
+import type { App, Component } from 'vue';
+export declare function mount(component: Component, { props, children, element, app, }?: {
+    props?: Record<string, unknown>;
+    children?: unknown;
+    app?: App;
+    element?: HTMLElement;
+}): {
+    vNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>;
+    destroy: () => void;
+    el: HTMLElement | undefined;
+};

package/types/modules/helpers/script-loader.d.ts

@@ -0,0 +1,19 @@
+export interface ScriptLoaderOptions {
+    identifier: string;
+    src: string;
+    once?: boolean;
+    async?: boolean;
+    defer?: boolean;
+}
+export declare class ScriptLoader {
+    private src;
+    private script?;
+    private once;
+    private async;
+    private defer;
+    private identifier;
+    constructor({ src, identifier, once, async, defer }: ScriptLoaderOptions);
+    removeTag(tag: Element | string): void;
+    load(): Promise<unknown>;
+    private injectScript;
+}

package/types/modules/helpers/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (duration: number) => Promise<unknown>;

package/types/modules/helpers/truthy-filter.d.ts

@@ -0,0 +1,2 @@
+export type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+export declare function truthyFilter<T>(value: T): value is Truthy<T>;

package/types/modules/helpers/user-visibility/index.d.ts

@@ -0,0 +1,2 @@
+export type { UserVisibilyOptions, UserVisibilyCallback } from './types';
+export { UserVisibility } from './user-visibility-handler';

package/types/modules/helpers/user-visibility/types.d.ts

@@ -0,0 +1,10 @@
+export type UserVisibilyCallback = ({ isVisible }: {
+    isVisible: boolean;
+}) => void;
+export type UserVisibilyStrictOptions = {
+    ssr: boolean;
+    immediate: boolean;
+    timeout: number;
+    once: boolean;
+};
+export type UserVisibilyOptions = Partial<UserVisibilyStrictOptions>;

package/types/modules/helpers/user-visibility/user-visibility-handler.d.ts

@@ -0,0 +1,19 @@
+import type { UserVisibilyCallback, UserVisibilyOptions } from './types';
+export declare class UserVisibility {
+    private readonly callback;
+    private eventHandlerFunction;
+    private event;
+    private timeoutHandler?;
+    private options;
+    private readonly defaultOptions;
+    private isVisible;
+    constructor(callback: UserVisibilyCallback, options?: UserVisibilyOptions);
+    start(): void;
+    private emitCallback;
+    private eventHandler;
+    private clearTimeout;
+    private initTimeout;
+    private addEventListener;
+    private removeEventListener;
+    destroy(): void;
+}

package/types/modules/index.d.ts

@@ -0,0 +1,5 @@
+export * from './helpers';
+export * from './directives';
+export * from './filters';
+export * from './plugins';
+export * from './composables';

package/types/modules/plugins/aos/index.d.ts

@@ -0,0 +1,35 @@
+import type { App } from 'vue';
+import type { Router } from 'vue-router';
+export interface AosOptions {
+    routerHook?: (args: any) => () => void;
+    router?: Router;
+    delay?: number;
+    observer?: IntersectionObserverInit;
+    animation?: {
+        once?: boolean;
+        duration?: number;
+    };
+}
+interface ClassOptions extends Omit<AosOptions, 'router'> {
+    delay: number;
+    observer: IntersectionObserverInit & {
+        threshold: number | number[];
+        rootMargin: string;
+    };
+    animation: {
+        once: boolean;
+        duration: number;
+    };
+}
+declare class AosHandler {
+    options: ClassOptions;
+    constructor(options?: Omit<AosOptions, 'router'>);
+    runAnimations(): Promise<void> | undefined;
+    private handleObserver;
+    private handleIntersect;
+}
+export declare let instance: AosHandler;
+export declare const plugin: {
+    install: (app: App, options?: AosOptions) => void;
+};
+export { AosHandler };

package/types/modules/plugins/index.d.ts

@@ -0,0 +1,3 @@
+export { ToasterHandler, installToaster, toastInstance, type ToasterOptions, type ToasterPositions, } from './toaster';
+export { WaitHandler, plugin as installWait, instance as waitInstance } from './wait';
+export { AosHandler, plugin as installAos, instance as aosInstance, type AosOptions } from './aos';

package/types/modules/plugins/toaster/MazToast.vue.d.ts

@@ -0,0 +1,83 @@
+import type { PropType } from 'vue';
+import type { ToasterPositions } from './types';
+declare const _default: import("vue").DefineComponent<{
+    position: {
+        type: PropType<ToasterPositions>;
+        default: string;
+    };
+    maxToasts: {
+        type: (NumberConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    timeout: {
+        type: NumberConstructor;
+        default: number;
+    };
+    queue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noPauseOnHover: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    type: {
+        type: PropType<"success" | "info" | "warning" | "danger" | undefined>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    message: {
+        type: StringConstructor;
+        required: true;
+    };
+    persistent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "click")[], "close" | "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    position: {
+        type: PropType<ToasterPositions>;
+        default: string;
+    };
+    maxToasts: {
+        type: (NumberConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    timeout: {
+        type: NumberConstructor;
+        default: number;
+    };
+    queue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noPauseOnHover: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    type: {
+        type: PropType<"success" | "info" | "warning" | "danger" | undefined>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    message: {
+        type: StringConstructor;
+        required: true;
+    };
+    persistent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onClose?: ((...args: any[]) => any) | undefined;
+    onClick?: ((...args: any[]) => any) | undefined;
+}, {
+    type: "success" | "info" | "warning" | "danger" | undefined;
+    position: ToasterPositions;
+    timeout: number;
+    persistent: boolean;
+    maxToasts: number | boolean;
+    queue: boolean;
+    noPauseOnHover: boolean;
+}, {}>;
+export default _default;

package/types/modules/plugins/toaster/index.d.ts

@@ -0,0 +1,10 @@
+import type { ToasterOptions } from './types';
+import { ToasterHandler } from './toaster-handler';
+import type { App } from 'vue';
+export declare let toastInstance: ToasterHandler;
+export declare function createToaster(app: App, options?: ToasterOptions): ToasterHandler;
+export declare const installToaster: {
+    install(app: App, options?: ToasterOptions): void;
+};
+export type { ToasterOptions, ToasterPositions } from './types';
+export { ToasterHandler } from './toaster-handler';

package/types/modules/plugins/toaster/timer.d.ts

@@ -0,0 +1,11 @@
+export declare class ToasterTimer {
+    callback: () => unknown;
+    delay: number;
+    timer: ReturnType<typeof setTimeout>;
+    startedAt: number;
+    constructor(callback: () => unknown, delay: number);
+    pause(): void;
+    resume(): void;
+    start(): void;
+    stop(): void;
+}

package/types/modules/plugins/toaster/toaster-handler.d.ts

@@ -0,0 +1,16 @@
+import type { App } from 'vue';
+import type { ToasterOptions } from './types';
+export interface LocalToasterOptions extends ToasterOptions {
+    type?: 'success' | 'info' | 'warning' | 'danger';
+}
+export declare class ToasterHandler {
+    private readonly app;
+    private readonly globalOptions;
+    constructor(app: App, globalOptions: ToasterOptions);
+    private show;
+    private getLocalOptions;
+    success(message: string, options?: ToasterOptions): void;
+    error(message: string, options?: ToasterOptions): void;
+    info(message: string, options?: ToasterOptions): void;
+    warning(message: string, options?: ToasterOptions): void;
+}

package/types/modules/plugins/toaster/types.d.ts

@@ -0,0 +1,6 @@
+export type ToasterPositions = 'top' | 'top-right' | 'top-left' | 'bottom' | 'bottom-right' | 'bottom-left';
+export interface ToasterOptions {
+    position?: ToasterPositions;
+    timeout?: number;
+    persistent?: boolean;
+}

package/types/modules/plugins/wait/index.d.ts

@@ -0,0 +1,14 @@
+import { type App } from 'vue';
+import type { LoaderId } from './utils';
+export declare class WaitHandler {
+    private _loaders;
+    get loaders(): import("vue").ComputedRef<unknown[]>;
+    stop(loaderId?: LoaderId): void;
+    start(loaderId?: LoaderId): () => void;
+    get anyLoading(): import("vue").ComputedRef<boolean>;
+    isLoading(loaderId?: LoaderId): boolean;
+}
+export declare const instance: WaitHandler;
+export declare const plugin: {
+    install: (app: App) => void;
+};

package/types/modules/plugins/wait/utils.d.ts

@@ -0,0 +1,7 @@
+export type LoaderId = unknown;
+export declare const DEFAULT_LOADER: LoaderId;
+export declare const uniq: (array: LoaderId[]) => unknown[];
+export declare const contains: (array: Array<LoaderId>) => (predicate?: LoaderId | VoidFunction) => boolean;
+export declare const hasItems: (array: LoaderId[]) => boolean;
+export declare const push: (array: LoaderId[]) => (item?: LoaderId) => unknown[];
+export declare const pop: (array: LoaderId[]) => (item?: LoaderId) => unknown[];

package/types/nuxt/index.d.ts

@@ -0,0 +1,41 @@
+export interface MazUiNuxtOptions {
+    /**
+     * Install the toaster plugin and enable auto import of toaster composable
+     */
+    injectToaster?: boolean;
+    /**
+     * Enable auto import of useCurrency composable
+     */
+    injectUseCurrency?: boolean;
+    /**
+     * Enable auto import of useTheme composable
+     */
+    injectUseThemeHandler?: boolean;
+    /**
+     * install global of v-fullscreen-img directive
+     */
+    installFullscreenImgDirective?: boolean;
+    /**
+     * Enable auto import of all components
+     * @default true
+     */
+    injectComponents?: boolean;
+    /**
+     * Enable Nuxt Devtools integration
+     * @default true
+     */
+    devtools?: boolean;
+}
+declare module '@nuxt/schema' {
+    interface PublicRuntimeConfig {
+        mazUi?: MazUiNuxtOptions;
+    }
+    interface NuxtConfig {
+        mazUi?: MazUiNuxtOptions;
+    }
+    interface NuxtOptions {
+        mazUi?: MazUiNuxtOptions;
+    }
+}
+declare const _default: import("@nuxt/schema").NuxtModule<MazUiNuxtOptions>;
+export default _default;

package/types/nuxt/runtime/composables/use-toast.d.ts

@@ -0,0 +1,2 @@
+import type { ToasterHandler } from './../../../modules';
+export declare function useToast(): ToasterHandler;

package/types/nuxt/runtime/plugins/toaster.d.ts

@@ -0,0 +1,7 @@
+import { ToasterHandler } from './../../../modules';
+declare const _default: import("nuxt/app").Plugin<{
+    toast: ToasterHandler;
+}> & import("nuxt/app").ObjectPlugin<{
+    toast: ToasterHandler;
+}>;
+export default _default;

package/types/tailwindcss/tailwind.config.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from 'tailwindcss';
+declare const _default: Config;
+export default _default;

package/types/tailwindcss/utils/colors.d.ts

@@ -0,0 +1,20 @@
+export declare function getColors(): {
+    transparent: string;
+    black: string;
+    'black-contrast': string;
+    white: string;
+    'white-contrast': string;
+    current: string;
+    normal: string;
+    color: string;
+    'color-light': string;
+    'color-lighter': string;
+    theme: string;
+    'theme-hover': string;
+    'bg-dark': string;
+    'bg-light': string;
+    light: string;
+    dark: string;
+    muted: string;
+    overlay: string;
+};

package/types/tailwindcss/variables/breakpoints.d.ts

@@ -0,0 +1,14 @@
+export declare const screens: {
+    'mob-s': string;
+    'mob-m': string;
+    'mob-l': string;
+    'tab-s': string;
+    'tab-m': string;
+    'tab-l': string;
+    'lap-s': string;
+    'lap-m': string;
+    'lap-l': string;
+    'lap-xl': string;
+    'lap-2xl': string;
+    'lap-3xl': string;
+};