@ironsource/shared-ui 2.0.0-rc.5 → 2.0.0-rc.7

package/components/table-cells/v3/Editable.vue.js

@@ -0,0 +1,7 @@
+import e from "./Editable.vue2.js";
+/* empty css               */import o from "../../../_virtual/_plugin-vue_export-helper.js";
+// import "../../../Editable.vue_vue_type_style_index_0_scoped_2561e913_lang.css"; //*');
+const p = /* @__PURE__ */ o(e, [["__scopeId", "data-v-2561e913"]]);
+export {
+  p as default
+};

package/components/table-cells/v3/Editable.vue2.js

@@ -0,0 +1,43 @@
+ import "../../../Editable.vue_vue_type_style_index_0_scoped_2561e913_lang.css"; import { defineComponent as u, openBlock as i, createElementBlock as a, unref as e, createElementVNode as m, renderSlot as s, createVNode as p, withCtx as y, createTextVNode as g, toDisplayString as k } from "vue";
+import E from "../../typography/Text.vue.js";
+import { editableCommon as _ } from "../common/Editable.common.js";
+const v = { class: "editable-container" }, x = {
+  key: 1,
+  class: "editable-content"
+}, N = /* @__PURE__ */ u({
+  __name: "Editable",
+  props: {
+    cell: { default: "" },
+    isEditing: { type: Boolean, default: !1 },
+    validateFunction: { type: Function, default: () => !1 },
+    isLoading: { type: Boolean, default: !1 },
+    rowIndex: null,
+    cellIndex: null
+  },
+  setup(t) {
+    const r = t, { onEdit: o, target: d, isEditing: c } = _(r);
+    return (n, l) => (i(), a("div", {
+      ref_key: "target",
+      ref: d,
+      class: "container",
+      onClick: l[0] || (l[0] = //@ts-ignore
+      (...f) => e(o) && e(o)(...f))
+    }, [
+      m("div", v, [
+        e(c) ? s(n.$slots, "input", { key: 0 }, void 0, !0) : (i(), a("div", x, [
+          s(n.$slots, "content", {}, () => [
+            p(E, { size: "sm" }, {
+              default: y(() => [
+                g(k(t.cell), 1)
+              ]),
+              _: 1
+            })
+          ], !0)
+        ]))
+      ])
+    ], 512));
+  }
+});
+export {
+  N as default
+};

package/components/table-cells/{index.d.ts → v3/index.d.ts}

