@vonage/vivid-vue 5.19.0 → 5.20.1

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

@@ -24,7 +24,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcCalendarElement | null, VwcCalendarElement | 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: VwcCalendarElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcCalendarElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcCalendarElement;
+    }): true;
+    input(event: Event & {
+        currentTarget: VwcCalendarElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcCalendarElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcCalendarElement;
+    }): true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     datetime: {
         type: PropType<string | Date>;
         default: undefined;
@@ -45,7 +64,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<"none" | "header" | "column" | "all">;
         default: undefined;
     };
-}>> & Readonly<{}>, {
+}>> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcCalendarElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcCalendarElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcCalendarElement;
+    }) => any) | undefined;
+    onInput?: ((event: Event & {
+        currentTarget: VwcCalendarElement;
+    }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcCalendarElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcCalendarElement;
+    }) => any) | undefined;
+}>, {
     datetime: string | Date;
     hour12: boolean;
     locales: string | string[];

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

@@ -1,4 +1,23 @@
+import type { VwcCalendarEventElement } from '@vonage/vivid';
 export interface VCalendarEventEvents {
+    'blur': FocusEvent & {
+        currentTarget: VwcCalendarEventElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcCalendarEventElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcCalendarEventElement;
+    };
+    'input': Event & {
+        currentTarget: VwcCalendarEventElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcCalendarEventElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcCalendarEventElement;
+    };
 }
 export interface VCalendarEventProps {
     appearance?: 'filled' | 'duotone' | 'subtle';
@@ -8,4 +27,10 @@ export interface VCalendarEventProps {
     heading?: string;
     overlapCount?: number;
     start?: number;
+    'onBlur'?: (event: VCalendarEventEvents['blur']) => void;
+    'onClick'?: (event: VCalendarEventEvents['click']) => void;
+    'onFocus'?: (event: VCalendarEventEvents['focus']) => void;
+    'onInput'?: (event: VCalendarEventEvents['input']) => void;
+    'onKeydown'?: (event: VCalendarEventEvents['keydown']) => void;
+    'onKeyup'?: (event: VCalendarEventEvents['keyup']) => void;
 }

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

@@ -32,7 +32,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcCalendarEventElement | 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<{
     appearance: {
         type: PropType<"filled" | "duotone" | "subtle">;
         default: undefined;

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

@@ -32,7 +32,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcCalendarEventElement | null, VwcCalendarEventElement | 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: VwcCalendarEventElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcCalendarEventElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcCalendarEventElement;
+    }): true;
+    input(event: Event & {
+        currentTarget: VwcCalendarEventElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcCalendarEventElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcCalendarEventElement;
+    }): true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     appearance: {
         type: PropType<"filled" | "duotone" | "subtle">;
         default: undefined;
@@ -61,7 +80,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<number>;
         default: undefined;
     };
-}>> & Readonly<{}>, {
+}>> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcCalendarEventElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcCalendarEventElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcCalendarEventElement;
+    }) => any) | undefined;
+    onInput?: ((event: Event & {
+        currentTarget: VwcCalendarEventElement;
+    }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcCalendarEventElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcCalendarEventElement;
+    }) => any) | undefined;
+}>, {
     description: string;
     appearance: "filled" | "duotone" | "subtle";
     heading: string;

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

@@ -1,5 +1,24 @@
+import type { VwcCardElement } from '@vonage/vivid';
 import type { IconId } from '../icons';
 export interface VCardEvents {
+    'blur': FocusEvent & {
+        currentTarget: VwcCardElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcCardElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcCardElement;
+    };
+    'input': Event & {
+        currentTarget: VwcCardElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcCardElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcCardElement;
+    };
 }
 export interface VCardProps {
     appearance?: 'ghost' | 'outlined' | 'elevated';
@@ -17,4 +36,10 @@ export interface VCardProps {
     target?: '_self' | '_blank' | '_parent' | '_top';
     text?: string;
     type?: string;
+    'onBlur'?: (event: VCardEvents['blur']) => void;
+    'onClick'?: (event: VCardEvents['click']) => void;
+    'onFocus'?: (event: VCardEvents['focus']) => void;
+    'onInput'?: (event: VCardEvents['input']) => void;
+    'onKeydown'?: (event: VCardEvents['keydown']) => void;
+    'onKeyup'?: (event: VCardEvents['keyup']) => void;
 }

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

@@ -65,7 +65,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcCardElement | 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<{
     appearance: {
         type: PropType<"ghost" | "outlined" | "elevated">;
         default: undefined;

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

@@ -65,7 +65,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcCardElement | null, VwcCardElement | 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: VwcCardElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcCardElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcCardElement;
+    }): true;
+    input(event: Event & {
+        currentTarget: VwcCardElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcCardElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcCardElement;
+    }): true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     appearance: {
         type: PropType<"ghost" | "outlined" | "elevated">;
         default: undefined;
@@ -126,7 +145,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<string>;
         default: undefined;
     };
-}>> & Readonly<{}>, {
+}>> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcCardElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcCardElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcCardElement;
+    }) => any) | undefined;
+    onInput?: ((event: Event & {
+        currentTarget: VwcCardElement;
+    }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcCardElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcCardElement;
+    }) => any) | undefined;
+}>, {
     type: string;
     text: string;
     target: "_self" | "_blank" | "_parent" | "_top";

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

@@ -1,10 +1,25 @@
 import type { VwcCheckboxElement } from '@vonage/vivid';
 export interface VCheckboxEvents {
+    'blur': FocusEvent & {
+        currentTarget: VwcCheckboxElement;
+    };
     'change': CustomEvent<undefined> & {
-        currentTarget: VwcCheckboxElement | null;
+        currentTarget: VwcCheckboxElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcCheckboxElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcCheckboxElement;
     };
     'input': CustomEvent<undefined> & {
-        currentTarget: VwcCheckboxElement | null;
+        currentTarget: VwcCheckboxElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcCheckboxElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcCheckboxElement;
     };
     'update:modelValue': boolean;
 }
@@ -29,7 +44,12 @@ export interface VCheckboxProps {
         trim?: true;
         number?: true;
     };
+    'onBlur'?: (event: VCheckboxEvents['blur']) => void;
     'onChange'?: (event: VCheckboxEvents['change']) => void;
+    'onClick'?: (event: VCheckboxEvents['click']) => void;
+    'onFocus'?: (event: VCheckboxEvents['focus']) => void;
     'onInput'?: (event: VCheckboxEvents['input']) => void;
+    'onKeydown'?: (event: VCheckboxEvents['keydown']) => void;
+    'onKeyup'?: (event: VCheckboxEvents['keyup']) => void;
     'onUpdate:modelValue'?: (event: VCheckboxEvents['update:modelValue']) => void;
 }

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

