maz-ui 2.3.10 → 3.0.0-beta.2

package/dist/types/components/MazPhoneNumberInput/index.vue.d.ts

@@ -0,0 +1,195 @@
+import type { CountryCode } from 'libphonenumber-js';
+import { PropType } from 'vue';
+import { Color, Position, Size } from '../types';
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: StringConstructor;
+        validator: (prop: string) => boolean;
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultPhoneNumber: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultCountryCode: {
+        type: PropType<CountryCode>;
+        default: undefined;
+        validator: (code: CountryCode) => boolean;
+    };
+    preferredCountries: {
+        type: PropType<CountryCode[]>;
+        default: undefined;
+    };
+    ignoredCountries: {
+        type: PropType<CountryCode[]>;
+        default: undefined;
+    };
+    onlyCountries: {
+        type: PropType<CountryCode[]>;
+        default: undefined;
+    };
+    translations: {
+        type: PropType<{
+            countrySelector: {
+                placeholder: string;
+                error: string;
+            };
+            phoneInput: {
+                placeholder: string;
+                example: string;
+            };
+        }>;
+        default: undefined;
+    };
+    listPosition: {
+        type: PropType<Position>;
+        default: string;
+        validator: (value: Position) => boolean;
+    };
+    color: {
+        type: PropType<Color>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    noFlags: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noExample: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noUseBrowserLocale: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    fetchCountry: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    noCountrySelector: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCodeOnList: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    error: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update" | "update:model-value" | "country-code")[], "update" | "update:model-value" | "country-code", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    modelValue?: unknown;
+    id?: unknown;
+    placeholder?: unknown;
+    defaultPhoneNumber?: unknown;
+    defaultCountryCode?: unknown;
+    preferredCountries?: unknown;
+    ignoredCountries?: unknown;
+    onlyCountries?: unknown;
+    translations?: unknown;
+    listPosition?: unknown;
+    color?: unknown;
+    size?: unknown;
+    noFlags?: unknown;
+    disabled?: unknown;
+    noExample?: unknown;
+    noSearch?: unknown;
+    noUseBrowserLocale?: unknown;
+    fetchCountry?: unknown;
+    noCountrySelector?: unknown;
+    showCodeOnList?: unknown;
+    error?: unknown;
+} & {
+    listPosition: Position;
+    color: Color;
+    size: Size;
+    noFlags: boolean;
+    disabled: boolean;
+    noExample: boolean;
+    noSearch: boolean;
+    noUseBrowserLocale: boolean;
+    fetchCountry: boolean;
+    noCountrySelector: boolean;
+    showCodeOnList: boolean;
+    error: boolean;
+} & {
+    id?: string | undefined;
+    modelValue?: string | undefined;
+    placeholder?: string | undefined;
+    defaultPhoneNumber?: string | undefined;
+    defaultCountryCode?: CountryCode | undefined;
+    preferredCountries?: CountryCode[] | undefined;
+    ignoredCountries?: CountryCode[] | undefined;
+    onlyCountries?: CountryCode[] | undefined;
+    translations?: {
+        countrySelector: {
+            placeholder: string;
+            error: string;
+        };
+        phoneInput: {
+            placeholder: string;
+            example: string;
+        };
+    } | undefined;
+}> & {
+    onUpdate?: ((...args: any[]) => any) | undefined;
+    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+    "onCountry-code"?: ((...args: any[]) => any) | undefined;
+}, {
+    id: string;
+    modelValue: string;
+    placeholder: string;
+    defaultPhoneNumber: string;
+    defaultCountryCode: CountryCode;
+    preferredCountries: CountryCode[];
+    ignoredCountries: CountryCode[];
+    onlyCountries: CountryCode[];
+    translations: {
+        countrySelector: {
+            placeholder: string;
+            error: string;
+        };
+        phoneInput: {
+            placeholder: string;
+            example: string;
+        };
+    };
+    listPosition: Position;
+    color: Color;
+    size: Size;
+    noFlags: boolean;
+    disabled: boolean;
+    noExample: boolean;
+    noSearch: boolean;
+    noUseBrowserLocale: boolean;
+    fetchCountry: boolean;
+    noCountrySelector: boolean;
+    showCodeOnList: boolean;
+    error: boolean;
+}>;
+export default _default;