@@ -1,4 +1,4 @@
-declare const EditableTypes: () => (import("vue").InjectionKey<import("./EditableContext").EditableContextProps> | ({
+declare const EditableTypes: () => (import("vue").InjectionKey<import("../common/EditableContext").EditableContextProps> | ({
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;
         $data: {};
@@ -162,5 +162,5 @@ declare const EditableTypes: () => (import("vue").InjectionKey<import("./Editabl
     };
 })))[];
 export { default as Editable } from './Editable.vue';
-export { EditableContext, useEditableContext } from './EditableContext';
+export { EditableContext, useEditableContext } from '../common/EditableContext';
 export { EditableTypes };

package/components/table-cells/{index.js → v3/index.js}

@@ -1,6 +1,6 @@
 import t from "./Editable.vue.js";
-import { EditableContext as e } from "./EditableContext.js";
-import { useEditableContext as a } from "./EditableContext.js";
+import { EditableContext as e } from "../common/EditableContext.js";
+import { useEditableContext as a } from "../common/EditableContext.js";
 const i = () => [t, e];
 export {
   t as Editable,

package/components/table-cells/v4/EditableV4.vue.d.ts

@@ -0,0 +1,51 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    cell?: string;
+    isLoading?: boolean;
+    rowIndex: number;
+    cellIndex: number;
+    validateFunction?: (value: unknown) => string | boolean;
+}>, {
+    cell: string;
+    isLoading: boolean;
+    validateFunction: () => false;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    cell?: string;
+    isLoading?: boolean;
+    rowIndex: number;
+    cellIndex: number;
+    validateFunction?: (value: unknown) => string | boolean;
+}>, {
+    cell: string;
+    isLoading: boolean;
+    validateFunction: () => false;
+}>>>, {
+    cell: string;
+    validateFunction: (value: unknown) => string | boolean;
+    isLoading: boolean;
+}>, {
+    input?(_: {}): any;
+    content?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/table-cells/v4/EditableV4.vue.js

@@ -0,0 +1,7 @@
+import o from "./EditableV4.vue2.js";
+/* empty css                 */import e from "../../../_virtual/_plugin-vue_export-helper.js";
+// import "../../../EditableV4.vue_vue_type_style_index_0_scoped_df325b51_lang.css"; //*');
+const d = /* @__PURE__ */ e(o, [["__scopeId", "data-v-df325b51"]]);
+export {
+  d as default
+};

package/components/table-cells/v4/EditableV4.vue2.js

@@ -0,0 +1,45 @@
+ import "../../../EditableV4.vue_vue_type_style_index_0_scoped_df325b51_lang.css"; import { defineComponent as u, openBlock as r, createElementBlock as a, unref as e, createElementVNode as m, renderSlot as i, createVNode as d, withCtx as y, createTextVNode as b, toDisplayString as g } from "vue";
+import { editableCommon as k } from "../common/Editable.common.js";
+import _ from "../../typography/v4/Typography.vue.js";
+import v from "../../input/v4/TextField.vue.js";
+const x = { class: "editable-wrapper" }, E = {
+  key: 1,
+  class: "editable-content"
+}, B = /* @__PURE__ */ u({
+  __name: "EditableV4",
+  props: {
+    cell: { default: "" },
+    isLoading: { type: Boolean, default: !1 },
+    rowIndex: null,
+    cellIndex: null,
+    validateFunction: { type: Function, default: () => !1 }
+  },
+  setup(t) {
+    const s = t, { onEdit: o, target: c, isEditing: p } = k(s);
+    return (n, l) => (r(), a("div", {
+      ref_key: "target",
+      ref: c,
+      class: "editable",
+      onClick: l[0] || (l[0] = //@ts-ignore
+      (...f) => e(o) && e(o)(...f))
+    }, [
+      m("div", x, [
+        e(p) ? i(n.$slots, "input", { key: 0 }, () => [
+          d(e(v))
+        ], !0) : (r(), a("div", E, [
+          i(n.$slots, "content", {}, () => [
+            d(e(_), { variant: "body1" }, {
+              default: y(() => [
+                b(g(t.cell), 1)
+              ]),
+              _: 1
+            })
+          ], !0)
+        ]))
+      ])
+    ], 512));
+  }
+});
+export {
+  B as default
+};

package/components/table-cells/v4/index.d.ts

@@ -0,0 +1,146 @@
+import Editable from './EditableV4.vue';
+declare const EditableTypes: () => ({
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            cell: string;
+            validateFunction: (value: unknown) => string | boolean;
+            isLoading: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            cell: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            validateFunction: {
+                type: import("vue").PropType<(value: unknown) => string | boolean>;
+                default: () => false;
+            };
+            isLoading: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            rowIndex: {
+                type: import("vue").PropType<number>;
+                required: true;
+            };
+            cellIndex: {
+                type: import("vue").PropType<number>;
+                required: true;
+            };
+        }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "cell" | "validateFunction" | "isLoading">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            cell: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            validateFunction: {
+                type: import("vue").PropType<(value: unknown) => string | boolean>;
+                default: () => false;
+            };
+            isLoading: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            rowIndex: {
+                type: import("vue").PropType<number>;
+                required: true;
+            };
+            cellIndex: {
+                type: import("vue").PropType<number>;
+                required: true;
+            };
+        }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            cell: string;
+            validateFunction: (value: unknown) => string | boolean;
+            isLoading: boolean;
+        }, {}, string> & {
+            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<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, 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_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        cell: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        validateFunction: {
+            type: import("vue").PropType<(value: unknown) => string | boolean>;
+            default: () => false;
+        };
+        isLoading: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+        rowIndex: {
+            type: import("vue").PropType<number>;
+            required: true;
+        };
+        cellIndex: {
+            type: import("vue").PropType<number>;
+            required: true;
+        };
+    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    cell: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    validateFunction: {
+        type: import("vue").PropType<(value: unknown) => string | boolean>;
+        default: () => false;
+    };
+    isLoading: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    rowIndex: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+    cellIndex: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    cell: string;
+    validateFunction: (value: unknown) => string | boolean;
+    isLoading: boolean;
+}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        input?(_: {}): any;
+        content?(_: {}): any;
+    };
+}))[];
+export { Editable, EditableTypes };

