@vonage/vivid-vue 5.17.0 → 5.18.0

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

@@ -1,30 +1,5 @@
-import type { VwcContextualHelpElement } from '@vonage/vivid';
 export interface VContextualHelpEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcContextualHelpElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcContextualHelpElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcContextualHelpElement;
-    };
-    'input': Event & {
-        currentTarget: VwcContextualHelpElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcContextualHelpElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcContextualHelpElement;
-    };
 }
 export interface VContextualHelpProps {
     placement?: 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'left-end' | 'left-start' | 'right-end' | 'right-start';
-    'onBlur'?: (event: VContextualHelpEvents['blur']) => void;
-    'onClick'?: (event: VContextualHelpEvents['click']) => void;
-    'onFocus'?: (event: VContextualHelpEvents['focus']) => void;
-    'onInput'?: (event: VContextualHelpEvents['input']) => void;
-    'onKeydown'?: (event: VContextualHelpEvents['keydown']) => void;
-    'onKeyup'?: (event: VContextualHelpEvents['keyup']) => void;
 }

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

@@ -8,7 +8,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcContextualHelpElement | 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<{
     placement: {
         type: PropType<"top" | "bottom" | "left" | "right" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-end" | "left-start" | "right-end" | "right-start">;
         default: undefined;

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

@@ -8,50 +8,12 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcContextualHelpElement | null, VwcContextualHelpElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcContextualHelpElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcContextualHelpElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcContextualHelpElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcContextualHelpElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcContextualHelpElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcContextualHelpElement;
-    }): true;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     placement: {
         type: PropType<"top" | "bottom" | "left" | "right" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left-end" | "left-start" | "right-end" | "right-start">;
         default: undefined;
     };
-}>> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcContextualHelpElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcContextualHelpElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcContextualHelpElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcContextualHelpElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcContextualHelpElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcContextualHelpElement;
-    }) => any) | undefined;
-}>, {
+}>> & Readonly<{}>, {
     placement: "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "left" | "right" | "left-end" | "left-start" | "right-end" | "right-start";
 }, SlotsType<{
     default: Record<string, never>;

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

@@ -1,31 +1,6 @@
-import type { VwcCountryElement } from '@vonage/vivid';
 export interface VCountryEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcCountryElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcCountryElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcCountryElement;
-    };
-    'input': Event & {
-        currentTarget: VwcCountryElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcCountryElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcCountryElement;
-    };
 }
 export interface VCountryProps {
     code?: string;
     label?: string;
-    'onBlur'?: (event: VCountryEvents['blur']) => void;
-    'onClick'?: (event: VCountryEvents['click']) => void;
-    'onFocus'?: (event: VCountryEvents['focus']) => void;
-    'onInput'?: (event: VCountryEvents['input']) => void;
-    'onKeydown'?: (event: VCountryEvents['keydown']) => void;
-    'onKeyup'?: (event: VCountryEvents['keyup']) => void;
 }

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

@@ -12,7 +12,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcCountryElement | 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<{
     code: {
         type: PropType<string>;
         default: undefined;

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

@@ -12,26 +12,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcCountryElement | null, VwcCountryElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcCountryElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcCountryElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcCountryElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcCountryElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcCountryElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcCountryElement;
-    }): true;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     code: {
         type: PropType<string>;
         default: undefined;
@@ -40,26 +21,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<string>;
         default: undefined;
     };
