@dv.net/ui-kit 7.6.0 → 7.6.1

package/dist/components/UiLanguages/UiLanguages.vue.d.ts

@@ -0,0 +1,261 @@
+import { nextTick } from 'vue';
+import { Locale, UiLanguagesProps } from './types';
+type __VLS_Props = UiLanguagesProps;
+type __VLS_PublicProps = {
+    modelValue?: Locale;
+    "is-show"?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        trigger?(_: {
+            locale: Locale;
+        }): any;
+    };
+    refs: {
+        inputRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly modelValue?: string | null | number | undefined | undefined;
+                readonly isDisabled?: boolean | undefined;
+                readonly placeholder?: string | undefined;
+                readonly label?: string | undefined;
+                readonly size?: import('../UiInput/types').InputSize | undefined;
+                readonly filled?: boolean | undefined;
+                readonly error?: boolean | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly inside?: boolean | undefined;
+                readonly type?: string | undefined;
+                readonly readonly?: boolean | undefined;
+                readonly readonlyInteractive?: boolean | undefined;
+                readonly autofocus?: boolean | undefined;
+                readonly clearable?: boolean | undefined;
+                readonly isEmptyValueNull?: boolean | undefined;
+                readonly id?: string | undefined;
+                readonly indexTab?: string | undefined;
+                readonly autocomplete?: string | undefined;
+                readonly showPassword?: boolean | undefined;
+                readonly name?: string | undefined;
+                readonly step?: string | undefined;
+                readonly onClear?: ((args_0?: void | undefined) => any) | undefined;
+                readonly onInput?: ((args_0: string) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((value: string | number | null | undefined) => any) | undefined;
+                readonly onChange?: ((args_0?: void | undefined) => any) | undefined;
+                readonly onBlur?: ((args_0?: void | undefined) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                prependRef: HTMLDivElement;
+                inputRef: HTMLInputElement;
+                appendRef: HTMLDivElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "clear", args_0?: void | undefined) => void) & ((event: "input", args_0: string) => void) & ((event: "update:modelValue", value: string | number | null | undefined) => void) & ((event: "change", args_0?: void | undefined) => void) & ((event: "blur", args_0?: void | undefined) => void);
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<{
+                modelValue?: string | null | number | undefined;
+            } & import('../UiInput/types').InputProps> & Readonly<{
+                onClear?: ((args_0?: void | undefined) => any) | undefined;
+                onInput?: ((args_0: string) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string | number | null | undefined) => any) | undefined;
+                onChange?: ((args_0?: void | undefined) => any) | undefined;
+                onBlur?: ((args_0?: void | undefined) => any) | undefined;
+            }>, {
+                focus: () => any;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                clear: (args_0: void) => any;
+                input: (args_0: string) => any;
+                "update:modelValue": (value: string | number | null | undefined) => any;
+                change: (args_0: void) => any;
+                blur: (args_0: void) => any;
+            }, string, {
+                size: import('../UiInput/types').InputSize;
+                type: string;
+                indexTab: string;
+                autocomplete: string;
+                step: string;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            size: import('../UiInput/types').InputSize;
+            type: string;
+            indexTab: string;
+            autocomplete: string;
+            step: string;
+        }> & Omit<Readonly<{
+            modelValue?: string | null | number | undefined;
+        } & import('../UiInput/types').InputProps> & Readonly<{
+            onClear?: ((args_0?: void | undefined) => any) | undefined;
+            onInput?: ((args_0: string) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | number | null | undefined) => any) | undefined;
+            onChange?: ((args_0?: void | undefined) => any) | undefined;
+            onBlur?: ((args_0?: void | undefined) => any) | undefined;
+        }>, "focus" | ("size" | "type" | "indexTab" | "autocomplete" | "step")> & {
+            focus: () => any;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                prepend?(_: {}): any;
+                append?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    "update:modelValue": (value: Locale) => void;
+    "update:is-show": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: Locale) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:is-show"?: ((value: boolean) => any) | undefined;
+}>, {
+    minNumbersLocalesDisplayFavorites: number;
+    forHeader: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly modelValue?: string | null | number | undefined | undefined;
+            readonly isDisabled?: boolean | undefined;
+            readonly placeholder?: string | undefined;
+            readonly label?: string | undefined;
+            readonly size?: import('../UiInput/types').InputSize | undefined;
+            readonly filled?: boolean | undefined;
+            readonly error?: boolean | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly inside?: boolean | undefined;
+            readonly type?: string | undefined;
+            readonly readonly?: boolean | undefined;
+            readonly readonlyInteractive?: boolean | undefined;
+            readonly autofocus?: boolean | undefined;
+            readonly clearable?: boolean | undefined;
+            readonly isEmptyValueNull?: boolean | undefined;
+            readonly id?: string | undefined;
+            readonly indexTab?: string | undefined;
+            readonly autocomplete?: string | undefined;
+            readonly showPassword?: boolean | undefined;
+            readonly name?: string | undefined;
+            readonly step?: string | undefined;
+            readonly onClear?: ((args_0?: void | undefined) => any) | undefined;
+            readonly onInput?: ((args_0: string) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: string | number | null | undefined) => any) | undefined;
+            readonly onChange?: ((args_0?: void | undefined) => any) | undefined;
+            readonly onBlur?: ((args_0?: void | undefined) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            prependRef: HTMLDivElement;
+            inputRef: HTMLInputElement;
+            appendRef: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "clear", args_0?: void | undefined) => void) & ((event: "input", args_0: string) => void) & ((event: "update:modelValue", value: string | number | null | undefined) => void) & ((event: "change", args_0?: void | undefined) => void) & ((event: "blur", args_0?: void | undefined) => void);
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            modelValue?: string | null | number | undefined;
+        } & import('../UiInput/types').InputProps> & Readonly<{
+            onClear?: ((args_0?: void | undefined) => any) | undefined;
+            onInput?: ((args_0: string) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string | number | null | undefined) => any) | undefined;
+            onChange?: ((args_0?: void | undefined) => any) | undefined;
+            onBlur?: ((args_0?: void | undefined) => any) | undefined;
+        }>, {
+            focus: () => any;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            clear: (args_0: void) => any;
+            input: (args_0: string) => any;
+            "update:modelValue": (value: string | number | null | undefined) => any;
+            change: (args_0: void) => any;
+            blur: (args_0: void) => any;
+        }, string, {
+            size: import('../UiInput/types').InputSize;
+            type: string;
+            indexTab: string;
+            autocomplete: string;
+            step: string;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        size: import('../UiInput/types').InputSize;
+        type: string;
+        indexTab: string;
+        autocomplete: string;
+        step: string;
+    }> & Omit<Readonly<{
+        modelValue?: string | null | number | undefined;
+    } & import('../UiInput/types').InputProps> & Readonly<{
+        onClear?: ((args_0?: void | undefined) => any) | undefined;
+        onInput?: ((args_0: string) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string | number | null | undefined) => any) | undefined;
+        onChange?: ((args_0?: void | undefined) => any) | undefined;
+        onBlur?: ((args_0?: void | undefined) => any) | undefined;
+    }>, "focus" | ("size" | "type" | "indexTab" | "autocomplete" | "step")> & {
+        focus: () => any;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            prepend?(_: {}): any;
+            append?(_: {}): any;
+        };
+    }) | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/UiLanguages/components/UiLanguageButton.vue.d.ts