package/components/table-cells/v4/index.js

@@ -0,0 +1,6 @@
+import t from "./EditableV4.vue.js";
+const o = () => [t];
+export {
+  t as Editable,
+  o as EditableTypes
+};

package/components/tabs/common/Tabs.types.d.ts

@@ -0,0 +1,6 @@
+export type Tab = {
+    id: number | string;
+    name: string;
+    iconName: string;
+    disabled?: boolean;
+};

package/components/tabs/common/tabsCommon.d.ts

@@ -0,0 +1,16 @@
+import { Tab } from '@is-ssp/tabs/common/Tabs.types';
+export declare const tabsCommon: (props: any, emit: any) => {
+    skipUnwrap: {
+        tabsNewList: import("vue").Ref<any[]>;
+    };
+    isHovered: import("vue").ComputedRef<boolean>;
+    selectedTabPosition: import("vue").ComputedRef<string>;
+    selectedTabWidth: import("vue").ComputedRef<string>;
+    selectedTabCenter: import("vue").ComputedRef<string>;
+    hoveredTabCenter: import("vue").ComputedRef<string>;
+    selectTab: (tab: Tab) => void;
+    setHover: (tab: Tab) => void;
+    clearHover: () => void;
+    tabsNewList: import("vue").Ref<any[]>;
+    getSelectedTabIndex: () => any;
+};

package/components/tabs/common/tabsCommon.js

@@ -0,0 +1,43 @@
+import { ref as d, computed as s } from "vue";
+const g = (o, l) => {
+  const t = d([]), n = d(null), a = 12, i = { tabsNewList: t }, u = s(
+    () => n.value && n.value !== o.selectedTab
+  ), v = s(() => {
+    const e = c();
+    return t.value[e]?.offsetLeft + "px";
+  }), c = () => o.tabsList.findIndex((e) => e.id === o.selectedTab), b = s(() => {
+    const e = c();
+    return t.value[e]?.clientWidth + "px";
+  }), r = (e) => {
+    const h = t.value[e]?.offsetLeft, m = t.value[e]?.clientWidth;
+    return (parseFloat(h) + parseFloat(m) / 2 - a).toString() + "px";
+  }, f = s(() => {
+    const e = c();
+    return r(e);
+  }), T = () => o.tabsList.findIndex((e) => e.id === n.value), x = s(() => {
+    const e = T();
+    return r(e);
+  });
+  return {
+    skipUnwrap: i,
+    isHovered: u,
+    selectedTabPosition: v,
+    selectedTabWidth: b,
+    selectedTabCenter: f,
+    hoveredTabCenter: x,
+    selectTab: (e) => {
+      l("update:selectedTab", e.id);
+    },
+    setHover: (e) => {
+      e !== null && (n.value = e.id);
+    },
+    clearHover: () => {
+      n.value = null;
+    },
+    tabsNewList: t,
+    getSelectedTabIndex: c
+  };
+};
+export {
+  g as tabsCommon
+};

package/components/tabs/{Tabs.vue.d.ts → v3/Tabs.vue.d.ts}

@@ -1,9 +1,4 @@
-type Tab = {
-    id: number | string;
-    name: string;
-    iconName: string;
-    disabled?: boolean;
-};
+import { Tab } from '@/components/tabs/common/Tabs.types';
 declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     tabsList: Tab[];
     selectedTab: string | number;

package/components/tabs/v3/Tabs.vue.js

@@ -0,0 +1,7 @@
+import o from "./Tabs.vue2.js";
+/* empty css           */import _ from "../../../_virtual/_plugin-vue_export-helper.js";
+// import "../../../Tabs.vue_vue_type_style_index_0_scoped_06c58d5a_lang.css"; //*');
+const a = /* @__PURE__ */ _(o, [["__scopeId", "data-v-06c58d5a"]]);
+export {
+  a as default
+};