@@ -75,7 +75,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {}, {}, {
     checkValidity(): boolean;
     reportValidity(): boolean;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue" | "input")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "change" | "click" | "focus" | "input" | "keydown" | "keyup" | "update:modelValue")[], string, Readonly<import("vue").ExtractPropTypes<{
     checked: {
         type: PropType<boolean>;
         default: undefined;

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

@@ -76,11 +76,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     checkValidity(): boolean;
     reportValidity(): boolean;
 }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur(event: FocusEvent & {
+        currentTarget: VwcCheckboxElement;
+    }): true;
     change(event: CustomEvent<undefined> & {
-        currentTarget: VwcCheckboxElement | null;
+        currentTarget: VwcCheckboxElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcCheckboxElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcCheckboxElement;
     }): true;
     input(event: CustomEvent<undefined> & {
-        currentTarget: VwcCheckboxElement | null;
+        currentTarget: VwcCheckboxElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcCheckboxElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcCheckboxElement;
     }): true;
     "update:modelValue"(event: boolean): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -153,13 +168,28 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: () => {};
     };
 }>> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcCheckboxElement;
+    }) => any) | undefined;
     onChange?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcCheckboxElement | null;
+        currentTarget: VwcCheckboxElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcCheckboxElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcCheckboxElement;
     }) => any) | undefined;
-    "onUpdate:modelValue"?: ((event: boolean) => any) | undefined;
     onInput?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcCheckboxElement | null;
+        currentTarget: VwcCheckboxElement;
     }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcCheckboxElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcCheckboxElement;
+    }) => any) | undefined;
+    "onUpdate:modelValue"?: ((event: boolean) => any) | undefined;
 }>, {
     name: string;
     value: string;

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

@@ -1,10 +1,25 @@
 import type { VwcColorPickerElement } from '@vonage/vivid';
 export interface VColorPickerEvents {
+    'blur': FocusEvent & {
+        currentTarget: VwcColorPickerElement;
+    };
     'change': CustomEvent<undefined> & {
-        currentTarget: VwcColorPickerElement | null;
+        currentTarget: VwcColorPickerElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcColorPickerElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcColorPickerElement;
     };
     'input': Event & {
-        currentTarget: VwcColorPickerElement | null;
+        currentTarget: VwcColorPickerElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcColorPickerElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcColorPickerElement;
     };
     'update:modelValue': string;
 }
@@ -33,7 +48,12 @@ export interface VColorPickerProps {
         number?: true;
         lazy?: true;
     };
+    'onBlur'?: (event: VColorPickerEvents['blur']) => void;
     'onChange'?: (event: VColorPickerEvents['change']) => void;
+    'onClick'?: (event: VColorPickerEvents['click']) => void;
+    'onFocus'?: (event: VColorPickerEvents['focus']) => void;
     'onInput'?: (event: VColorPickerEvents['input']) => void;
+    'onKeydown'?: (event: VColorPickerEvents['keydown']) => void;
+    'onKeyup'?: (event: VColorPickerEvents['keyup']) => void;
     'onUpdate:modelValue'?: (event: VColorPickerEvents['update:modelValue']) => void;
 }

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

