@vonage/vivid-vue 5.20.0 → 5.21.0

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

@@ -37,11 +37,29 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     focus(): void;
     openChanged(_: boolean, newValue: boolean): void;
 }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur(event: FocusEvent & {
+        currentTarget: VwcMenuElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcMenuElement;
+    }): true;
     close(event: CustomEvent<undefined> & {
-        currentTarget: VwcMenuElement | null;
+        currentTarget: VwcMenuElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcMenuElement;
+    }): true;
+    input(event: Event & {
+        currentTarget: VwcMenuElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcMenuElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcMenuElement;
     }): true;
     open(event: CustomEvent<undefined> & {
-        currentTarget: VwcMenuElement | null;
+        currentTarget: VwcMenuElement;
     }): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     anchor: {
@@ -73,11 +91,29 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: undefined;
     };
 }>> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcMenuElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcMenuElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcMenuElement;
+    }) => any) | undefined;
+    onInput?: ((event: Event & {
+        currentTarget: VwcMenuElement;
+    }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcMenuElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcMenuElement;
+    }) => any) | undefined;
     onClose?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcMenuElement | null;
+        currentTarget: VwcMenuElement;
     }) => any) | undefined;
     onOpen?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcMenuElement | null;
+        currentTarget: VwcMenuElement;
     }) => any) | undefined;
 }>, {
     anchor: string | HTMLElement;

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

@@ -1,11 +1,29 @@
 import type { VwcMenuItemElement } from '@vonage/vivid';
 import type { IconId } from '../icons';
 export interface VMenuItemEvents {
+    'blur': FocusEvent & {
+        currentTarget: VwcMenuItemElement;
+    };
     'change': CustomEvent<undefined> & {
-        currentTarget: VwcMenuItemElement | null;
+        currentTarget: VwcMenuItemElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcMenuItemElement;
     };
     'expanded-change': CustomEvent<HTMLElement> & {
-        currentTarget: VwcMenuItemElement | null;
+        currentTarget: VwcMenuItemElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcMenuItemElement;
+    };
+    'input': Event & {
+        currentTarget: VwcMenuItemElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcMenuItemElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcMenuItemElement;
     };
     'update:modelValue': boolean;
 }
@@ -25,7 +43,13 @@ export interface VMenuItemProps {
         trim?: true;
         number?: true;
     };
+    'onBlur'?: (event: VMenuItemEvents['blur']) => void;
     'onChange'?: (event: VMenuItemEvents['change']) => void;
+    'onClick'?: (event: VMenuItemEvents['click']) => void;
     'onExpandedChange'?: (event: VMenuItemEvents['expanded-change']) => void;
+    'onFocus'?: (event: VMenuItemEvents['focus']) => void;
+    'onInput'?: (event: VMenuItemEvents['input']) => void;
+    'onKeydown'?: (event: VMenuItemEvents['keydown']) => void;
+    'onKeyup'?: (event: VMenuItemEvents['keyup']) => void;
     'onUpdate:modelValue'?: (event: VMenuItemEvents['update:modelValue']) => void;
 }

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

@@ -53,7 +53,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcMenuItemElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue" | "expanded-change")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "change" | "click" | "focus" | "input" | "keydown" | "keyup" | "update:modelValue" | "expanded-change")[], string, Readonly<import("vue").ExtractPropTypes<{
     checkAppearance: {
         type: PropType<"normal" | "tick-only">;
         default: undefined;

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

@@ -54,11 +54,29 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcMenuItemElement | null, VwcMenuItemElement | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur(event: FocusEvent & {
+        currentTarget: VwcMenuItemElement;
+    }): true;
     change(event: CustomEvent<undefined> & {
-        currentTarget: VwcMenuItemElement | null;
+        currentTarget: VwcMenuItemElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcMenuItemElement;
     }): true;
     "expanded-change"(event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcMenuItemElement | null;
+        currentTarget: VwcMenuItemElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcMenuItemElement;
+    }): true;
+    input(event: Event & {
+        currentTarget: VwcMenuItemElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcMenuItemElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcMenuItemElement;
     }): true;
     "update:modelValue"(event: boolean): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -111,12 +129,30 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: () => {};
     };
 }>> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcMenuItemElement;
+    }) => any) | undefined;
     onChange?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcMenuItemElement | null;
+        currentTarget: VwcMenuItemElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcMenuItemElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcMenuItemElement;
+    }) => any) | undefined;
+    onInput?: ((event: Event & {
+        currentTarget: VwcMenuItemElement;
+    }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcMenuItemElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcMenuItemElement;
     }) => any) | undefined;
     "onUpdate:modelValue"?: ((event: boolean) => any) | undefined;
     "onExpanded-change"?: ((event: CustomEvent<HTMLElement> & {
-        currentTarget: VwcMenuItemElement | null;
+        currentTarget: VwcMenuItemElement;
     }) => any) | undefined;
 }>, {
     text: string;

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

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

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

@@ -2,5 +2,5 @@ import type { VwcNavElement } from '@vonage/vivid';
 declare const _default: import("vue").DefineComponent<{}, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcNavElement | 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/VNav.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<VwcNavElement | null, VwcNavElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, SlotsType<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur(event: FocusEvent & {
+        currentTarget: VwcNavElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcNavElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcNavElement;
+    }): true;
+    input(event: Event & {
+        currentTarget: VwcNavElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcNavElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcNavElement;
+    }): true;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcNavElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcNavElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcNavElement;
+    }) => any) | undefined;
+    onInput?: ((event: Event & {
+        currentTarget: VwcNavElement;
+    }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcNavElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcNavElement;
+    }) => any) | undefined;
+}>, {}, SlotsType<{
     default: Record<string, never>;
 }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

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

