@dv.net/ui-kit 7.6.0 → 7.6.1

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

@@ -0,0 +1,22 @@
+import { Component } from 'vue';
+import { AvatarStatusType } from '../UiAvatar/types';
+import { UiIconType } from '../UiIcon/types';
+export interface ProfileMenuItem {
+    name?: string;
+    iconName?: string;
+    iconColor?: string;
+    iconType?: UiIconType;
+    animationIcon?: Component;
+    label?: string;
+    isShow?: boolean;
+    isActive?: boolean;
+    action?: () => void;
+    class?: () => string;
+    id?: () => string;
+}
+export interface UiProfileMenuProps {
+    userEmail: string | null;
+    status?: AvatarStatusType;
+    menuItems: ProfileMenuItem[][];
+    avatar?: string;
+}

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

@@ -0,0 +1,21 @@
+import { UiRadioProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        subtitle?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLLabelElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UiRadioProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UiRadioProps> & Readonly<{}>, {
+    size: import('./types').UiRadioSize;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLabelElement>;
+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/UiRadio/types.d.ts

@@ -0,0 +1,6 @@
+export type UiRadioSize = "sm" | "md";
+export interface UiRadioProps {
+    size?: UiRadioSize;
+    value: string | number;
+    disabled?: boolean;
+}

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

@@ -0,0 +1,30 @@
+import { UiRadioGroupProps } from './types';
+type __VLS_Props = UiRadioGroupProps;
+type __VLS_PublicProps = {
+    modelValue?: string | number;
+} & __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: string | number) => any;
+    change: (value: string | number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+    onChange?: ((value: string | number) => any) | undefined;
+}>, {
+    size: import('../UiRadio/types').UiRadioSize;
+}, {}, {}, {}, 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/UiRadioGroup/constants.d.ts

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

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

@@ -0,0 +1,12 @@
+import { ComputedRef, Ref } from 'vue';
+import { UiRadioSize } from '../UiRadio/types';
+export interface UiRadioGroupProps {
+    disabled?: boolean;
+    size?: UiRadioSize;
+}
+export interface UiRadioGroupProvideData {
+    modelValue: Ref<string | number>;
+    disabled?: ComputedRef<boolean>;
+    change: (value: string | number) => void;
+    size?: ComputedRef<UiRadioSize>;
+}

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

@@ -0,0 +1,39 @@
+import { UiSelectProps } from './types.ts';
+declare const _default: <ModelValue, Options>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onClear?: ((...args: any[]) => any) | undefined;
+        readonly onSearch?: ((...args: any[]) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: ModelValue | null) => any) | undefined;
+        readonly onChange?: ((...args: any[]) => any) | undefined;
+        readonly onOnClose?: ((...args: any[]) => any) | undefined;
+        readonly onChangeInfinityScroll?: ((...args: any[]) => any) | undefined;
+        readonly "onUpdate:isOpen"?: ((value: boolean) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onChange" | "onUpdate:modelValue" | "onClear" | "onChangeInfinityScroll" | "onSearch" | "onOnClose" | "onUpdate:isOpen"> & ({
+        modelValue?: ModelValue | null;
+        isOpen?: boolean;
+    } & UiSelectProps<Options>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        selected?(_: {
+            option: ModelValue;
+        }): any;
+        header?(_: {}): any;
+        default?(_: {
+            option: Options;
+            checked: boolean;
+        }): any;
+        default?(_: {
+            option: Options;
+            checked: boolean;
+        }): any;
+        footer?(_: {}): any;
+    };
+    emit: ((event: "clear" | "search" | "change" | "onClose" | "changeInfinityScroll", ...args: any[]) => void) & (((evt: "update:modelValue", value: ModelValue | null) => void) & ((evt: "update:isOpen", value: boolean) => void));
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/UiSelect/components/SelectList.vue.d.ts

