@vonage/vivid-vue 5.16.0 → 5.18.0

package/dist/generated/components/VTable.vue3.d.ts

@@ -3,45 +3,7 @@ import type { SlotsType } from 'vue';
 declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcTableElement | null, VwcTableElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcTableElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcTableElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcTableElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcTableElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcTableElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcTableElement;
-    }): true;
-}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcTableElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcTableElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcTableElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcTableElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableElement;
-    }) => any) | undefined;
-}>, {}, SlotsType<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
     default: Record<string, never>;
 }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

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

@@ -1,29 +1,4 @@
-import type { VwcTableBodyElement } from '@vonage/vivid';
 export interface VTableBodyEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcTableBodyElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcTableBodyElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcTableBodyElement;
-    };
-    'input': Event & {
-        currentTarget: VwcTableBodyElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcTableBodyElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcTableBodyElement;
-    };
 }
 export interface VTableBodyProps {
-    'onBlur'?: (event: VTableBodyEvents['blur']) => void;
-    'onClick'?: (event: VTableBodyEvents['click']) => void;
-    'onFocus'?: (event: VTableBodyEvents['focus']) => void;
-    'onInput'?: (event: VTableBodyEvents['input']) => void;
-    'onKeydown'?: (event: VTableBodyEvents['keydown']) => void;
-    'onKeyup'?: (event: VTableBodyEvents['keyup']) => void;
 }

package/dist/generated/components/VTableBody.vue2.d.ts

@@ -2,5 +2,5 @@ import type { VwcTableBodyElement } from '@vonage/vivid';
 declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcTableBodyElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup")[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, never[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

package/dist/generated/components/VTableBody.vue3.d.ts

@@ -3,45 +3,7 @@ import type { SlotsType } from 'vue';
 declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcTableBodyElement | null, VwcTableBodyElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcTableBodyElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcTableBodyElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcTableBodyElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcTableBodyElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcTableBodyElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcTableBodyElement;
-    }): true;
-}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcTableBodyElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcTableBodyElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcTableBodyElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcTableBodyElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableBodyElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableBodyElement;
-    }) => any) | undefined;
-}>, {}, SlotsType<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
     default: Record<string, never>;
 }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

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

@@ -1,33 +1,9 @@
 import type { VwcTableCellElement } from '@vonage/vivid';
 export interface VTableCellEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcTableCellElement;
-    };
     'cell-focused': CustomEvent<HTMLElement> & {
-        currentTarget: VwcTableCellElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcTableCellElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcTableCellElement;
-    };
-    'input': Event & {
-        currentTarget: VwcTableCellElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcTableCellElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcTableCellElement;
+        currentTarget: VwcTableCellElement | null;
     };
 }
 export interface VTableCellProps {
-    'onBlur'?: (event: VTableCellEvents['blur']) => void;
     'onCellFocused'?: (event: VTableCellEvents['cell-focused']) => void;
-    'onClick'?: (event: VTableCellEvents['click']) => void;
-    'onFocus'?: (event: VTableCellEvents['focus']) => void;
-    'onInput'?: (event: VTableCellEvents['input']) => void;
-    'onKeydown'?: (event: VTableCellEvents['keydown']) => void;
-    'onKeyup'?: (event: VTableCellEvents['keyup']) => void;
 }

package/dist/generated/components/VTableCell.vue2.d.ts

@@ -2,5 +2,5 @@ import type { VwcTableCellElement } from '@vonage/vivid';
 declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcTableCellElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup" | "cell-focused")[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "cell-focused"[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

package/dist/generated/components/VTableCell.vue3.d.ts

@@ -4,48 +4,12 @@ declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcTableCellElement | null, VwcTableCellElement | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcTableCellElement;
-    }): true;
     "cell-focused"(event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcTableCellElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcTableCellElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcTableCellElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcTableCellElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcTableCellElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcTableCellElement;
+        currentTarget: VwcTableCellElement | null;
     }): true;
 }, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcTableCellElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcTableCellElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcTableCellElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcTableCellElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableCellElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableCellElement;
-    }) => any) | undefined;
     "onCell-focused"?: ((event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcTableCellElement;
+        currentTarget: VwcTableCellElement | null;
     }) => any) | undefined;
 }>, {}, SlotsType<{
     default: Record<string, never>;

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

@@ -1,29 +1,4 @@
-import type { VwcTableHeadElement } from '@vonage/vivid';
 export interface VTableHeadEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcTableHeadElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcTableHeadElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcTableHeadElement;
-    };
-    'input': Event & {
-        currentTarget: VwcTableHeadElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcTableHeadElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcTableHeadElement;
-    };
 }
 export interface VTableHeadProps {
-    'onBlur'?: (event: VTableHeadEvents['blur']) => void;
-    'onClick'?: (event: VTableHeadEvents['click']) => void;
-    'onFocus'?: (event: VTableHeadEvents['focus']) => void;
-    'onInput'?: (event: VTableHeadEvents['input']) => void;
-    'onKeydown'?: (event: VTableHeadEvents['keydown']) => void;
-    'onKeyup'?: (event: VTableHeadEvents['keyup']) => void;
 }