package/components/tabs/v3/Tabs.vue2.js

@@ -0,0 +1,85 @@
+ import "../../../Tabs.vue_vue_type_style_index_0_scoped_06c58d5a_lang.css"; import { defineComponent as z, useCssVars as N, unref as e, openBlock as o, createElementBlock as a, normalizeClass as i, Fragment as w, renderList as x, renderSlot as y, createBlock as m, createCommentVNode as n, withCtx as S, createTextVNode as B, toDisplayString as L, pushScopeId as M, popScopeId as V, createElementVNode as g } from "vue";
+import "../../typography/Heading.vue.js";
+import E from "../../typography/Text.vue.js";
+import H from "../../icon/v3/Icon.vue.js";
+import { TabsTestIdModifiers as u } from "../../../testids/index.js";
+import { tabsCommon as P } from "../common/tabsCommon.js";
+const A = (t) => (M("data-v-06c58d5a"), t = t(), V(), t), R = ["data-testid"], W = ["data-testid", "onClick", "onMouseover"], D = /* @__PURE__ */ A(() => /* @__PURE__ */ g("div", { class: "tabs-border-line" }, null, -1)), F = {
+  key: 0,
+  class: "tabs-border-line-hover"
+}, K = /* @__PURE__ */ z({
+  __name: "Tabs",
+  props: {
+    tabsList: { default: () => [] },
+    selectedTab: null,
+    variant: { default: "fill" },
+    size: { default: "sm" },
+    testId: { default: "" }
+  },
+  emits: ["update:selectedTab"],
+  setup(t, { emit: f }) {
+    const v = t;
+    N((l) => ({
+      "31d21add": e(p),
+      "6c412892": e(k),
+      "0ce1a9ee": e(C),
+      "4e3ce556": e(h)
+    }));
+    const {
+      skipUnwrap: b,
+      isHovered: T,
+      selectedTabPosition: p,
+      selectedTabWidth: k,
+      selectedTabCenter: C,
+      hoveredTabCenter: h,
+      selectTab: I,
+      setHover: $,
+      clearHover: r
+    } = P(v, f);
+    return (l, c) => (o(), a("ul", {
+      class: i(["tabs-wrap", [t.size, t.variant]]),
+      "data-testid": `${t.testId}-${e(u).WRAPPER}`
+    }, [
+      (o(!0), a(w, null, x(t.tabsList, (s) => (o(), a("li", {
+        ref_for: !0,
+        ref: e(b).tabsNewList,
+        key: s.id,
+        class: i(["tab-item", {
+          "disabled-tab": s.disabled,
+          "selected-tab": s.id === t.selectedTab
+        }]),
+        "data-testid": `${t.testId}-${e(u).TAB}-${s.id}`,
+        onClick: (d) => e(I)(s),
+        onMouseover: (d) => e($)(s),
+        onMouseleave: c[0] || (c[0] = //@ts-ignore
+        (...d) => e(r) && e(r)(...d))
+      }, [
+        y(l.$slots, "default", { tab: s }, () => [
+          s.iconName ? (o(), m(e(H), {
+            key: 0,
+            name: s.iconName,
+            class: i(["tab-icon", {
+              size: t.size,
+              "lone-icon": !s.name
+            }])
+          }, null, 8, ["name", "class"])) : n("", !0),
+          s.name ? (o(), m(e(E), {
+            key: 1,
+            size: "sm",
+            strong: ""
+          }, {
+            default: S(() => [
+              B(L(s.name), 1)
+            ]),
+            _: 2
+          }, 1024)) : n("", !0)
+        ], !0)
+      ], 42, W))), 128)),
+      D,
+      e(T) ? (o(), a("div", F)) : n("", !0)
+    ], 10, R));
+  }
+});
+export {
+  K as default
+};

package/components/tabs/{index.d.ts → v3/index.d.ts}

