@vonage/vivid-vue 5.17.0 → 5.19.0

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

@@ -90,6 +90,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<string>;
         default: undefined;
     };
+    pressed: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
     referrerpolicy: {
         type: PropType<string>;
         default: undefined;
@@ -137,26 +141,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     checkValidity(): boolean;
     reportValidity(): boolean;
     validate(): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    blur(event: FocusEvent & {
-        currentTarget: VwcButtonElement;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcButtonElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcButtonElement;
-    }): true;
-    input(event: Event & {
-        currentTarget: VwcButtonElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcButtonElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcButtonElement;
-    }): true;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     active: {
         type: PropType<boolean>;
         default: undefined;
@@ -245,6 +230,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<string>;
         default: undefined;
     };
+    pressed: {
+        type: PropType<boolean>;
+        default: undefined;
+    };
     referrerpolicy: {
         type: PropType<string>;
         default: undefined;
@@ -285,26 +274,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<string>;
         default: undefined;
     };
-}>> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcButtonElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcButtonElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcButtonElement;
-    }) => any) | undefined;
-    onInput?: ((event: Event & {
-        currentTarget: VwcButtonElement;
-    }) => any) | undefined;
-    onKeydown?: ((event: KeyboardEvent & {
-        currentTarget: VwcButtonElement;
-    }) => any) | undefined;
-    onKeyup?: ((event: KeyboardEvent & {
-        currentTarget: VwcButtonElement;
-    }) => any) | undefined;
-}>, {
+}>> & Readonly<{}>, {
     name: string;
     value: string;
     type: string;
@@ -334,6 +304,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     initialValue: string;
     label: string;
     pending: boolean;
+    pressed: boolean;
     required: boolean;
     stacked: boolean;
     title: string;

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

@@ -1,23 +1,4 @@
-import type { VwcCalendarElement } from '@vonage/vivid';
 export interface VCalendarEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcCalendarElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcCalendarElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcCalendarElement;
-    };
-    'input': Event & {
-        currentTarget: VwcCalendarElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcCalendarElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcCalendarElement;
-    };
 }
 export interface VCalendarProps {
     datetime?: string | Date;
@@ -25,10 +6,4 @@ export interface VCalendarProps {
     locales?: string | string[];
     startDay?: 'sunday' | 'monday';
     stickyMode?: 'none' | 'header' | 'column' | 'all';
-    'onBlur'?: (event: VCalendarEvents['blur']) => void;
-    'onClick'?: (event: VCalendarEvents['click']) => void;
-    'onFocus'?: (event: VCalendarEvents['focus']) => void;
-    'onInput'?: (event: VCalendarEvents['input']) => void;
-    'onKeydown'?: (event: VCalendarEvents['keydown']) => void;
-    'onKeyup'?: (event: VCalendarEvents['keyup']) => void;
 }

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

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

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

@@ -24,26 +24,7 @@ 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, {
-    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<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     datetime: {
         type: PropType<string | Date>;
         default: undefined;
@@ -64,26 +45,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<"none" | "header" | "column" | "all">;
         default: undefined;
     };
-}>> & 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;
-}>, {
+}>> & Readonly<{}>, {
     datetime: string | Date;
     hour12: boolean;
     locales: string | string[];

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

@@ -1,23 +1,4 @@
-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';
@@ -27,10 +8,4 @@ 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, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, never[], string, Readonly<import("vue").ExtractPropTypes<{
     appearance: {
         type: PropType<"filled" | "duotone" | "subtle">;
         default: undefined;

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

@@ -32,26 +32,7 @@ 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, {
-    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<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     appearance: {
         type: PropType<"filled" | "duotone" | "subtle">;
         default: undefined;
@@ -80,26 +61,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<number>;
         default: undefined;
     };
-}>> & 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;
-}>, {
+}>> & Readonly<{}>, {
     description: string;
     appearance: "filled" | "duotone" | "subtle";
     heading: string;

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

@@ -1,24 +1,5 @@
-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';
@@ -36,10 +17,4 @@ 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, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, never[], string, Readonly<import("vue").ExtractPropTypes<{
     appearance: {
         type: PropType<"ghost" | "outlined" | "elevated">;
         default: undefined;

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

@@ -65,26 +65,7 @@ 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, {
-    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<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     appearance: {
         type: PropType<"ghost" | "outlined" | "elevated">;
         default: undefined;
@@ -145,26 +126,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<string>;
         default: undefined;
     };
-}>> & 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;
-}>, {
+}>> & Readonly<{}>, {
     type: string;
     text: string;
     target: "_self" | "_blank" | "_parent" | "_top";

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

@@ -1,25 +1,10 @@
 import type { VwcCheckboxElement } from '@vonage/vivid';
 export interface VCheckboxEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcCheckboxElement;
-    };
     'change': CustomEvent<undefined> & {
-        currentTarget: VwcCheckboxElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcCheckboxElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcCheckboxElement;
+        currentTarget: VwcCheckboxElement | null;
     };
     'input': CustomEvent<undefined> & {
-        currentTarget: VwcCheckboxElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcCheckboxElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcCheckboxElement;
+        currentTarget: VwcCheckboxElement | null;
     };
     'update:modelValue': boolean;
 }
@@ -44,12 +29,7 @@ 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, ("blur" | "change" | "click" | "focus" | "input" | "keydown" | "keyup" | "update:modelValue")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue" | "input")[], string, Readonly<import("vue").ExtractPropTypes<{
     checked: {
         type: PropType<boolean>;
         default: undefined;

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

@@ -76,26 +76,11 @@ 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;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcCheckboxElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcCheckboxElement;
+        currentTarget: VwcCheckboxElement | null;
     }): true;
     input(event: CustomEvent<undefined> & {
-        currentTarget: VwcCheckboxElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcCheckboxElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcCheckboxElement;
+        currentTarget: VwcCheckboxElement | null;
     }): true;
     "update:modelValue"(event: boolean): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -168,28 +153,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: () => {};
     };
 }>> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcCheckboxElement;
