@vonage/vivid-vue 5.19.0 → 5.20.1

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

@@ -8,12 +8,50 @@ 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, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, 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<{
     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<{}>, {
+}>> & 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;
+}>, {
     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,6 +1,31 @@
+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, never[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup")[], string, Readonly<import("vue").ExtractPropTypes<{
     code: {
         type: PropType<string>;
         default: undefined;

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

@@ -12,7 +12,26 @@ 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, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, 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<{
     code: {
         type: PropType<string>;
         default: undefined;
@@ -21,7 +40,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<string>;
         default: undefined;
     };
-}>> & Readonly<{}>, {
+}>> & 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;
+}>, {
     label: string;
     code: string;
 }, SlotsType<{

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

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

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

@@ -2,5 +2,5 @@ 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<{}>>, {}>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup")[], string, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

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

@@ -3,7 +3,45 @@ 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<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur(event: FocusEvent & {
+        currentTarget: VwcCountryGroupElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcCountryGroupElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcCountryGroupElement;
+    }): true;
+    input(event: Event & {
+        currentTarget: VwcCountryGroupElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcCountryGroupElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcCountryGroupElement;
+    }): true;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcCountryGroupElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcCountryGroupElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcCountryGroupElement;
+    }) => any) | undefined;
+    onInput?: ((event: Event & {
+        currentTarget: VwcCountryGroupElement;
+    }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcCountryGroupElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcCountryGroupElement;
+    }) => any) | undefined;
+}>, {}, SlotsType<{
     default: Record<string, never>;
 }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

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

@@ -1,12 +1,30 @@
 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 | null;
+        currentTarget: VwcDataGridElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcDataGridElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcDataGridElement;
+    };
+    'input': Event & {
+        currentTarget: VwcDataGridElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcDataGridElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcDataGridElement;
     };
 }
 export interface VDataGridProps {
@@ -34,5 +52,11 @@ 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, "cell-click"[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup" | "cell-click")[], string, Readonly<import("vue").ExtractPropTypes<{
     cellItemTemplate: {
         type: PropType<any>;
         default: undefined;

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

@@ -68,13 +68,31 @@ 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 | null;
+        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;
     }): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     cellItemTemplate: {
@@ -141,13 +159,31 @@ 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 | null;
+        currentTarget: VwcDataGridElement;
     }) => any) | undefined;
 }>, {
     cellItemTemplate: any;

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

@@ -1,22 +1,40 @@
 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 | null;
+        currentTarget: VwcDataGridCellElement;
     };
     'cell-focused': CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridCellElement | null;
+        currentTarget: VwcDataGridCellElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcDataGridCellElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcDataGridCellElement;
+    };
+    'input': Event & {
+        currentTarget: VwcDataGridCellElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcDataGridCellElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcDataGridCellElement;
     };
     'sort': CustomEvent<{
         columnDataKey: string;
         ariaSort: string | null;
         sortDirection: string | null;
     }> & {
-        currentTarget: VwcDataGridCellElement | null;
+        currentTarget: VwcDataGridCellElement;
     };
 }
 export interface VDataGridCellProps {
@@ -39,7 +57,13 @@ 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, ("sort" | "cell-click" | "cell-focused")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup" | "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,23 +42,41 @@ 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 | null;
+        currentTarget: VwcDataGridCellElement;
     }): true;
     "cell-focused"(event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridCellElement | null;
+        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;
     }): true;
     sort(event: CustomEvent<{
         columnDataKey: string;
         ariaSort: string | null;
         sortDirection: string | null;
     }> & {
-        currentTarget: VwcDataGridCellElement | null;
+        currentTarget: VwcDataGridCellElement;
     }): boolean;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     cellType: {
@@ -99,12 +117,30 @@ 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 | null;
+        currentTarget: VwcDataGridCellElement;
     }) => any) | undefined;
     "onCell-click"?: ((event: CustomEvent<{
         cell: HTMLElement;
@@ -112,10 +148,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         isHeaderCell: boolean;
         columnDataKey: string;
     }> & {
-        currentTarget: VwcDataGridCellElement | null;
+        currentTarget: VwcDataGridCellElement;
     }) => any) | undefined;
     "onCell-focused"?: ((event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridCellElement | null;
+        currentTarget: VwcDataGridCellElement;
     }) => any) | undefined;
 }>, {
     cellType: "default" | "columnheader" | "rowheader";

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

@@ -1,15 +1,33 @@
 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 | null;
+        currentTarget: VwcDataGridRowElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcDataGridRowElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcDataGridRowElement;
+    };
+    'input': Event & {
+        currentTarget: VwcDataGridRowElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcDataGridRowElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcDataGridRowElement;
     };
     'row-focused': CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridRowElement | null;
+        currentTarget: VwcDataGridRowElement;
     };
 }
 export interface VDataGridRowProps {
@@ -32,6 +50,12 @@ 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, ("cell-click" | "row-focused")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup" | "cell-click" | "row-focused")[], string, Readonly<import("vue").ExtractPropTypes<{
     cellItemTemplate: {
         type: PropType<any>;
         default: undefined;

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

@@ -48,16 +48,34 @@ 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 | null;
+        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;
     }): true;
     "row-focused"(event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridRowElement | null;
+        currentTarget: VwcDataGridRowElement;
     }): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     cellItemTemplate: {
@@ -104,16 +122,34 @@ 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 | null;
+        currentTarget: VwcDataGridRowElement;
     }) => any) | undefined;
     "onRow-focused"?: ((event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcDataGridRowElement | null;
+        currentTarget: VwcDataGridRowElement;
     }) => any) | undefined;
 }>, {
     cellItemTemplate: any;