package/dist/generated/components/VTableHead.vue2.d.ts

@@ -2,5 +2,5 @@ import type { VwcTableHeadElement } from '@vonage/vivid';
 declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcTableHeadElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup")[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, never[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

package/dist/generated/components/VTableHead.vue3.d.ts

@@ -3,45 +3,7 @@ import type { SlotsType } from 'vue';
 declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcTableHeadElement | null, VwcTableHeadElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcTableHeadElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcTableHeadElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcTableHeadElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcTableHeadElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcTableHeadElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcTableHeadElement;
-    }): true;
-}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcTableHeadElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcTableHeadElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcTableHeadElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcTableHeadElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableHeadElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableHeadElement;
-    }) => any) | undefined;
-}>, {}, SlotsType<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
     default: Record<string, never>;
 }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

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

@@ -1,33 +1,9 @@
 import type { VwcTableHeaderCellElement } from '@vonage/vivid';
 export interface VTableHeaderCellEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    };
     'cell-focused': CustomEvent<HTMLElement> & {
-        currentTarget: VwcTableHeaderCellElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    };
-    'input': Event & {
-        currentTarget: VwcTableHeaderCellElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcTableHeaderCellElement;
+        currentTarget: VwcTableHeaderCellElement | null;
     };
 }
 export interface VTableHeaderCellProps {
-    'onBlur'?: (event: VTableHeaderCellEvents['blur']) => void;
     'onCellFocused'?: (event: VTableHeaderCellEvents['cell-focused']) => void;
-    'onClick'?: (event: VTableHeaderCellEvents['click']) => void;
-    'onFocus'?: (event: VTableHeaderCellEvents['focus']) => void;
-    'onInput'?: (event: VTableHeaderCellEvents['input']) => void;
-    'onKeydown'?: (event: VTableHeaderCellEvents['keydown']) => void;
-    'onKeyup'?: (event: VTableHeaderCellEvents['keyup']) => void;
 }

package/dist/generated/components/VTableHeaderCell.vue2.d.ts

@@ -2,5 +2,5 @@ import type { VwcTableHeaderCellElement } from '@vonage/vivid';
 declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcTableHeaderCellElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup" | "cell-focused")[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "cell-focused"[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

package/dist/generated/components/VTableHeaderCell.vue3.d.ts

@@ -4,48 +4,12 @@ declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcTableHeaderCellElement | null, VwcTableHeaderCellElement | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    }): true;
     "cell-focused"(event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcTableHeaderCellElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcTableHeaderCellElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcTableHeaderCellElement;
+        currentTarget: VwcTableHeaderCellElement | null;
     }): true;
 }, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcTableHeaderCellElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableHeaderCellElement;
-    }) => any) | undefined;
     "onCell-focused"?: ((event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcTableHeaderCellElement;
+        currentTarget: VwcTableHeaderCellElement | null;
     }) => any) | undefined;
 }>, {}, SlotsType<{
     default: Record<string, never>;

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

@@ -1,29 +1,4 @@
-import type { VwcTableRowElement } from '@vonage/vivid';
 export interface VTableRowEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcTableRowElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcTableRowElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcTableRowElement;
-    };
-    'input': Event & {
-        currentTarget: VwcTableRowElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcTableRowElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcTableRowElement;
-    };
 }
 export interface VTableRowProps {
-    'onBlur'?: (event: VTableRowEvents['blur']) => void;
-    'onClick'?: (event: VTableRowEvents['click']) => void;
-    'onFocus'?: (event: VTableRowEvents['focus']) => void;
-    'onInput'?: (event: VTableRowEvents['input']) => void;
-    'onKeydown'?: (event: VTableRowEvents['keydown']) => void;
-    'onKeyup'?: (event: VTableRowEvents['keyup']) => void;
 }

package/dist/generated/components/VTableRow.vue2.d.ts

@@ -2,5 +2,5 @@ import type { VwcTableRowElement } from '@vonage/vivid';
 declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcTableRowElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup")[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, never[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

package/dist/generated/components/VTableRow.vue3.d.ts

@@ -3,45 +3,7 @@ import type { SlotsType } from 'vue';
 declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcTableRowElement | null, VwcTableRowElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcTableRowElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcTableRowElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcTableRowElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcTableRowElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcTableRowElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcTableRowElement;
-    }): true;
-}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcTableRowElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcTableRowElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcTableRowElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcTableRowElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableRowElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcTableRowElement;
-    }) => any) | undefined;
-}>, {}, SlotsType<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
     default: Record<string, never>;
 }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/generated/components/VTableSortingButton.d.ts