@@ -0,0 +1,22 @@
+declare const _default: <Options>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & {
+        options: Options[];
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?(_: {
+            options: {
+                index: number;
+                data: Options;
+            }[];
+        }): any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/UiSelect/components/SelectListItem.vue.d.ts

@@ -0,0 +1,32 @@
+import { SelectListItemSizeKeys } from '../types';
+interface UiSelectListItemProps {
+    isDisabled: boolean;
+    isChecked: boolean;
+    isNavigated: boolean;
+    size?: SelectListItemSizeKeys;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<UiSelectListItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    check: (...args: any[]) => void;
+    mouseOver: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<UiSelectListItemProps> & Readonly<{
+    onCheck?: ((...args: any[]) => any) | undefined;
+    onMouseOver?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: SelectListItemSizeKeys;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+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/UiSelect/components/SelectSearch.vue.d.ts

@@ -0,0 +1,124 @@
+type __VLS_Props = {
+    placeholder?: string;
+};
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, 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 import('vue').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>;
+export default _default;

package/dist/components/UiSelect/components/SelectTrigger.vue.d.ts

@@ -0,0 +1,33 @@
+import { UiIconSize } from '../../UiIcon/types';
+import { SelectType } from '../types';
+interface UiSelectTriggerProps {
+    isActive: boolean;
+    type: SelectType;
+    placeholder: string | undefined;
+    clearable: boolean;
+    isHasValue: boolean;
+    chevronName: string;
+    chevronColor: string;
+    chevronSize: UiIconSize;
+}
+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<UiSelectTriggerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<UiSelectTriggerProps> & Readonly<{
+    onClear?: ((...args: any[]) => 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/UiSelect/components/SelectVirtualList.vue.d.ts

@@ -0,0 +1,27 @@
+import { SelectListItemSizeKeys } from '../types';
+declare const _default: <Options>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onChangeInfinityScroll?: ((...args: any[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onChangeInfinityScroll"> & {
+        options: Options[];
+        size: SelectListItemSizeKeys;
+        isLoading: boolean;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?(_: {
+            item: {
+                index: number;
+                option: Options;
+            };
+        }): any;
+    };
+    emit: (event: "changeInfinityScroll", ...args: any[]) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/UiSelect/composables/useKeyboard.d.ts

@@ -0,0 +1,11 @@
+import { ComputedRef, Ref } from 'vue';
+export declare function useKeyboard<Options>({ isFocus, checkOption, filteredOptions }: {
+    isFocus: Ref<boolean>;
+    checkOption: (value: unknown) => void;
+    filteredOptions: ComputedRef<Options[]>;
+}): {
+    onKeydownEnter: () => void;
+    onKeydownDown: () => void;
+    onKeydownUp: () => void;
+    navigatedIndex: Ref<number | null, number | null>;
+};

package/dist/components/UiSelect/composables/useMultiple.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+export declare function useMultiple(modelValue: Ref<string[]>): {
+    setModelValueItem: (value: string) => void;
+};

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

@@ -0,0 +1,43 @@
+import { OffsetOptions } from '@floating-ui/vue';
+import { UiIconSize } from '../UiIcon/types';
+import { UiPlacementType } from '../UiTooltip/types.ts';
+export declare enum SelectListItemSize {
+    sm = 44,
+    md = 52,
+    lg = 56,
+    xl = 60
+}
+export type SelectSize = "sm" | "md" | "lg" | "xl";
+export type SelectListItemSizeKeys = keyof typeof SelectListItemSize;
+export type SelectType = "default" | "inside" | "outside";
+export interface UiSelectProps<Options> {
+    options: Options[];
+    valueKey?: string;
+    labelKey?: string;
+    asObject?: boolean;
+    type?: SelectType;
+    size?: string;
+    error?: boolean;
+    filled?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    withSearch?: boolean;
+    clearable?: boolean;
+    loading?: boolean;
+    id?: string;
+    multiple?: boolean;
+    itemSize?: SelectListItemSizeKeys;
+    popperClass?: string;
+    fitContentWidth?: boolean;
+    offset?: OffsetOptions;
+    placement?: UiPlacementType;
+    readonly?: boolean;
+    teleport?: string | boolean;
+    isVirtualList?: boolean;
+    customSearch?: boolean;
+    chevronName?: string;
+    chevronColor?: string;
+    chevronSize?: UiIconSize;
+    optionClass?: (option: Options, index: number) => string;
+    searchFn?: (search: string) => Options[];
+}

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

@@ -0,0 +1,11 @@
+import { UISkeletonProps } from './types';
+declare const _default: import('vue').DefineComponent<UISkeletonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UISkeletonProps> & Readonly<{}>, {
+    rows: number;
+    animated: boolean;
+    rowHeight: number;
+    itemBorderRadius: number;
+    rowsGap: number;
+    firstColor: string;
+    secondColor: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,9 @@
+export type UISkeletonProps = {
+    animated?: boolean;
+    rows?: number;
+    rowHeight?: number;
+    itemBorderRadius?: number;
+    rowsGap?: number;
+    firstColor?: string;
+    secondColor?: string;
+};

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

@@ -0,0 +1,17 @@
+import { UiSwitchProps } from './types';
+type __VLS_Props = UiSwitchProps;
+type __VLS_PublicProps = {
+    modelValue?: boolean;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    "update:modelValue": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    loading: boolean;
+    textPositionRight: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLabelElement>;
+export default _default;

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

@@ -0,0 +1,8 @@
+export interface UiSwitchProps {
+    disabled?: boolean;
+    loading?: boolean;
+    label?: string;
+    text?: string;
+    textPositionRight?: boolean;
+    beforeChange?: () => Promise<boolean>;
+}

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

@@ -0,0 +1,64 @@
+import { UiPaginationMeta } from '../UiPagination/types.ts';
+import { UiTableProps, UiTableSortObject } from './types.ts';
+declare const _default: <Selected, Expanded, Data>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:disabled"?: ((value: Selected[]) => any) | undefined;
+        readonly "onUpdate:selected"?: ((value: Selected[]) => any) | undefined;
+        readonly "onUpdate:expanded"?: ((value: Expanded[]) => any) | undefined;
+        readonly "onUpdate:sort"?: ((value: UiTableSortObject) => any) | undefined;
+        readonly onSortChange?: ((value: UiTableSortObject) => any) | undefined;
+        readonly onRowClick?: ((row: Data) => any) | undefined;
+        readonly onChangePagination?: ((value: UiPaginationMeta) => any) | undefined;
+        readonly onIndeterminateChange?: ((value: boolean) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:disabled" | "onUpdate:selected" | "onUpdate:expanded" | "onUpdate:sort" | "onSortChange" | "onRowClick" | "onChangePagination" | "onIndeterminateChange"> & ({
+        disabled?: Selected[];
+        selected?: Selected[];
+        expanded?: Expanded[];
+        sort?: UiTableSortObject;
+    } & UiTableProps<Data>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<`header-cell-${string}`, (_: {
+        title: string | undefined;
+        header: import('./types.ts').UiTableHeader<Data>;
+    }) => any>> & Partial<Record<`header-cell-${string}-prepend`, (_: {}) => any>> & Partial<Record<`header-cell-${string}-append`, (_: {}) => any>> & Partial<Record<number, (_: {
+        key?: number;
+        summary: number | string;
+    }) => any>> & Partial<Record<`body-cell-${string}`, (_: {
+        row: Data;
+        index: number;
+    }) => any>> & Partial<Record<number, (_: {
+        key?: number;
+        summary: number | string;
+    }) => any>> & {
+        header?(_: {
+            headers: import('./types.ts').UiTableHeader<Data>[];
+        }): any;
+        'header-cell'?(_: {
+            title: string | undefined;
+            header: import('./types.ts').UiTableHeader<Data>;
+        }): any;
+        body?(_: {
+            row: Data;
+            headers: import('./types.ts').UiTableHeader<Data>[];
+            index: number;
+        }): any;
+        'body-cell'?(_: {
+            row: Data;
+            header: import('./types.ts').UiTableHeader<Data>;
+            index: number;
+        }): any;
+        expande?(_: {
+            row: Data;
+            index: number;
+        }): any;
+        footer?(_: {}): any;
+    };
+    emit: (((evt: "sortChange", value: UiTableSortObject) => void) & ((evt: "rowClick", row: Data) => void) & ((evt: "changePagination", value: UiPaginationMeta) => void) & ((evt: "indeterminateChange", value: boolean) => void)) & (((evt: "update:disabled", value: Selected[]) => void) & ((evt: "update:selected", value: Selected[]) => void) & ((evt: "update:expanded", value: Expanded[]) => void) & ((evt: "update:sort", value: UiTableSortObject) => void));
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/UiTable/components/TableSort.vue.d.ts

@@ -0,0 +1,27 @@
+import { UiTableSortOrder } from '../types.ts';
+type __VLS_PublicProps = {
+    modelValue?: UiTableSortOrder;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    sort: (...args: any[]) => void;
+    "update:modelValue": (value: UiTableSortOrder) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSort?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: UiTableSortOrder) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+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/UiTable/components/TableSummary.vue.d.ts

@@ -0,0 +1,26 @@
+import { PreparedData, UiTableHeader } from '../types.ts';
+declare const _default: <Data>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & {
+        emptyValue: string | boolean;
+        loading?: boolean;
+        headers: UiTableHeader<Data>[];
+        preparedData: PreparedData<Data>[];
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Partial<Record<`summary-cell-${string}`, (_: {
+        summary: string | number;
+    }) => any>> & {
+        'summary-cell'?(_: {
+            index: number;
+            header: UiTableHeader<Data>;
+        }): any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/UiTable/composables/useExpande.d.ts

@@ -0,0 +1,6 @@
+import { ComputedRef, Ref } from 'vue';
+import { PreparedData } from '../types.ts';
+export declare function useExpande<T>(data: ComputedRef<PreparedData<T>[]>, expandeModel: Ref<unknown[]>, expandeKey: string | undefined): {
+    expandeRow: (id: string, value: boolean) => void;
+    expandeObj: Ref<{}, {}>;
+};

package/dist/components/UiTable/composables/useSelected.d.ts

@@ -0,0 +1,9 @@
+import { ComputedRef, Ref } from 'vue';
+import { PreparedData } from '../types.ts';
+export declare function useSelected<T>(data: ComputedRef<PreparedData<T>[]>, selectedModel: Ref<unknown[]>, selectedKey: string | undefined): {
+    isAllSelected: ComputedRef<boolean>;
+    isIndeterminate: ComputedRef<boolean>;
+    selectRow: (id: string, value: boolean) => void;
+    selectAll: (value: boolean) => void;
+    selectedObject: Ref<{}, {}>;
+};

package/dist/components/UiTable/composables/useSort.d.ts

@@ -0,0 +1,9 @@
+import { ComputedRef, Ref } from 'vue';
+import { PreparedData, UiTableHeader, UiTableSortObject } from '../types';
+export declare function useSort<T>(preparedData: ComputedRef<PreparedData<T>[]>, sortObject: Ref<UiTableSortObject>, emptyValue: string | boolean, headers: UiTableHeader<T>[]): {
+    isCustomSortMode: Ref<boolean, boolean>;
+    sortedData: ComputedRef<PreparedData<T>[]>;
+    sortObject: Ref<UiTableSortObject, UiTableSortObject>;
+    isSorting: Ref<boolean, boolean>;
+    sort: ({ name, order }: UiTableSortObject, isCustomSort: boolean) => void;
+};