-}>> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcCountryElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcCountryElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcCountryElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcCountryElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcCountryElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcCountryElement;
-    }) => any) | undefined;
-}>, {
+}>> & Readonly<{}>, {
     label: string;
     code: string;
 }, SlotsType<{

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

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

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

@@ -0,0 +1,4 @@
+export interface VCountryGroupEvents {
+}
+export interface VCountryGroupProps {
+}

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

@@ -0,0 +1,6 @@
+import type { VwcCountryGroupElement } from '@vonage/vivid';
+declare const _default: import("vue").DefineComponent<{}, {
+    componentName: import("vue").Ref<string>;
+    element: import("vue").Ref<VwcCountryGroupElement | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, never[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import type { VwcCountryGroupElement } from '@vonage/vivid';
+import type { SlotsType } from 'vue';
+declare const _default: import("vue").DefineComponent<{}, {
+    componentName: import("vue").Ref<string>;
+    element: import("vue").Ref<VwcCountryGroupElement | null, VwcCountryGroupElement | null>;
+}, {}, {}, {}, 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/VDataGrid.types.d.ts

@@ -1,30 +1,12 @@
 import type { VwcDataGridElement, VwcDataGridCellElement } from '@vonage/vivid';
 export interface VDataGridEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcDataGridElement;
-    };
     'cell-click': CustomEvent<{
         cell: HTMLElement;
         row: HTMLElement;
         isHeaderCell: boolean;
         columnDataKey: string;
     }> & {
-        currentTarget: VwcDataGridElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcDataGridElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcDataGridElement;
-    };
-    'input': Event & {
-        currentTarget: VwcDataGridElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcDataGridElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcDataGridElement;
+        currentTarget: VwcDataGridElement | null;
     };
 }
 export interface VDataGridProps {
@@ -52,11 +34,5 @@ export interface VDataGridProps {
     rowItemTemplate?: any;
     rowsData?: object[];
     selectionMode?: 'none' | 'single-row' | 'multi-row' | 'single-cell' | 'multi-cell';
-    'onBlur'?: (event: VDataGridEvents['blur']) => void;
     'onCellClick'?: (event: VDataGridEvents['cell-click']) => void;
-    'onClick'?: (event: VDataGridEvents['click']) => void;
-    'onFocus'?: (event: VDataGridEvents['focus']) => void;
-    'onInput'?: (event: VDataGridEvents['input']) => void;
-    'onKeydown'?: (event: VDataGridEvents['keydown']) => void;
-    'onKeyup'?: (event: VDataGridEvents['keyup']) => void;
 }

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

@@ -67,7 +67,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcDataGridElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup" | "cell-click")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "cell-click"[], string, Readonly<import("vue").ExtractPropTypes<{
     cellItemTemplate: {
         type: PropType<any>;
         default: undefined;

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

@@ -68,31 +68,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcDataGridElement | null, VwcDataGridElement | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcDataGridElement;
-    }): true;
     "cell-click"(event: CustomEvent<{
         cell: HTMLElement;
         row: HTMLElement;
         isHeaderCell: boolean;
         columnDataKey: string;
     }> & {
-        currentTarget: VwcDataGridElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcDataGridElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcDataGridElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcDataGridElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcDataGridElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcDataGridElement;
+        currentTarget: VwcDataGridElement | null;
     }): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     cellItemTemplate: {
@@ -159,31 +141,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: undefined;
     };
 }>> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcDataGridElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcDataGridElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcDataGridElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcDataGridElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcDataGridElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcDataGridElement;
-    }) => any) | undefined;
     "onCell-click"?: ((event: CustomEvent<{
         cell: HTMLElement;
         row: HTMLElement;
         isHeaderCell: boolean;
         columnDataKey: string;
     }> & {
-        currentTarget: VwcDataGridElement;
+        currentTarget: VwcDataGridElement | null;
     }) => any) | undefined;
 }>, {
     cellItemTemplate: any;

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

@@ -1,40 +1,22 @@
 import type { VwcDataGridCellElement } from '@vonage/vivid';
 export interface VDataGridCellEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcDataGridCellElement;
-    };
     'cell-click': CustomEvent<{
         cell: HTMLElement;
         row: HTMLElement;
         isHeaderCell: boolean;
         columnDataKey: string;
     }> & {
-        currentTarget: VwcDataGridCellElement;
+        currentTarget: VwcDataGridCellElement | null;
     };
     'cell-focused': CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridCellElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcDataGridCellElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcDataGridCellElement;
-    };
-    'input': Event & {
-        currentTarget: VwcDataGridCellElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcDataGridCellElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcDataGridCellElement;
+        currentTarget: VwcDataGridCellElement | null;
     };
     'sort': CustomEvent<{
         columnDataKey: string;
         ariaSort: string | null;
         sortDirection: string | null;
     }> & {
-        currentTarget: VwcDataGridCellElement;
+        currentTarget: VwcDataGridCellElement | null;
     };
 }
 export interface VDataGridCellProps {
@@ -57,13 +39,7 @@ export interface VDataGridCellProps {
     rowData?: object;
     selected?: boolean;
     sortDirection?: 'none' | 'ascending' | 'descending' | 'other';
-    'onBlur'?: (event: VDataGridCellEvents['blur']) => void;
     'onCellClick'?: (event: VDataGridCellEvents['cell-click']) => void;
     'onCellFocused'?: (event: VDataGridCellEvents['cell-focused']) => void;
-    'onClick'?: (event: VDataGridCellEvents['click']) => void;
-    'onFocus'?: (event: VDataGridCellEvents['focus']) => void;
-    'onInput'?: (event: VDataGridCellEvents['input']) => void;
-    'onKeydown'?: (event: VDataGridCellEvents['keydown']) => void;
-    'onKeyup'?: (event: VDataGridCellEvents['keyup']) => void;
     'onSort'?: (event: VDataGridCellEvents['sort']) => void;
 }

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

@@ -41,7 +41,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcDataGridCellElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup" | "sort" | "cell-click" | "cell-focused")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("sort" | "cell-click" | "cell-focused")[], string, Readonly<import("vue").ExtractPropTypes<{
     cellType: {
         type: PropType<"default" | "columnheader" | "rowheader">;
         default: undefined;

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

@@ -42,41 +42,23 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcDataGridCellElement | null, VwcDataGridCellElement | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcDataGridCellElement;
-    }): true;
     "cell-click"(event: CustomEvent<{
         cell: HTMLElement;
         row: HTMLElement;
         isHeaderCell: boolean;
         columnDataKey: string;
     }> & {
-        currentTarget: VwcDataGridCellElement;
+        currentTarget: VwcDataGridCellElement | null;
     }): true;
     "cell-focused"(event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridCellElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcDataGridCellElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcDataGridCellElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcDataGridCellElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcDataGridCellElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcDataGridCellElement;
+        currentTarget: VwcDataGridCellElement | null;
     }): true;
     sort(event: CustomEvent<{
         columnDataKey: string;
         ariaSort: string | null;
         sortDirection: string | null;
     }> & {
-        currentTarget: VwcDataGridCellElement;
+        currentTarget: VwcDataGridCellElement | null;
     }): boolean;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     cellType: {
@@ -117,30 +99,12 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: undefined;
     };
 }>> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcDataGridCellElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcDataGridCellElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcDataGridCellElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcDataGridCellElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcDataGridCellElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcDataGridCellElement;