@@ -0,0 +1,7 @@
+import { VNode } from 'vue';
+import VTableSortingButtonVue2 from './VTableSortingButton.vue2';
+import VTableSortingButtonVue3 from './VTableSortingButton.vue3';
+
+type IsVue2 = "data" extends keyof VNode ? true : false;
+declare const _default: IsVue2 extends true ? typeof VTableSortingButtonVue2 : typeof VTableSortingButtonVue3;
+export default _default;

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

@@ -0,0 +1,10 @@
+import type { VwcTableSortingButtonElement } from '@vonage/vivid';
+export interface VTableSortingButtonEvents {
+    'sort': CustomEvent<undefined> & {
+        currentTarget: VwcTableSortingButtonElement | null;
+    };
+}
+export interface VTableSortingButtonProps {
+    direction?: 'none' | 'desc' | 'asc';
+    'onSort'?: (event: VTableSortingButtonEvents['sort']) => void;
+}

package/dist/generated/components/VTableSortingButton.vue2.d.ts

@@ -0,0 +1,21 @@
+import type { PropType } from 'vue';
+import type { VwcTableSortingButtonElement } from '@vonage/vivid';
+declare const _default: import("vue").DefineComponent<{
+    direction: {
+        type: PropType<"none" | "desc" | "asc">;
+        default: undefined;
+    };
+}, {
+    componentName: import("vue").Ref<string>;
+    element: import("vue").Ref<VwcTableSortingButtonElement | null>;
+}, {}, {}, {
+    toggleSort(): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "sort"[], string, Readonly<import("vue").ExtractPropTypes<{
+    direction: {
+        type: PropType<"none" | "desc" | "asc">;
+        default: undefined;
+    };
+}>>, {
+    direction: "none" | "desc" | "asc";
+}>;
+export default _default;

package/dist/generated/components/VTableSortingButton.vue3.d.ts

@@ -0,0 +1,31 @@
+import type { VwcTableSortingButtonElement } from '@vonage/vivid';
+import type { SlotsType, PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    direction: {
+        type: PropType<"none" | "desc" | "asc">;
+        default: undefined;
+    };
+}>, {
+    componentName: import("vue").Ref<string>;
+    element: import("vue").Ref<VwcTableSortingButtonElement | null, VwcTableSortingButtonElement | null>;
+}, {}, {}, {
+    toggleSort(): void;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    sort(event: CustomEvent<undefined> & {
+        currentTarget: VwcTableSortingButtonElement | null;
+    }): boolean;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    direction: {
+        type: PropType<"none" | "desc" | "asc">;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onSort?: ((event: CustomEvent<undefined> & {
+        currentTarget: VwcTableSortingButtonElement | null;
+    }) => any) | undefined;
+}>, {
+    direction: "none" | "desc" | "asc";
+}, SlotsType<{
+    default: Record<string, never>;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -1,25 +1,7 @@
 import type { VwcTabsElement } from '@vonage/vivid';
 export interface VTabsEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcTabsElement;
-    };
     'change': CustomEvent<HTMLElement> & {
-        currentTarget: VwcTabsElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcTabsElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcTabsElement;
-    };
-    'input': Event & {
-        currentTarget: VwcTabsElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcTabsElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcTabsElement;
+        currentTarget: VwcTabsElement | null;
     };
 }
 export interface VTabsProps {
@@ -30,11 +12,5 @@ export interface VTabsProps {
     orientation?: 'horizontal' | 'vertical';
     scrollablePanel?: boolean;
     tabsLayout?: 'align-start' | 'stretch';
-    'onBlur'?: (event: VTabsEvents['blur']) => void;
     'onChange'?: (event: VTabsEvents['change']) => void;
-    'onClick'?: (event: VTabsEvents['click']) => void;
-    'onFocus'?: (event: VTabsEvents['focus']) => void;
-    'onInput'?: (event: VTabsEvents['input']) => void;
-    'onKeydown'?: (event: VTabsEvents['keydown']) => void;
-    'onKeyup'?: (event: VTabsEvents['keyup']) => void;
 }

package/dist/generated/components/VTabs.vue2.d.ts

@@ -1,4 +1,4 @@
-import { PropType } from 'vue';
+import type { PropType } from 'vue';
 import type { VwcTabsElement } from '@vonage/vivid';
 declare const _default: import("vue").DefineComponent<{
     activeid: {
@@ -34,7 +34,7 @@ declare const _default: import("vue").DefineComponent<{
     element: import("vue").Ref<VwcTabsElement | null>;
 }, {}, {}, {
     adjust(adjustment: number): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "change" | "click" | "focus" | "input" | "keydown" | "keyup")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], string, Readonly<import("vue").ExtractPropTypes<{
     activeid: {
         type: PropType<string>;
         default: undefined;