@@ -0,0 +1,7 @@
+import { UiLanguagesButtonProps } from '../types';
+declare const _default: import('vue').DefineComponent<UiLanguagesButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<UiLanguagesButtonProps> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+export default _default;

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

@@ -0,0 +1,17 @@
+export interface Locale {
+    id: number;
+    name: string;
+    isoCode: string;
+    nativeName?: string;
+}
+export interface UiLanguagesProps {
+    locales: Locale[];
+    disabled?: boolean;
+    minNumbersLocalesDisplayFavorites?: number;
+    forHeader?: boolean;
+    isHidden?: boolean;
+}
+export interface UiLanguagesButtonProps {
+    locale: Locale;
+    selected: Locale;
+}

package/dist/components/UiLayout/UiLayout.vue.d.ts

@@ -0,0 +1,27 @@
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        'sidebar-mobile'?(_: {}): any;
+        'sidebar-desktop'?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,4 @@
+export interface menuProvide {
+    onMenuItemSelect: () => void;
+}
+export declare const menuProvideDefault: menuProvide;

package/dist/components/UiLayoutAuth/UiLayoutAuth.vue.d.ts

@@ -0,0 +1,18 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        'lang-select'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/UiLayoutMenu/UiLayoutMenu.vue.d.ts

@@ -0,0 +1,9 @@
+import { UiLayoutMenuProps } from './types';
+declare const _default: import('vue').DefineComponent<UiLayoutMenuProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    selected: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<UiLayoutMenuProps> & Readonly<{
+    onSelected?: ((...args: any[]) => any) | undefined;
+}>, {
+    collapsed: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLUListElement>;
+export default _default;

package/dist/components/UiLayoutMenu/UiLayoutMenuItem.vue.d.ts

@@ -0,0 +1,7 @@
+import { UiLayoutMenuItemProps } from './types';
+declare const _default: import('vue').DefineComponent<UiLayoutMenuItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    selected: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<UiLayoutMenuItemProps> & Readonly<{
+    onSelected?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,30 @@
+import { Component } from 'vue';
+export interface RouteItem {
+    path: string;
+    meta: {
+        title: string;
+        icon?: string;
+        iconActive?: string;
+        iconComponent?: Component;
+        iconComponentActive?: Component;
+        class?: string;
+        isButton?: boolean;
+        isChildren?: boolean;
+        indicator?: string | number;
+        alwaysOpen?: boolean;
+        animationIcon?: Component;
+        click?: () => void;
+    };
+    children?: RouteItem[];
+}
+export interface UiLayoutMenuProps {
+    routeItems: RouteItem[];
+    collapsed?: boolean;
+}
+export interface UiLayoutMenuItemProps {
+    routeItem: RouteItem;
+    collapsed: boolean;
+    parrentRoutes: string[] | null;
+    routeItems: RouteItem[];
+    activeMenuPath: string | null;
+}

package/dist/components/UiLink/UiLink.vue.d.ts

@@ -0,0 +1,21 @@
+import { UiLinkProps } from '../UiLink/types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UiLinkProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UiLinkProps> & Readonly<{}>, {
+    size: import('../UiLink/types').UiLinkSize;
+    mode: import('../UiLink/types').UiLinkMode;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,10 @@
+import { RouteLocationRaw } from 'vue-router';
+export type UiLinkSize = "sm" | "md" | "lg" | "xl";
+export type UiLinkMode = "primary" | "secondary";
+export type UiLinkTarget = "_blank" | "_self" | "_parent" | "_top";
+export interface UiLinkProps {
+    to?: RouteLocationRaw;
+    size?: UiLinkSize;
+    mode?: UiLinkMode;
+    disabled?: boolean;
+}

package/dist/components/UiLoading/UiLoading.vue.d.ts

@@ -0,0 +1,7 @@
+import { UiLoadingProps } from './types.ts';
+declare const _default: import('vue').DefineComponent<UiLoadingProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UiLoadingProps> & Readonly<{}>, {
+    iconName: string;
+    iconSize: import('../UiIcon/types').UiIconSize;
+    iconType: import('../UiIcon/types').UiIconType;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { UiIconSize, UiIconType } from '../UiIcon/types';
+export interface UiLoadingProps {
+    isShow: boolean;
+    iconName?: string;
+    iconSize?: UiIconSize;
+    iconType?: UiIconType;
+    iconColor?: string;
+    filled?: boolean;
+}

package/dist/components/UiMobileMenu/UiMobileMenu.vue.d.ts

@@ -0,0 +1,31 @@
+type __VLS_Props = {
+    size?: string;
+    title?: string;
+};
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    size: string;
+    title: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/UiModal/UiModal.vue.d.ts

@@ -0,0 +1,38 @@
+import { UiModalProps } from './types';
+type __VLS_Props = UiModalProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        contentRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+    "update:modelValue": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    popperClass: string;
+    padding: string;
+    borderRadius: string;
+    isShowBtnClose: boolean;
+    background: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    contentRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,11 @@
+export interface UiModalProps {
+    isShowBtnClose?: boolean;
+    disabled?: boolean;
+    padding?: string;
+    borderRadius?: string;
+    width?: string;
+    background?: string;
+    popperClass?: string;
+    positionTop?: string;
+    positionLeft?: string;
+}

package/dist/components/UiOverlay/UiOverlay.vue.d.ts

@@ -0,0 +1,24 @@
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/UiPagination/UiPagination.vue.d.ts

@@ -0,0 +1,22 @@
+import { UiPaginationMeta, UiPaginationProps } from './types';
+type __VLS_Props = UiPaginationProps;
+type __VLS_PublicProps = {
+    "page"?: number;
+    "perPage"?: number;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    changePerPage: (value: UiPaginationMeta) => any;
+    changePage: (value: UiPaginationMeta) => any;
+    "update:page": (value: number) => any;
+    "update:perPage": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onChangePerPage?: ((value: UiPaginationMeta) => any) | undefined;
+    onChangePage?: ((value: UiPaginationMeta) => any) | undefined;
+    "onUpdate:page"?: ((value: number) => any) | undefined;
+    "onUpdate:perPage"?: ((value: number) => any) | undefined;
+}>, {
+    perPagePresets: number[];
+    total: number;
+    nextPageExists: boolean | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/UiPagination/components/IconArrow.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, SVGSVGElement>;
+export default _default;

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

@@ -0,0 +1,13 @@
+export interface UiPaginationProps {
+    keyPerPagPagination?: string;
+    disabled?: boolean;
+    perPagePresets?: number[];
+    total?: number;
+    nextPageExists?: boolean | null;
+    isShowPerPageSelect?: boolean;
+    isShowAlwaysPagination?: boolean;
+}
+export interface UiPaginationMeta {
+    page: number;
+    perPage: number;
+}

package/dist/components/UiProfileMenu/UiProfileMenu.vue.d.ts

@@ -0,0 +1,29 @@
+import { UiProfileMenuProps } from './types.ts';
+type __VLS_Props = UiProfileMenuProps;
+declare function closeMenu(): void;
+type __VLS_PublicProps = {
+    "modelValue"?: boolean;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`menu-item-${string}`, (_: {
+        item: import('./types.ts').ProfileMenuItem;
+        index: string | undefined;
+        closeMenu: typeof closeMenu;
+    }) => any>>;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};