@@ -78,7 +78,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {}, {}, {
     checkValidity(): boolean;
     reportValidity(): boolean;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue" | "input")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "change" | "click" | "focus" | "input" | "keydown" | "keyup" | "update:modelValue")[], string, Readonly<import("vue").ExtractPropTypes<{
     disableSavedColors: {
         type: PropType<boolean>;
         default: undefined;

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

@@ -79,11 +79,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     checkValidity(): boolean;
     reportValidity(): boolean;
 }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur(event: FocusEvent & {
+        currentTarget: VwcColorPickerElement;
+    }): true;
     change(event: CustomEvent<undefined> & {
-        currentTarget: VwcColorPickerElement | null;
+        currentTarget: VwcColorPickerElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcColorPickerElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcColorPickerElement;
     }): true;
     input(event: Event & {
-        currentTarget: VwcColorPickerElement | null;
+        currentTarget: VwcColorPickerElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcColorPickerElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcColorPickerElement;
     }): true;
     "update:modelValue"(event: string): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -159,13 +174,28 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: () => {};
     };
 }>> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcColorPickerElement;
+    }) => any) | undefined;
     onChange?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcColorPickerElement | null;
+        currentTarget: VwcColorPickerElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcColorPickerElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcColorPickerElement;
     }) => any) | undefined;
-    "onUpdate:modelValue"?: ((event: string) => any) | undefined;
     onInput?: ((event: Event & {
-        currentTarget: VwcColorPickerElement | null;
+        currentTarget: VwcColorPickerElement;
     }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcColorPickerElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcColorPickerElement;
+    }) => any) | undefined;
+    "onUpdate:modelValue"?: ((event: string) => any) | undefined;
 }>, {
     name: string;
     value: string;

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

@@ -1,8 +1,26 @@
 import type { VwcComboboxElement, VwcOptionElement } from '@vonage/vivid';
 import type { IconId } from '../icons';
 export interface VComboboxEvents {
+    'blur': FocusEvent & {
+        currentTarget: VwcComboboxElement;
+    };
     'change': CustomEvent<undefined> & {
-        currentTarget: VwcComboboxElement | null;
+        currentTarget: VwcComboboxElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcComboboxElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcComboboxElement;
+    };
+    'input': Event & {
+        currentTarget: VwcComboboxElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcComboboxElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcComboboxElement;
     };
     'update:modelValue': string;
 }
@@ -33,6 +51,12 @@ export interface VComboboxProps {
         trim?: true;
         number?: true;
     };
+    'onBlur'?: (event: VComboboxEvents['blur']) => void;
     'onChange'?: (event: VComboboxEvents['change']) => void;
+    'onClick'?: (event: VComboboxEvents['click']) => void;
+    'onFocus'?: (event: VComboboxEvents['focus']) => void;
+    'onInput'?: (event: VComboboxEvents['input']) => void;
+    'onKeydown'?: (event: VComboboxEvents['keydown']) => void;
+    'onKeyup'?: (event: VComboboxEvents['keyup']) => void;
     'onUpdate:modelValue'?: (event: VComboboxEvents['update:modelValue']) => void;
 }

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

@@ -103,7 +103,7 @@ declare const _default: import("vue").DefineComponent<{
     reportValidity(): boolean;
     selectFirstOption(): void;
     validate(): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "change" | "click" | "focus" | "input" | "keydown" | "keyup" | "update:modelValue")[], string, Readonly<import("vue").ExtractPropTypes<{
     appearance: {
         type: PropType<"fieldset" | "ghost">;
         default: undefined;

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

@@ -104,8 +104,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     selectFirstOption(): void;
     validate(): void;
 }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur(event: FocusEvent & {
+        currentTarget: VwcComboboxElement;
+    }): true;
     change(event: CustomEvent<undefined> & {
-        currentTarget: VwcComboboxElement | null;
+        currentTarget: VwcComboboxElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcComboboxElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcComboboxElement;
+    }): true;
+    input(event: Event & {
+        currentTarget: VwcComboboxElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcComboboxElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcComboboxElement;
     }): true;
     "update:modelValue"(event: string): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -202,8 +220,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: () => {};
     };
 }>> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcComboboxElement;
+    }) => any) | undefined;
     onChange?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcComboboxElement | null;
+        currentTarget: VwcComboboxElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcComboboxElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcComboboxElement;
+    }) => any) | undefined;
+    onInput?: ((event: Event & {
+        currentTarget: VwcComboboxElement;
+    }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcComboboxElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcComboboxElement;
     }) => any) | undefined;
     "onUpdate:modelValue"?: ((event: string) => any) | undefined;
 }>, {

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

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