-    }) => any) | undefined;
     onChange?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcCheckboxElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcCheckboxElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcCheckboxElement;
+        currentTarget: VwcCheckboxElement | null;
     }) => any) | undefined;
+    "onUpdate:modelValue"?: ((event: boolean) => any) | undefined;
     onInput?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcCheckboxElement;
+        currentTarget: VwcCheckboxElement | null;
     }) => 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,25 +1,10 @@
 import type { VwcColorPickerElement } from '@vonage/vivid';
 export interface VColorPickerEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcColorPickerElement;
-    };
     'change': CustomEvent<undefined> & {
-        currentTarget: VwcColorPickerElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcColorPickerElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcColorPickerElement;
+        currentTarget: VwcColorPickerElement | null;
     };
     'input': Event & {
-        currentTarget: VwcColorPickerElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcColorPickerElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcColorPickerElement;
+        currentTarget: VwcColorPickerElement | null;
     };
     'update:modelValue': string;
 }
@@ -48,12 +33,7 @@ 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, ("blur" | "change" | "click" | "focus" | "input" | "keydown" | "keyup" | "update:modelValue")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue" | "input")[], string, Readonly<import("vue").ExtractPropTypes<{
     disableSavedColors: {
         type: PropType<boolean>;
         default: undefined;

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

@@ -79,26 +79,11 @@ 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;
-    }): true;
-    click(event: MouseEvent & {
-        currentTarget: VwcColorPickerElement;
-    }): true;
-    focus(event: FocusEvent & {
-        currentTarget: VwcColorPickerElement;
+        currentTarget: VwcColorPickerElement | null;
     }): true;
     input(event: Event & {
-        currentTarget: VwcColorPickerElement;
-    }): true;
-    keydown(event: KeyboardEvent & {
-        currentTarget: VwcColorPickerElement;
-    }): true;
-    keyup(event: KeyboardEvent & {
-        currentTarget: VwcColorPickerElement;
+        currentTarget: VwcColorPickerElement | null;
     }): true;
     "update:modelValue"(event: string): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -174,28 +159,13 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: () => {};
     };
 }>> & Readonly<{
-    onBlur?: ((event: FocusEvent & {
-        currentTarget: VwcColorPickerElement;
-    }) => any) | undefined;
     onChange?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcColorPickerElement;
-    }) => any) | undefined;
-    onClick?: ((event: MouseEvent & {
-        currentTarget: VwcColorPickerElement;
-    }) => any) | undefined;
-    onFocus?: ((event: FocusEvent & {
-        currentTarget: VwcColorPickerElement;
+        currentTarget: VwcColorPickerElement | null;
     }) => any) | undefined;
+    "onUpdate:modelValue"?: ((event: string) => any) | undefined;
     onInput?: ((event: Event & {
-        currentTarget: VwcColorPickerElement;
+        currentTarget: VwcColorPickerElement | null;
     }) => 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,26 +1,8 @@
 import type { VwcComboboxElement, VwcOptionElement } from '@vonage/vivid';
 import type { IconId } from '../icons';
 export interface VComboboxEvents {
-    'blur': FocusEvent & {
-        currentTarget: VwcComboboxElement;
-    };
     'change': CustomEvent<undefined> & {
-        currentTarget: VwcComboboxElement;
-    };
-    'click': MouseEvent & {
-        currentTarget: VwcComboboxElement;
-    };
-    'focus': FocusEvent & {
-        currentTarget: VwcComboboxElement;
-    };
-    'input': Event & {
-        currentTarget: VwcComboboxElement;
-    };
-    'keydown': KeyboardEvent & {
-        currentTarget: VwcComboboxElement;
-    };
-    'keyup': KeyboardEvent & {
-        currentTarget: VwcComboboxElement;
+        currentTarget: VwcComboboxElement | null;
     };
     'update:modelValue': string;
 }
@@ -51,12 +33,6 @@ 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, ("blur" | "change" | "click" | "focus" | "input" | "keydown" | "keyup" | "update:modelValue")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], string, Readonly<import("vue").ExtractPropTypes<{
     appearance: {
         type: PropType<"fieldset" | "ghost">;
         default: undefined;