-    }) => any) | undefined;
     onSort?: ((event: CustomEvent<{
         columnDataKey: string;
         ariaSort: string | null;
         sortDirection: string | null;
     }> & {
-        currentTarget: VwcDataGridCellElement;
+        currentTarget: VwcDataGridCellElement | null;
     }) => any) | undefined;
     "onCell-click"?: ((event: CustomEvent<{
         cell: HTMLElement;
@@ -148,10 +112,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         isHeaderCell: boolean;
         columnDataKey: string;
     }> & {
-        currentTarget: VwcDataGridCellElement;
+        currentTarget: VwcDataGridCellElement | null;
     }) => any) | undefined;
     "onCell-focused"?: ((event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridCellElement;
+        currentTarget: VwcDataGridCellElement | null;
     }) => any) | undefined;
 }>, {
     cellType: "default" | "columnheader" | "rowheader";

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

@@ -1,33 +1,15 @@
 import type { VwcDataGridRowElement, VwcDataGridCellElement } from '@vonage/vivid';
 export interface VDataGridRowEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcDataGridRowElement;
-    };
     'cell-click': CustomEvent<{
         cell: HTMLElement;
         row: HTMLElement;
         isHeaderCell: boolean;
         columnDataKey: string;
     }> & {
-        currentTarget: VwcDataGridRowElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcDataGridRowElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcDataGridRowElement;
-    };
-    'input': Event & {
-        currentTarget: VwcDataGridRowElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcDataGridRowElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcDataGridRowElement;
+        currentTarget: VwcDataGridRowElement | null;
     };
     'row-focused': CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridRowElement;
+        currentTarget: VwcDataGridRowElement | null;
     };
 }
 export interface VDataGridRowProps {
@@ -50,12 +32,6 @@ export interface VDataGridRowProps {
     rowIndex?: number;
     rowType?: 'header' | 'default' | 'sticky-header';
     selected?: false | true;
-    'onBlur'?: (event: VDataGridRowEvents['blur']) => void;
     'onCellClick'?: (event: VDataGridRowEvents['cell-click']) => void;
-    'onClick'?: (event: VDataGridRowEvents['click']) => void;
-    'onFocus'?: (event: VDataGridRowEvents['focus']) => void;
-    'onInput'?: (event: VDataGridRowEvents['input']) => void;
-    'onKeydown'?: (event: VDataGridRowEvents['keydown']) => void;
-    'onKeyup'?: (event: VDataGridRowEvents['keyup']) => void;
     'onRowFocused'?: (event: VDataGridRowEvents['row-focused']) => void;
 }

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

@@ -47,7 +47,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcDataGridRowElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup" | "cell-click" | "row-focused")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("cell-click" | "row-focused")[], string, Readonly<import("vue").ExtractPropTypes<{
     cellItemTemplate: {
         type: PropType<any>;
         default: undefined;

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

@@ -48,34 +48,16 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcDataGridRowElement | null, VwcDataGridRowElement | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcDataGridRowElement;
-    }): true;
     "cell-click"(event: CustomEvent<{
         cell: HTMLElement;
         row: HTMLElement;
         isHeaderCell: boolean;
         columnDataKey: string;
     }> & {
-        currentTarget: VwcDataGridRowElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcDataGridRowElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcDataGridRowElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcDataGridRowElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcDataGridRowElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcDataGridRowElement;
+        currentTarget: VwcDataGridRowElement | null;
     }): true;
     "row-focused"(event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridRowElement;
+        currentTarget: VwcDataGridRowElement | null;
     }): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     cellItemTemplate: {
@@ -122,34 +104,16 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: undefined;
     };
 }>> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcDataGridRowElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcDataGridRowElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcDataGridRowElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcDataGridRowElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcDataGridRowElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcDataGridRowElement;
-    }) => any) | undefined;
     "onCell-click"?: ((event: CustomEvent<{
         cell: HTMLElement;
         row: HTMLElement;
         isHeaderCell: boolean;
         columnDataKey: string;
     }> & {
-        currentTarget: VwcDataGridRowElement;
+        currentTarget: VwcDataGridRowElement | null;
     }) => any) | undefined;
     "onRow-focused"?: ((event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridRowElement;
+        currentTarget: VwcDataGridRowElement | null;
     }) => any) | undefined;
 }>, {
     cellItemTemplate: any;