@@ -6,12 +6,7 @@ declare const TabsTypes: () => ({
             size: "sm" | "md" | "lg" | "xl";
             testId: string;
             variant: "fill" | "fix";
-            tabsList: {
-                id: string | number;
-                name: string;
-                iconName: string;
-                disabled?: boolean;
-            }[];
+            tabsList: import("../common/Tabs.types").Tab[];
         }> & Omit<Readonly<import("vue").ExtractPropTypes<{
             size: {
                 type: import("vue").PropType<"sm" | "md" | "lg" | "xl">;
@@ -26,12 +21,7 @@ declare const TabsTypes: () => ({
                 default: string;
             };
             tabsList: {
-                type: import("vue").PropType<{
-                    id: string | number;
-                    name: string;
-                    iconName: string;
-                    disabled?: boolean;
-                }[]>;
+                type: import("vue").PropType<import("../common/Tabs.types").Tab[]>;
                 required: true;
                 default: () => any[];
             };
@@ -69,12 +59,7 @@ declare const TabsTypes: () => ({
                 default: string;
             };
             tabsList: {
-                type: import("vue").PropType<{
-                    id: string | number;
-                    name: string;
-                    iconName: string;
-                    disabled?: boolean;
-                }[]>;
+                type: import("vue").PropType<import("../common/Tabs.types").Tab[]>;
                 required: true;
                 default: () => any[];
             };
@@ -90,12 +75,7 @@ declare const TabsTypes: () => ({
             size: "sm" | "md" | "lg" | "xl";
             testId: string;
             variant: "fill" | "fix";
-            tabsList: {
-                id: string | number;
-                name: string;
-                iconName: string;
-                disabled?: boolean;
-            }[];
+            tabsList: import("../common/Tabs.types").Tab[];
         }, {}, string> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
@@ -130,12 +110,7 @@ declare const TabsTypes: () => ({
             default: string;
         };
         tabsList: {
-            type: import("vue").PropType<{
-                id: string | number;
-                name: string;
-                iconName: string;
-                disabled?: boolean;
-            }[]>;
+            type: import("vue").PropType<import("../common/Tabs.types").Tab[]>;
             required: true;
             default: () => any[];
         };
@@ -163,12 +138,7 @@ declare const TabsTypes: () => ({
         default: string;
     };
     tabsList: {
-        type: import("vue").PropType<{
-            id: string | number;
-            name: string;
-            iconName: string;
-            disabled?: boolean;
-        }[]>;
+        type: import("vue").PropType<import("../common/Tabs.types").Tab[]>;
         required: true;
         default: () => any[];
     };
@@ -184,21 +154,11 @@ declare const TabsTypes: () => ({
     size: "sm" | "md" | "lg" | "xl";
     testId: string;
     variant: "fill" | "fix";
-    tabsList: {
-        id: string | number;
-        name: string;
-        iconName: string;
-        disabled?: boolean;
-    }[];
+    tabsList: import("../common/Tabs.types").Tab[];
 }, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
     $slots: {
         default?(_: {
-            tab: {
-                id: string | number;
-                name: string;
-                iconName: string;
-                disabled?: boolean;
-            };
+            tab: import("../common/Tabs.types").Tab;
         }): any;
     };
 }))[];

package/components/tabs/v4/TabsV4.vue.d.ts

@@ -0,0 +1,56 @@
+import { Tab } from '@/components/tabs/common/Tabs.types';
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    tabsList: Tab[];
+    selectedTab: string | number;
+    variant?: "page" | "card";
+    testId?: string;
+}>, {
+    tabsList: () => any[];
+    variant: string;
+    testId: string;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:selectedTab": (tabId: string | number) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    tabsList: Tab[];
+    selectedTab: string | number;
+    variant?: "page" | "card";
+    testId?: string;
+}>, {
+    tabsList: () => any[];
+    variant: string;
+    testId: string;
+}>>> & {
+    "onUpdate:selectedTab"?: (tabId: string | number) => any;
+}, {
+    testId: string;
+    variant: "page" | "card";
+    tabsList: Tab[];
+}>, {
+    "tab-icon"?(_: {
+        tab: Tab;
+        active: boolean;
+    }): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};