package/dist/types/components/MazPhoneNumberInput/types.d.ts

@@ -0,0 +1,19 @@
+import { CountryCallingCode, CountryCode, NationalNumber, NumberType } from 'libphonenumber-js';
+import locales from './constantes/locales';
+export declare type Result = {
+    isValid: boolean;
+    countryCode?: CountryCode;
+    countryCallingCode?: CountryCallingCode;
+    nationalNumber?: NationalNumber;
+    type?: NumberType;
+    formatInternational?: string;
+    formatNational?: string;
+    uri?: string;
+    e164?: string;
+};
+export declare type Translations = typeof locales;
+export declare type Country = {
+    iso2: CountryCode;
+    dialCode: CountryCallingCode;
+    name: string;
+};

package/dist/types/components/MazPhoneNumberInput/utils/countries-name-list-by-iso-code.d.ts

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

package/dist/types/components/MazPhoneNumberInput/utils/index.d.ts

@@ -0,0 +1,15 @@
+import { CountryCode, Examples } from 'libphonenumber-js';
+import { Country, Result } from '../types';
+export declare function getCountryName(code: CountryCode | string): string | undefined;
+export declare function loadPhoneNumberExamplesFile(): Promise<Examples>;
+export declare function getExamplePhoneNumber(countryCode: CountryCode): import("libphonenumber-js").PhoneNumber | undefined;
+export declare function sanitizePhoneNumber(input?: string): string | undefined;
+export declare function getCountriesList(): Country[] | undefined;
+export declare function browserLocale(): string | undefined;
+export declare function isCountryAvailable(locale: string): boolean;
+export declare const getResultsFromPhoneNumber: (countryCode?: CountryCode | undefined, phoneNumber?: string | undefined) => Result;
+export declare function getAsYouTypeFormat(countryCode: CountryCode, phoneNumber?: string): string | undefined;
+export declare function fetchCountryCode(): Promise<string | undefined>;
+declare type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+export declare function truthyFilter<T>(value: T): value is Truthy<T>;
+export {};

package/dist/types/components/MazSelect.vue.d.ts

@@ -0,0 +1,110 @@
+import { PropType } from 'vue';
+import { Color, ModelValueSimple, Position, Size } from './types';
+export declare type MazSelectOptions = Record<string, ModelValueSimple>;
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: PropType<ModelValueSimple>;
+        default: undefined;
+    };
+    options: {
+        type: PropType<MazSelectOptions[]>;
+        required: true;
+    };
+    optionValueKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    optionLabelKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    optionInputValueKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    listPosition: {
+        type: PropType<Position>;
+        default: string;
+        validator: (value: Position) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: PropType<Color>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    itemHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxListHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxListWidth: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "open" | "update:model-value" | "blur")[], "close" | "open" | "update:model-value" | "blur", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    modelValue?: unknown;
+    options?: unknown;
+    optionValueKey?: unknown;
+    optionLabelKey?: unknown;
+    optionInputValueKey?: unknown;
+    listPosition?: unknown;
+    disabled?: unknown;
+    open?: unknown;
+    color?: unknown;
+    itemHeight?: unknown;
+    maxListHeight?: unknown;
+    maxListWidth?: unknown;
+    size?: unknown;
+} & {
+    open: boolean;
+    options: MazSelectOptions[];
+    optionValueKey: string;
+    optionLabelKey: string;
+    optionInputValueKey: string;
+    listPosition: Position;
+    disabled: boolean;
+    color: Color;
+    itemHeight: number;
+    maxListHeight: number;
+    size: Size;
+} & {
+    modelValue?: ModelValueSimple;
+    maxListWidth?: number | undefined;
+}> & {
+    onClose?: ((...args: any[]) => any) | undefined;
+    onOpen?: ((...args: any[]) => any) | undefined;
+    "onUpdate:model-value"?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+}, {
+    open: boolean;
+    modelValue: ModelValueSimple;
+    optionValueKey: string;
+    optionLabelKey: string;
+    optionInputValueKey: string;
+    listPosition: Position;
+    disabled: boolean;
+    color: Color;
+    itemHeight: number;
+    maxListHeight: number;
+    maxListWidth: number;
+    size: Size;
+}>;
+export default _default;

