@dv.net/ui-kit 1.0.0

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

@@ -0,0 +1,23 @@
+import { UiFormProps } from './types';
+declare function validate(): boolean | undefined;
+declare function resetValidate(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLFormElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UiFormProps, {
+    validate: typeof validate;
+    resetValidate: typeof resetValidate;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UiFormProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLFormElement>;
+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/UiForm/constants.d.ts

@@ -0,0 +1 @@
+export declare const FORM_PROVIDE_VALUE: unique symbol;

package/dist/components/UiForm/constants.js

@@ -0,0 +1,4 @@
+const o = Symbol("form");
+export {
+  o as FORM_PROVIDE_VALUE
+};

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

@@ -0,0 +1,15 @@
+export interface UiFormProps {
+    model?: Record<string, string | unknown>;
+    rules?: UiFormRules;
+}
+export interface UiFormRules {
+    [key: string]: UiFormRule[];
+}
+export interface UiFormRule {
+    required?: boolean;
+    min?: number;
+    max?: number;
+    email?: boolean;
+    validator?: () => boolean;
+    message: string;
+}

package/dist/components/UiForm/types.js

@@ -0,0 +1 @@
+

package/dist/components/UiForm/useValidate.d.ts

@@ -0,0 +1,5 @@
+import { UiFormRule } from './types';
+export declare function useValidation(models: Record<string, unknown>): {
+    validation: (fieldName: string, fieldValue: string, rule: UiFormRule) => void;
+    errors: import('vue').Ref<Record<string, string[]>, Record<string, string[]>>;
+};

package/dist/components/UiForm/useValidate.js

@@ -0,0 +1,21 @@
+import { ref as a, onMounted as c } from "vue";
+import { rules as s } from "./validations.js";
+function m(l) {
+  const u = a({});
+  function f(t, e, o) {
+    for (const [n, r] of Object.entries(o))
+      s[n] && r ? i(s[n](e, r), t, o.message) : n === "validator" && i(r(), t, o.message);
+  }
+  function i(t, e, o) {
+    t ? u.value[e] = u.value[e].filter((n) => n !== o) : u.value[e].includes(o) || u.value[e].push(o);
+  }
+  return c(() => {
+    u.value = Object.keys(l).reduce(
+      (t, e) => (t[e] = [], t),
+      {}
+    );
+  }), { validation: f, errors: u };
+}
+export {
+  m as useValidation
+};

package/dist/components/UiForm/validations.d.ts

@@ -0,0 +1,4 @@
+import { UiFormRule } from './types';
+type RuleName = Exclude<keyof UiFormRule, "message" | "validator">;
+export declare const rules: Record<RuleName, (value: unknown, ruleValue?: unknown) => boolean>;
+export {};

package/dist/components/UiForm/validations.js

@@ -0,0 +1,21 @@
+const g = {
+  required: t,
+  min: e,
+  max: i,
+  email: u
+};
+function t(r) {
+  return Array.isArray(r) ? !!r.length : !!r;
+}
+function e(r, n) {
+  return String(r).length >= Number(n);
+}
+function i(r, n) {
+  return Number(n) >= String(r).length;
+}
+function u(r) {
+  return /^[^@]+@[^.@]+.[^.@]+$/.test(String(r));
+}
+export {
+  g as rules
+};

package/dist/components/UiFormItem/UiFormItem.js

@@ -0,0 +1,5 @@
+import { _ as m } from "../../chunks/UiFormItem.vue_vue_type_script_setup_true_lang-Bbr8B6FG.js";
+/* empty css                                                               */
+export {
+  m as default
+};

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

@@ -0,0 +1,26 @@
+import { UiFormItemProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        label?(_: {}): any;
+        default?(_: {
+            id: string | undefined;
+        }): any;
+        notation?(_: {}): any;
+    };
+    refs: {
+        formItemRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UiFormItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UiFormItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    formItemRef: HTMLDivElement;
+}, 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/UiFormItem/types.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+import { UiFormRules } from '../UiForm/types';
+export interface UiFormItemProps {
+    label?: string;
+    name?: string;
+    notation?: string;
+    error?: string;
+    id?: string;
+}
+export interface UiFormItemProvideData {
+    model?: Record<string, string>;
+    rules?: UiFormRules;
+    errors: Record<string, string[]>;
+    validateField: (value: string) => void;
+    formSubmitCounts: Ref<number>;
+}

package/dist/components/UiFormItem/types.js

@@ -0,0 +1 @@
+

package/dist/components/UiIcon/UiIcon.js

@@ -0,0 +1,5 @@
+import { _ as m } from "../../chunks/UiIcon.vue_vue_type_script_setup_true_lang-CP1bPN5o.js";
+/* empty css                                                           */
+export {
+  m as default
+};

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

@@ -0,0 +1,6 @@
+import { UiIconProps } from './types';
+declare const _default: import('vue').DefineComponent<UiIconProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UiIconProps> & Readonly<{}>, {
+    size: import('./types').UiIconSize;
+    color: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,8 @@
+export type UiIconType = "100" | "400" | "filled" | "social";
+export type UiIconSize = "fill" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+export interface UiIconProps {
+    name: string;
+    type: UiIconType;
+    size?: UiIconSize;
+    color?: string;
+}

package/dist/components/UiIcon/types.js

@@ -0,0 +1 @@
+

package/dist/components/UiIconButton/UiIconButton.js

@@ -0,0 +1,5 @@
+import { _ as m } from "../../chunks/UiIconButton.vue_vue_type_script_setup_true_lang-BBWg01iF.js";
+import "../../chunks/style-CD0jFgS4.js";
+export {
+  m as default
+};

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

@@ -0,0 +1,14 @@
+import { UiIconButtonProps } from './types';
+declare const _default: import('vue').DefineComponent<UiIconButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UiIconButtonProps> & Readonly<{}>, {
+    size: import('./types').UiIconButtonSize;
+    type: import('./types').UiIconButtonType;
+    mode: import('./types').UiIconButtonMode;
+    nativeType: import('./types').UiIconButtonNativeType;
+    loading: boolean;
+    to: string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric;
+    href: string;
+    iconName: string;
+    iconType: import('../UiIcon/types').UiIconType;
+    noSize: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,21 @@
+import { RouteLocationAsPathGeneric, RouteLocationAsRelativeGeneric } from 'vue-router';
+import { UiIconType } from '../UiIcon/types';
+export type UiIconButtonMode = "square" | "circle";
+export type UiIconButtonNativeType = "button" | "submit" | "reset";
+export type UiIconButtonSize = "xs" | "sm" | "md" | "lg" | "xl";
+export type UiIconButtonType = "contrast" | "accent" | "tint" | "positive" | "positive-tint" | "negative" | "negative-tint" | "clear";
+export interface UiIconButtonProps {
+    mode?: UiIconButtonMode;
+    type?: UiIconButtonType;
+    size?: UiIconButtonSize;
+    iconName: string;
+    iconType?: UiIconType;
+    iconColor?: string;
+    disabled?: boolean;
+    loading?: boolean;
+    noSize?: boolean;
+    to?: string | RouteLocationAsRelativeGeneric | RouteLocationAsPathGeneric;
+    href?: string;
+    nativeType?: UiIconButtonNativeType;
+    containerSmall?: boolean;
+}

package/dist/components/UiIconButton/types.js

@@ -0,0 +1 @@
+

package/dist/components/UiInput/UiInput.js

@@ -0,0 +1,5 @@
+import { _ as m } from "../../chunks/UiInput.vue_vue_type_script_setup_true_lang-CT3b77Nb.js";
+import "../../chunks/style-CD0jFgS4.js";
+export {
+  m as default
+};

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

@@ -0,0 +1,51 @@
+import { InputProps } from './types';
+type __VLS_Props = InputProps;
+type __VLS_PublicProps = {
+    "modelValue"?: string | null | number | undefined;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        prepend?(_: {}): any;
+        append?(_: {}): any;
+    };
+    refs: {
+        prependRef: HTMLDivElement;
+        inputRef: HTMLInputElement;
+        appendRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    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, import('vue').PublicProps, Readonly<__VLS_PublicProps> & 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;
+}>, {
+    size: import('./types').InputSize;
+    type: string;
+    autocomplete: string;
+    indexTab: string;
+    step: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    prependRef: HTMLDivElement;
+    inputRef: HTMLInputElement;
+    appendRef: HTMLDivElement;
+}, 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/UiInput/types.d.ts

@@ -0,0 +1,22 @@
+export type InputSize = "sm" | "md" | "lg" | "xl";
+export interface InputProps {
+    isDisabled?: boolean;
+    placeholder?: string;
+    label?: string;
+    size?: InputSize;
+    filled?: boolean;
+    error?: boolean;
+    disabled?: boolean;
+    inside?: boolean;
+    type?: string;
+    readonly?: boolean;
+    autofocus?: boolean;
+    clearable?: boolean;
+    isEmptyValueNull?: boolean;
+    id?: string;
+    indexTab?: string;
+    autocomplete?: string;
+    showPassword?: boolean;
+    name?: string;
+    step?: string;
+}

package/dist/components/UiInput/types.js

@@ -0,0 +1 @@
+

package/dist/components/UiLanguages/UiLanguages.js

@@ -0,0 +1,5 @@
+import { _ as m } from "../../chunks/UiLanguages.vue_vue_type_script_setup_true_lang-D99OANJy.js";
+import "../../chunks/style-CD0jFgS4.js";
+export {
+  m as default
+};

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

@@ -0,0 +1,263 @@
+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 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: {
+                [x: string]: unknown;
+            };
+            $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;
+                autocomplete: string;
+                indexTab: 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;
+            autocomplete: string;
+            indexTab: 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" | "autocomplete" | "indexTab" | "step")> & import('vue').ShallowUnwrapRef<{
+            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 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: {
+            [x: string]: unknown;
+        };
+        $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;
+            autocomplete: string;
+            indexTab: 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;
+        autocomplete: string;
+        indexTab: 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" | "autocomplete" | "indexTab" | "step")> & import('vue').ShallowUnwrapRef<{
+        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.js

@@ -0,0 +1,4 @@
+import { _ as f } from "../../../chunks/UiLanguageButton.vue_vue_type_script_setup_true_lang-BbBju8fJ.js";
+export {
+  f as default
+};

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/UiLanguages/types.js

@@ -0,0 +1 @@
+

package/dist/components/UiLayout/UiLayout.js

@@ -0,0 +1,5 @@
+import { _ as m } from "../../chunks/UiLayout.vue_vue_type_script_setup_true_lang-CELUDfDH.js";
+/* empty css                                                             */
+export {
+  m as default
+};