@vonage/vivid-vue 5.19.0 → 5.20.1

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

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

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

@@ -63,7 +63,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<{
     disabled: {
         type: PropType<boolean>;
         default: undefined;

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

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

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

@@ -1,16 +1,31 @@
 import type { VwcDateRangePickerElement } from '@vonage/vivid';
 export interface VDateRangePickerEvents {
+    'blur': FocusEvent & {
+        currentTarget: VwcDateRangePickerElement;
+    };
     'change': CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcDateRangePickerElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcDateRangePickerElement;
     };
     'input': CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
     };
     'input:end': CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
     };
     'input:start': CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcDateRangePickerElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcDateRangePickerElement;
     };
     'update:end': string;
     'update:start': string;
@@ -40,10 +55,15 @@ export interface VDateRangePickerProps {
         trim?: true;
         number?: true;
     };
+    'onBlur'?: (event: VDateRangePickerEvents['blur']) => void;
     'onChange'?: (event: VDateRangePickerEvents['change']) => void;
+    'onClick'?: (event: VDateRangePickerEvents['click']) => void;
+    'onFocus'?: (event: VDateRangePickerEvents['focus']) => void;
     'onInput'?: (event: VDateRangePickerEvents['input']) => void;
     'onInput:end'?: (event: VDateRangePickerEvents['input:end']) => void;
     'onInput:start'?: (event: VDateRangePickerEvents['input:start']) => void;
+    'onKeydown'?: (event: VDateRangePickerEvents['keydown']) => void;
+    'onKeyup'?: (event: VDateRangePickerEvents['keyup']) => void;
     'onUpdate:end'?: (event: VDateRangePickerEvents['update:end']) => void;
     'onUpdate:start'?: (event: VDateRangePickerEvents['update:start']) => void;
 }

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

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

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

@@ -80,17 +80,32 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     checkValidity(): boolean;
     reportValidity(): boolean;
 }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur(event: FocusEvent & {
+        currentTarget: VwcDateRangePickerElement;
+    }): true;
     change(event: CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcDateRangePickerElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcDateRangePickerElement;
     }): true;
     input(event: CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
     }): true;
     "input:end"(event: CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
     }): true;
     "input:start"(event: CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcDateRangePickerElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcDateRangePickerElement;
     }): true;
     "update:end"(event: string): true;
     "update:start"(event: string): true;
@@ -168,17 +183,32 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: () => {};
     };
 }>> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcDateRangePickerElement;
+    }) => any) | undefined;
     onChange?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcDateRangePickerElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcDateRangePickerElement;
     }) => any) | undefined;
     onInput?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
+    }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcDateRangePickerElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcDateRangePickerElement;
     }) => any) | undefined;
     "onInput:end"?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
     }) => any) | undefined;
     "onInput:start"?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDateRangePickerElement | null;
+        currentTarget: VwcDateRangePickerElement;
     }) => any) | undefined;
     "onUpdate:end"?: ((event: string) => any) | undefined;
     "onUpdate:start"?: ((event: string) => any) | undefined;

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

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

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

@@ -91,7 +91,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<{
     clock: {
         type: PropType<"12h" | "24h">;
         default: undefined;

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

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

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

@@ -1,25 +1,34 @@
 import type { VwcDialPadElement } from '@vonage/vivid';
 export interface VDialPadEvents {
     'blur': CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     };
     'change': CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcDialPadElement;
     };
     'dial': CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     };
     'end-call': CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     };
     'focus': CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     };
     'input': CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcDialPadElement;
     };
     'keypad-click': CustomEvent<HTMLElement> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcDialPadElement;
     };
     'update:modelValue': string;
 }
@@ -46,10 +55,13 @@ export interface VDialPadProps {
     };
     'onBlur'?: (event: VDialPadEvents['blur']) => void;
     'onChange'?: (event: VDialPadEvents['change']) => void;
+    'onClick'?: (event: VDialPadEvents['click']) => void;
     'onDial'?: (event: VDialPadEvents['dial']) => void;
     'onEndCall'?: (event: VDialPadEvents['end-call']) => void;
     'onFocus'?: (event: VDialPadEvents['focus']) => void;
     'onInput'?: (event: VDialPadEvents['input']) => void;
+    'onKeydown'?: (event: VDialPadEvents['keydown']) => void;
     'onKeypadClick'?: (event: VDialPadEvents['keypad-click']) => void;
+    'onKeyup'?: (event: VDialPadEvents['keyup']) => void;
     'onUpdate:modelValue'?: (event: VDialPadEvents['update:modelValue']) => void;
 }

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