package/dist/types/components/MazSpinner.vue.d.ts

@@ -0,0 +1,25 @@
+import { PropType } from 'vue';
+import { Color } from './types';
+declare const _default: import("vue").DefineComponent<{
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+    color: {
+        type: PropType<Color>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    size?: unknown;
+    color?: unknown;
+} & {
+    size: string;
+    color: Color;
+} & {}>, {
+    size: string;
+    color: Color;
+}>;
+export default _default;

package/dist/types/components/MazTransitionExpand.vue.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("vue").DefineComponent<{}, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
+export default _default;

package/dist/types/components/index.d.ts

@@ -0,0 +1,18 @@
+export { default as MazArrowIcon } from './MazArrowIcon.vue';
+export { default as MazAvatar } from './MazAvatar.vue';
+export { default as MazBackDrop } from './MazBackDrop.vue';
+export { default as MazBottomSheet } from './MazBottomSheet.vue';
+export { default as MazBtn } from './MazBtn.vue';
+export { default as MazCheckbox } from './MazCheckbox.vue';
+export { default as MazDialog } from './MazDialog.vue';
+export { default as MazDropzone } from './MazDropzone/index.vue';
+export { default as MazCard } from './MazCard.vue';
+export { default as MazGallery } from './MazGallery.vue';
+export { default as MazIcon } from './MazIcon.vue';
+export { default as MazInput } from './MazInput.vue';
+export { default as MazInputPrice } from './MazInputPrice.vue';
+export { default as MazLazyImg } from './MazLazyImg.vue';
+export { default as MazPhoneNumberInput } from './MazPhoneNumberInput/index.vue';
+export { default as MazSelect } from './MazSelect.vue';
+export { default as MazSpinner } from './MazSpinner.vue';
+export { default as MazTransitionExpand } from './MazTransitionExpand.vue';

package/dist/types/components/types.d.ts

@@ -0,0 +1,50 @@
+import Dropzone, { DropzoneFile, DropzoneOptions } from 'dropzone';
+import { ComponentPublicInstance } from 'vue';
+export declare type ModelValueSimple = string | number | null | undefined | boolean;
+export declare type MazGalleryImage = {
+    slug: string;
+    alt?: string;
+} | string;
+export declare type Color = 'primary' | 'secondary' | 'info' | 'success' | 'warning' | 'danger' | 'white' | 'black' | 'transparent';
+export declare const colors: Color[];
+export declare type Size = 'mini' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export declare type Position = 'top' | 'top right' | 'top left' | 'bottom' | 'bottom right' | 'bottom left';
+export interface Source {
+    srcset?: string;
+    media?: string;
+}
+export interface DataImage {
+    sources?: Source[];
+}
+export declare type Image = DataImage | string;
+export interface MazDropzoneOptions extends DropzoneOptions {
+    dictFilesDescriptions?: string;
+    autoRemoveOnError?: boolean;
+}
+export interface MazDropzoneFile extends DropzoneFile {
+    manuallyAdded?: boolean;
+}
+export interface IMazDropzone extends Dropzone {
+    options: MazDropzoneOptions;
+}
+export interface MazDropzoneInstance extends ComponentPublicInstance {
+    manuallyAddFile: (file: DropzoneFile, fileUrl: string) => void;
+    setOption: (option: string, value: any) => IMazDropzone['options'];
+    processQueue: IMazDropzone['processQueue'];
+    removeFile: IMazDropzone['removeFile'];
+    removeAllFiles: IMazDropzone['removeAllFiles'];
+    destroy: IMazDropzone['destroy'];
+    disable: IMazDropzone['disable'];
+    enable: IMazDropzone['enable'];
+    accept: IMazDropzone['accept'];
+    addFile: IMazDropzone['addFile'];
+    resizeImage: IMazDropzone['resizeImage'];
+    cancelUpload: IMazDropzone['cancelUpload'];
+    getAcceptedFiles: () => MazDropzoneFile[];
+    getRejectedFiles: () => MazDropzoneFile[];
+    getFilesWithStatus: IMazDropzone['getFilesWithStatus'];
+    getQueuedFiles: IMazDropzone['getQueuedFiles'];
+    getUploadingFiles: IMazDropzone['getUploadingFiles'];
+    getAddedFiles: IMazDropzone['getAddedFiles'];
+    getActiveFiles: IMazDropzone['getActiveFiles'];
+}

package/dist/types/components_tmp/MazCalendar/types.d.ts

@@ -0,0 +1,16 @@
+export interface DaySlot {
+    start: string;
+    end: string;
+    options?: {
+        badge?: number;
+        highlighted?: boolean;
+        warning?: boolean;
+        blocked?: boolean;
+        disabled?: boolean;
+    };
+    extra?: Record<string, any>;
+}
+export interface Day {
+    date: string;
+    slots?: DaySlot[];
+}

package/dist/types/components_tmp/MazChart/includes.d.ts

@@ -0,0 +1,11 @@
+export declare const chartJsEventNames: string[];
+export declare function generateEventObject(type: string, chartRef?: HTMLCanvasElement): {
+    type: string;
+    chartRef: HTMLCanvasElement | undefined;
+    preventDefault(): void;
+    isDefaultPrevented(): boolean;
+    _defaultPrevented: boolean;
+};
+export declare function generateChartJsEventListener(emit: (event: string, ...args: any[]) => void, event: ReturnType<typeof generateEventObject>): {
+    [x: string]: () => boolean;
+};

package/dist/types/components_tmp/MazMap/map-module/create-html-marker.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="google.maps" />
+interface OffsetPosition {
+    x: number;
+    y: number;
+}
+export interface HTMLMarker extends google.maps.OverlayView {
+    remove(): void;
+    getPosition(): google.maps.LatLng | null | undefined;
+    getDraggable(): boolean;
+}
+export declare const createHTMLMarker: (options: {
+    api: typeof google;
+    map: google.maps.Map;
+    templateHtml: string;
+    position: google.maps.LatLng | google.maps.LatLngLiteral;
+    offset?: OffsetPosition;
+}) => HTMLMarker;
+export {};

package/dist/types/components_tmp/MazMap/map-module/map.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="google.maps" />
+import { HTMLMarker } from './create-html-marker';
+import { ScriptOptions } from './script-loader';
+export declare type MapOptions = google.maps.MapOptions;
+export interface MapMarker extends google.maps.MarkerOptions {
+    infoWindow?: google.maps.InfoWindowOptions;
+}
+export interface MarkerInfoWindowOptions extends google.maps.InfoWindowOptions {
+    offset?: {
+        x: number;
+        y: number;
+    };
+}
+export interface MapHTMLMarker {
+    position: google.maps.LatLng | google.maps.LatLngLiteral;
+    templateHtml: string;
+    offset?: {
+        x: number;
+        y: number;
+    };
+    infoWindow?: MarkerInfoWindowOptions;
+}
+export declare class Map {
+    private readonly mapContainerId;
+    private readonly apiKey;
+    private readonly options?;
+    private api;
+    private map;
+    private markers;
+    private htmlMarkers;
+    private mapOptions;
+    constructor(mapContainerId: string, apiKey: string, options?: google.maps.MapOptions | undefined);
+    init(options?: ScriptOptions): Promise<void>;
+    private getInfoWindow;
+    private addInfoWindowContentToMarker;
+    addMarker({ infoWindow, ...arguments_ }: MapMarker): google.maps.Marker;
+    addHTMLMarker({ position, templateHtml, offset, infoWindow, }: MapHTMLMarker): HTMLMarker;
+    get allMarkers(): (google.maps.Marker | HTMLMarker)[];
+    fitOnAllMarkers(): void;
+    removeAllMarkers(): void;
+}
+export * from './script-loader';
+export * from './create-html-marker';

package/dist/types/components_tmp/MazMap/map-module/script-loader.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="google.maps" />
+export interface ScriptOptions {
+    [key: string]: string | string[] | undefined;
+    language?: string;
+    region?: string;
+    libraries?: string[];
+}
+export declare class ScriptLoader {
+    private readonly apiKey;
+    private readonly options?;
+    private readonly scriptOptions;
+    private resolveScript;
+    api: typeof google;
+    constructor(apiKey: string, options?: ScriptOptions | undefined);
+    private getUrl;
+    init(): Promise<typeof google>;
+}

package/dist/types/components_tmp/MazPromiseDialog/use-maz-promise-dialog.d.ts

@@ -0,0 +1,28 @@
+export interface ModalState {
+    id: string;
+    isActive: boolean;
+    resolve: (value: any) => void;
+    reject?: (reason?: any) => void;
+}
+export interface ModalData {
+    title: string;
+    message: string;
+}
+export declare const useMazPromiseDialog: () => {
+    confirmDialogData: import("vue").Ref<ModalData | undefined>;
+    modalState: import("vue").Ref<{
+        id: string;
+        isActive: boolean;
+        resolve: (value: any) => void;
+        reject?: ((reason?: any) => void) | undefined;
+    }[]>;
+    showModalAndWaitChoice: (identifier: string, callback?: (() => any) | undefined) => Promise<unknown>;
+    removeModalFromState: (identifier: string) => {
+        id: string;
+        isActive: boolean;
+        resolve: (value: any) => void;
+        reject?: ((reason?: any) => void) | undefined;
+    }[];
+    rejectModal: (currentModal: ModalState) => void;
+    resolveModal: (currentModal: ModalState) => void;
+};

package/dist/types/components_tmp/MazSlider/utils.d.ts

@@ -0,0 +1,15 @@
+interface IPosObject {
+    x: number;
+    y: number;
+}
+export declare const getOffset: (elem: HTMLDivElement) => IPosObject;
+/**
+ * Get the position of the mouse/finger in the element
+ * @param e Trigger event
+ * @param elem Container element
+ * @param isReverse From the right/bottom
+ */
+export declare const getPos: (e: MouseEvent | TouchEvent, elem: HTMLDivElement, isReverse?: boolean) => IPosObject;
+export declare const isBetween: (value: number, prev: number, next: number, direction: string) => boolean;
+export declare const getOpacityCoeff: (index: number, middle: number, length: number) => number;
+export {};

package/dist/types/components_tmp/MazTabs/maz-tabs.composable.d.ts

@@ -0,0 +1,3 @@
+export declare const useMazTabs: () => {
+    currentTab: import("vue").Ref<number | undefined>;
+};

package/dist/types/components_tmp/toaster/index.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vue';
+declare const plugin: Plugin;
+export default plugin;

package/dist/types/components_tmp/toaster/positions.d.ts

@@ -0,0 +1,8 @@
+export declare enum Positions {
+    TOP_RIGHT = "top-right",
+    TOP = "top",
+    TOP_LEFT = "top-left",
+    BOTTOM_RIGHT = "bottom-right",
+    BOTTOM = "bottom",
+    BOTTOM_LEFT = "bottom-left"
+}

package/dist/types/components_tmp/toaster/timer.d.ts

@@ -0,0 +1,11 @@
+export declare class Timer {
+    callback: Function;
+    delay: number;
+    timer: number;
+    startedAt: number;
+    constructor(callback: Function, delay: number);
+    pause(): void;
+    resume(): void;
+    start(): void;
+    stop(): void;
+}

package/dist/types/components_tmp/toaster/use-toast.d.ts

@@ -0,0 +1,21 @@
+import { App } from 'vue';
+import { Positions } from './positions';
+export interface ToasterOptions {
+    position?: Positions;
+    timeout?: number;
+    closable?: boolean;
+}
+export interface LocalToasterOptions extends ToasterOptions {
+    type?: 'success' | 'info' | 'warning' | 'danger';
+}
+export declare class Toaster {
+    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/dist/types/directives/click-outside.directive.d.ts

@@ -0,0 +1,10 @@
+import { Directive, Plugin } from 'vue';
+declare const directive: Directive;
+declare const mixin: {
+    directives: {
+        ClickAway: import("vue").ObjectDirective<any, any>;
+    };
+};
+export { directive, mixin };
+declare const plugin: Plugin;
+export default plugin;

package/dist/types/directives/closable.directive.d.ts

@@ -0,0 +1,5 @@
+import { Directive, Plugin } from 'vue';
+declare const directive: Directive;
+export { directive };
+declare const plugin: Plugin;
+export default plugin;