@@ -1,8 +1,26 @@
 import type { VwcNavDisclosureElement } from '@vonage/vivid';
 import type { IconId } from '../icons';
 export interface VNavDisclosureEvents {
+    'blur': FocusEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    };
+    'input': Event & {
+        currentTarget: VwcNavDisclosureElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    };
     'toggle': CustomEvent<undefined> & {
-        currentTarget: VwcNavDisclosureElement | null;
+        currentTarget: VwcNavDisclosureElement;
     };
 }
 export interface VNavDisclosureProps {
@@ -12,5 +30,11 @@ export interface VNavDisclosureProps {
     icon?: IconId;
     label?: string;
     open?: boolean;
+    'onBlur'?: (event: VNavDisclosureEvents['blur']) => void;
+    'onClick'?: (event: VNavDisclosureEvents['click']) => void;
+    'onFocus'?: (event: VNavDisclosureEvents['focus']) => void;
+    'onInput'?: (event: VNavDisclosureEvents['input']) => void;
+    'onKeydown'?: (event: VNavDisclosureEvents['keydown']) => void;
+    'onKeyup'?: (event: VNavDisclosureEvents['keyup']) => void;
     'onToggle'?: (event: VNavDisclosureEvents['toggle']) => void;
 }

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

@@ -29,7 +29,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcNavDisclosureElement | null>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "toggle"[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("blur" | "click" | "focus" | "input" | "keydown" | "keyup" | "toggle")[], string, Readonly<import("vue").ExtractPropTypes<{
     appearance: {
         type: PropType<"ghost" | "ghost-light">;
         default: undefined;

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

@@ -30,8 +30,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcNavDisclosureElement | null, VwcNavDisclosureElement | null>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur(event: FocusEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    }): true;
+    click(event: MouseEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    }): true;
+    focus(event: FocusEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    }): true;
+    input(event: Event & {
+        currentTarget: VwcNavDisclosureElement;
+    }): true;
+    keydown(event: KeyboardEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    }): true;
+    keyup(event: KeyboardEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    }): true;
     toggle(event: CustomEvent<undefined> & {
-        currentTarget: VwcNavDisclosureElement | null;
+        currentTarget: VwcNavDisclosureElement;
     }): true;
 }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     appearance: {
@@ -59,8 +77,26 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         default: undefined;
     };
 }>> & Readonly<{
+    onBlur?: ((event: FocusEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    }) => any) | undefined;
+    onClick?: ((event: MouseEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    }) => any) | undefined;
+    onFocus?: ((event: FocusEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    }) => any) | undefined;
+    onInput?: ((event: Event & {
+        currentTarget: VwcNavDisclosureElement;
+    }) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    }) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent & {
+        currentTarget: VwcNavDisclosureElement;
+    }) => any) | undefined;
     onToggle?: ((event: CustomEvent<undefined> & {
-        currentTarget: VwcNavDisclosureElement | null;
+        currentTarget: VwcNavDisclosureElement;
     }) => any) | undefined;
 }>, {
     appearance: "ghost" | "ghost-light";

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

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

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

@@ -57,7 +57,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcNavItemElement | 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" | "ghost-light">;
         default: undefined;

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

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

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

@@ -1,8 +1,33 @@
+import type { VwcNoteElement } from '@vonage/vivid';
 import type { IconId } from '../icons';
 export interface VNoteEvents {
+    'blur': FocusEvent & {
+        currentTarget: VwcNoteElement;
+    };
+    'click': MouseEvent & {
+        currentTarget: VwcNoteElement;
+    };
+    'focus': FocusEvent & {
+        currentTarget: VwcNoteElement;
+    };
+    'input': Event & {
+        currentTarget: VwcNoteElement;
+    };
+    'keydown': KeyboardEvent & {
+        currentTarget: VwcNoteElement;
+    };
+    'keyup': KeyboardEvent & {
+        currentTarget: VwcNoteElement;
+    };
 }
 export interface VNoteProps {
     connotation?: 'accent' | 'success' | 'alert' | 'warning' | 'information' | 'announcement';
     headline?: string;
     icon?: IconId;
+    'onBlur'?: (event: VNoteEvents['blur']) => void;
+    'onClick'?: (event: VNoteEvents['click']) => void;
+    'onFocus'?: (event: VNoteEvents['focus']) => void;
+    'onInput'?: (event: VNoteEvents['input']) => void;
+    'onKeydown'?: (event: VNoteEvents['keydown']) => void;
+    'onKeyup'?: (event: VNoteEvents['keyup']) => void;
 }

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

@@ -17,7 +17,7 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     componentName: import("vue").Ref<string>;
     element: import("vue").Ref<VwcNoteElement | 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<{
     connotation: {
         type: PropType<"accent" | "success" | "alert" | "warning" | "information" | "announcement">;
         default: undefined;