@@ -71,7 +71,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {}, {}, {
     focus(): void;
     valueChanged(_oldValue: string, newValue: string): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue" | "input" | "blur" | "dial" | "end-call" | "focus" | "keypad-click")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "change" | "click" | "focus" | "input" | "keydown" | "keyup" | "update:modelValue" | "dial" | "end-call" | "keypad-click")[], string, Readonly<import("vue").ExtractPropTypes<{
     autofocus: {
         type: PropType<boolean>;
         default: undefined;

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

@@ -73,25 +73,34 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     valueChanged(_oldValue: string, newValue: string): void;
 }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     blur(event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     }): true;
     change(event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcDialPadElement;
     }): true;
     dial(event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     }): true;
     "end-call"(event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     }): true;
     focus(event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     }): true;
     input(event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcDialPadElement;
     }): true;
     "keypad-click"(event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcDialPadElement;
     }): true;
     "update:modelValue"(event: string): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -160,27 +169,36 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: () => {};
     };
 }>> & Readonly<{
+    onBlur?: ((event: CustomEvent<undefined> & {
+        currentTarget: VwcDialPadElement;
+    }) => any) | undefined;
     onChange?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcDialPadElement;
+    }) => any) | undefined;
+    onFocus?: ((event: CustomEvent<undefined> & {
+        currentTarget: VwcDialPadElement;
     }) => any) | undefined;
-    "onUpdate:modelValue"?: ((event: string) => any) | undefined;
     onInput?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     }) => any) | undefined;
-    onBlur?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcDialPadElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcDialPadElement;
     }) => any) | undefined;
+    "onUpdate:modelValue"?: ((event: string) => any) | undefined;
     onDial?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     }) => any) | undefined;
     "onEnd-call"?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
-    }) => any) | undefined;
-    onFocus?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     }) => any) | undefined;
     "onKeypad-click"?: ((event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcDialPadElement | null;
+        currentTarget: VwcDialPadElement;
     }) => any) | undefined;
 }>, {
     value: string;

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

@@ -1,14 +1,32 @@
 import type { VwcDialogElement } from '@vonage/vivid';
 import type { IconId } from '../icons';
 export interface VDialogEvents {
+    'blur': FocusEvent & {
+        currentTarget: VwcDialogElement;
+    };
     'cancel': CustomEvent<undefined> & {
-        currentTarget: VwcDialogElement | null;
+        currentTarget: VwcDialogElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcDialogElement;
     };
     'close': CustomEvent<string> & {
-        currentTarget: VwcDialogElement | null;
+        currentTarget: VwcDialogElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcDialogElement;
+    };
+    'input': Event & {
+        currentTarget: VwcDialogElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcDialogElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcDialogElement;
     };
     'open': CustomEvent<undefined> & {
-        currentTarget: VwcDialogElement | null;
+        currentTarget: VwcDialogElement;
     };
     'update:open': boolean;
 }
@@ -31,8 +49,14 @@ export interface VDialogProps {
         trim?: true;
         number?: true;
     };
+    'onBlur'?: (event: VDialogEvents['blur']) => void;
     'onCancel'?: (event: VDialogEvents['cancel']) => void;
+    'onClick'?: (event: VDialogEvents['click']) => void;
     'onClose'?: (event: VDialogEvents['close']) => void;
+    'onFocus'?: (event: VDialogEvents['focus']) => void;
+    'onInput'?: (event: VDialogEvents['input']) => void;
+    'onKeydown'?: (event: VDialogEvents['keydown']) => void;
+    'onKeyup'?: (event: VDialogEvents['keyup']) => void;
     'onOpen'?: (event: VDialogEvents['open']) => void;
     'onUpdate:open'?: (event: VDialogEvents['update:open']) => void;
 }

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

@@ -69,7 +69,7 @@ declare const _default: import("vue").DefineComponent<{
     close(): void;
     show(): void;
     showModal(): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "open" | "cancel" | "update:open")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup" | "close" | "open" | "cancel" | "update:open")[], string, Readonly<import("vue").ExtractPropTypes<{
     dismissButtonAriaLabel: {
         type: PropType<string>;
         default: undefined;

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

@@ -70,14 +70,32 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     show(): void;
     showModal(): void;
 }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur(event: FocusEvent & {
+        currentTarget: VwcDialogElement;
+    }): true;
     cancel(event: CustomEvent<undefined> & {
-        currentTarget: VwcDialogElement | null;
+        currentTarget: VwcDialogElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcDialogElement;
     }): true;
     close(event: CustomEvent<string> & {
-        currentTarget: VwcDialogElement | null;
+        currentTarget: VwcDialogElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcDialogElement;
+    }): true;
+    input(event: Event & {
+        currentTarget: VwcDialogElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcDialogElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcDialogElement;
     }): true;
     open(event: CustomEvent<undefined> & {
-        currentTarget: VwcDialogElement | null;
+        currentTarget: VwcDialogElement;
     }): true;
     "update:open"(event: boolean): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -142,14 +160,32 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: () => {};
     };
 }>> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcDialogElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcDialogElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcDialogElement;
+    }) => any) | undefined;
+    onInput?: ((event: Event & {
+        currentTarget: VwcDialogElement;
+    }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcDialogElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcDialogElement;
+    }) => any) | undefined;
     onClose?: ((event: CustomEvent<string> & {
-        currentTarget: VwcDialogElement | null;
+        currentTarget: VwcDialogElement;
     }) => any) | undefined;
     onOpen?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDialogElement | null;
+        currentTarget: VwcDialogElement;
     }) => any) | undefined;
     onCancel?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcDialogElement | null;
+        currentTarget: VwcDialogElement;
     }) => any) | undefined;
     "onUpdate:open"?: ((event: boolean) => any) | undefined;
 }>, {