@vonage/vivid-test-utils 5.2.0

package/dist/components.generated.d.ts

@@ -0,0 +1,2581 @@
+import type { DriverT } from './drivers/driver';
+import { BaseComponent, BaseWrapper, ComponentCollectionExpectations, type ComponentCollectionLocator, type Context } from './base';
+import type { VwcAccordionElement, VwcAccordionItemElement, VwcActionGroupElement, VwcAlertElement, VwcAudioPlayerElement, VwcAvatarElement, VwcBadgeElement, VwcBannerElement, VwcBreadcrumbElement, VwcBreadcrumbItemElement, VwcButtonElement, VwcCalendarElement, VwcCalendarEventElement, VwcCardElement, VwcCheckboxElement, VwcComboboxElement, VwcDataGridElement, VwcDataGridCellElement, VwcDataGridRowElement, VwcDatePickerElement, VwcDateRangePickerElement, VwcDateTimePickerElement, VwcDialPadElement, VwcDialogElement, VwcDividerElement, VwcEmptyStateElement, VwcFabElement, VwcFilePickerElement, VwcHeaderElement, VwcIconElement, VwcLayoutElement, VwcMenuElement, VwcMenuItemElement, VwcNavElement, VwcNavDisclosureElement, VwcNavItemElement, VwcNoteElement, VwcNumberFieldElement, VwcOptionElement, VwcPaginationElement, VwcProgressElement, VwcProgressRingElement, VwcRadioElement, VwcRadioGroupElement, VwcRangeSliderElement, VwcRichTextEditorElement, VwcSearchableSelectElement, VwcSelectElement, VwcSelectableBoxElement, VwcSideDrawerElement, VwcSimpleColorPickerElement, VwcSliderElement, VwcSplitButtonElement, VwcSwitchElement, VwcTabElement, VwcTabPanelElement, VwcTabsElement, VwcTagElement, VwcTagGroupElement, VwcTextAreaElement, VwcTextFieldElement, VwcTimePickerElement, VwcToggletipElement, VwcTooltipElement, VwcTreeItemElement, VwcTreeViewElement, VwcVideoPlayerElement } from "@vonage/vivid";
+type IconId = string;
+type AccordionProps = {
+    expandMode: 'single' | 'multi';
+};
+export declare class AccordionWrapper<D extends DriverT> extends BaseWrapper<D, VwcAccordionElement> {
+    type: "accordion";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Accordion<D extends DriverT> extends BaseComponent<D, AccordionWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): AccordionWrapper<D>;
+    byTestId: (id: string) => AccordionWrapper<D>;
+}
+export declare class AccordionExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: AccordionWrapper<D>);
+    toHaveProp: <T extends "expandMode">(propName: T, value: AccordionProps[T]) => D["expectReturn"];
+}
+type AccordionItemProps = {
+    appearance: 'ghost' | 'filled' | 'ghost-light';
+    expanded: boolean;
+    heading: string;
+    headingLevel: 1 | 2 | 3 | 4 | 5 | 6;
+    icon: IconId;
+    iconTrailing: boolean;
+    id: string;
+    meta: string;
+    noIndicator: boolean;
+    size: 'condensed' | 'normal';
+};
+export declare class AccordionItemWrapper<D extends DriverT> extends BaseWrapper<D, VwcAccordionItemElement> {
+    type: "accordionItem";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    expand: () => D["actionReturn"];
+    collapse: () => D["actionReturn"];
+}
+export declare class AccordionItem<D extends DriverT> extends BaseComponent<D, AccordionItemWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): AccordionItemWrapper<D>;
+    byTestId: (id: string) => AccordionItemWrapper<D>;
+    byHeading: (heading: string) => AccordionItemWrapper<D>;
+}
+export declare class AccordionItemExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: AccordionItemWrapper<D>);
+    toHaveProp: <T extends keyof AccordionItemProps>(propName: T, value: AccordionItemProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toBeExpanded: () => D["expectReturn"];
+    toBeCollapsed: () => D["expectReturn"];
+}
+type ActionGroupProps = {
+    appearance: 'fieldset' | 'ghost';
+    shape: 'rounded' | 'pill';
+    tight: boolean;
+};
+export declare class ActionGroupWrapper<D extends DriverT> extends BaseWrapper<D, VwcActionGroupElement> {
+    type: "actionGroup";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class ActionGroup<D extends DriverT> extends BaseComponent<D, ActionGroupWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): ActionGroupWrapper<D>;
+    byTestId: (id: string) => ActionGroupWrapper<D>;
+}
+export declare class ActionGroupExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: ActionGroupWrapper<D>);
+    toHaveProp: <T extends keyof ActionGroupProps>(propName: T, value: ActionGroupProps[T]) => D["expectReturn"];
+}
+type AlertProps = {
+    connotation: 'accent' | 'information' | 'success' | 'warning' | 'announcement' | 'alert';
+    dismissButtonAriaLabel: string;
+    headline: string;
+    icon: IconId;
+    open: boolean;
+    placement: 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end';
+    removable: boolean;
+    strategy: 'fixed' | 'static';
+    text: string;
+    timeoutms: number;
+};
+export declare class AlertWrapper<D extends DriverT> extends BaseWrapper<D, VwcAlertElement> {
+    type: "alert";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Alert<D extends DriverT> extends BaseComponent<D, AlertWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): AlertWrapper<D>;
+    byTestId: (id: string) => AlertWrapper<D>;
+    byHeadline: (headline: string) => AlertWrapper<D>;
+}
+export declare class AlertExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: AlertWrapper<D>);
+    toHaveProp: <T extends keyof AlertProps>(propName: T, value: AlertProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toBeOpen: () => D["expectReturn"];
+    toBeClosed: () => D["expectReturn"];
+}
+type AudioPlayerProps = {
+    connotation: 'accent' | 'cta';
+    disabled: boolean;
+    durationFallback: boolean;
+    notime: boolean;
+    pauseButtonAriaLabel: string;
+    playButtonAriaLabel: string;
+    playbackRates: string;
+    skipBackwardAriaLabel: string;
+    skipBy: '0' | '5' | '10' | '30';
+    skipForwardAriaLabel: string;
+    sliderAriaLabel: string;
+    src: string;
+};
+export declare class AudioPlayerWrapper<D extends DriverT> extends BaseWrapper<D, VwcAudioPlayerElement> {
+    type: "audioPlayer";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class AudioPlayer<D extends DriverT> extends BaseComponent<D, AudioPlayerWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): AudioPlayerWrapper<D>;
+    byTestId: (id: string) => AudioPlayerWrapper<D>;
+}
+export declare class AudioPlayerExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: AudioPlayerWrapper<D>);
+    toHaveProp: <T extends keyof AudioPlayerProps>(propName: T, value: AudioPlayerProps[T]) => D["expectReturn"];
+}
+type AvatarProps = {
+    appearance: 'filled' | 'outlined' | 'duotone' | 'subtle';
+    clickable: boolean;
+    connotation: 'accent' | 'cta';
+    download: string;
+    href: string;
+    hreflang: string;
+    icon: IconId;
+    initials: string;
+    ping: string;
+    referrerpolicy: string;
+    rel: string;
+    shape: 'rounded' | 'pill';
+    size: 'condensed' | 'normal' | 'expanded';
+    target: '_self' | '_blank' | '_parent' | '_top';
+    type: string;
+};
+export declare class AvatarWrapper<D extends DriverT> extends BaseWrapper<D, VwcAvatarElement> {
+    type: "avatar";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Avatar<D extends DriverT> extends BaseComponent<D, AvatarWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): AvatarWrapper<D>;
+    byTestId: (id: string) => AvatarWrapper<D>;
+}
+export declare class AvatarExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: AvatarWrapper<D>);
+    toHaveProp: <T extends keyof AvatarProps>(propName: T, value: AvatarProps[T]) => D["expectReturn"];
+}
+type BadgeProps = {
+    appearance: 'filled' | 'duotone' | 'subtle' | 'subtle-light';
+    connotation: 'accent' | 'cta' | 'success' | 'alert' | 'warning' | 'information' | 'announcement';
+    icon: IconId;
+    iconTrailing: boolean;
+    shape: 'rounded' | 'pill';
+    size: 'normal' | 'expanded';
+    text: string;
+};
+export declare class BadgeWrapper<D extends DriverT> extends BaseWrapper<D, VwcBadgeElement> {
+    type: "badge";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Badge<D extends DriverT> extends BaseComponent<D, BadgeWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): BadgeWrapper<D>;
+    byTestId: (id: string) => BadgeWrapper<D>;
+}
+export declare class BadgeExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: BadgeWrapper<D>);
+    toHaveProp: <T extends keyof BadgeProps>(propName: T, value: BadgeProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+}
+type BannerProps = {
+    actionHref: string;
+    actionText: string;
+    connotation: 'information' | 'announcement' | 'success' | 'warning' | 'alert';
+    dismissAriaLabel: string;
+    icon: IconId;
+    removable: boolean;
+    text: string;
+};
+export declare class BannerWrapper<D extends DriverT> extends BaseWrapper<D, VwcBannerElement> {
+    type: "banner";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    dismiss: () => D["actionReturn"];
+}
+export declare class Banner<D extends DriverT> extends BaseComponent<D, BannerWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): BannerWrapper<D>;
+    byTestId: (id: string) => BannerWrapper<D>;
+    byText: (text: string) => BannerWrapper<D>;
+}
+export declare class BannerExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: BannerWrapper<D>);
+    toHaveProp: <T extends keyof BannerProps>(propName: T, value: BannerProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+}
+export declare class BreadcrumbWrapper<D extends DriverT> extends BaseWrapper<D, VwcBreadcrumbElement> {
+    type: "breadcrumb";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Breadcrumb<D extends DriverT> extends BaseComponent<D, BreadcrumbWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): BreadcrumbWrapper<D>;
+    byTestId: (id: string) => BreadcrumbWrapper<D>;
+}
+export declare class BreadcrumbExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: BreadcrumbWrapper<D>);
+    toHaveProp: (propName: never, value: never) => never;
+}
+type BreadcrumbItemProps = {
+    download: string;
+    href: string;
+    hreflang: string;
+    ping: string;
+    referrerpolicy: string;
+    rel: string;
+    target: '_self' | '_blank' | '_parent' | '_top';
+    text: string;
+    type: string;
+};
+export declare class BreadcrumbItemWrapper<D extends DriverT> extends BaseWrapper<D, VwcBreadcrumbItemElement> {
+    type: "breadcrumbItem";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class BreadcrumbItem<D extends DriverT> extends BaseComponent<D, BreadcrumbItemWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): BreadcrumbItemWrapper<D>;
+    byTestId: (id: string) => BreadcrumbItemWrapper<D>;
+}
+export declare class BreadcrumbItemExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: BreadcrumbItemWrapper<D>);
+    toHaveProp: <T extends keyof BreadcrumbItemProps>(propName: T, value: BreadcrumbItemProps[T]) => D["expectReturn"];
+}
+type ButtonProps = {
+    active: boolean;
+    appearance: 'filled' | 'outlined' | 'ghost' | 'ghost-light' | 'outlined-light';
+    autofocus: boolean;
+    connotation: 'accent' | 'announcement' | 'cta' | 'success' | 'alert';
+    disabled: boolean;
+    download: string;
+    dropdownIndicator: boolean;
+    form: string;
+    formaction: string;
+    formenctype: string;
+    formmethod: string;
+    formnovalidate: boolean;
+    formtarget: '_self' | '_blank' | '_parent' | '_top';
+    href: string;
+    hreflang: string;
+    icon: IconId;
+    iconTrailing: boolean;
+    initialValue: string;
+    label: string;
+    name: string;
+    pending: boolean;
+    ping: string;
+    referrerpolicy: string;
+    rel: string;
+    required: boolean;
+    shape: 'rounded' | 'pill';
+    size: 'super-condensed' | 'condensed' | 'normal' | 'expanded';
+    stacked: boolean;
+    target: '_self' | '_blank' | '_parent' | '_top';
+    title: string;
+    type: 'submit' | 'reset' | 'button';
+    value: string;
+};
+export declare class ButtonWrapper<D extends DriverT> extends BaseWrapper<D, VwcButtonElement> {
+    type: "button";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    click: () => D["actionReturn"];
+}
+export declare class Button<D extends DriverT> extends BaseComponent<D, ButtonWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): ButtonWrapper<D>;
+    byTestId: (id: string) => ButtonWrapper<D>;
+    byLabel: (label: string) => ButtonWrapper<D>;
+}
+export declare class ButtonExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: ButtonWrapper<D>);
+    toHaveProp: <T extends keyof ButtonProps>(propName: T, value: ButtonProps[T]) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+}
+type CalendarProps = {
+    datetime: Date | string;
+    hour12: boolean;
+    locales: string | string[];
+    startDay: 'sunday' | 'monday';
+    stickyMode: 'none' | 'header' | 'column' | 'all';
+};
+export declare class CalendarWrapper<D extends DriverT> extends BaseWrapper<D, VwcCalendarElement> {
+    type: "calendar";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Calendar<D extends DriverT> extends BaseComponent<D, CalendarWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): CalendarWrapper<D>;
+    byTestId: (id: string) => CalendarWrapper<D>;
+}
+export declare class CalendarExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: CalendarWrapper<D>);
+    toHaveProp: <T extends keyof CalendarProps>(propName: T, value: CalendarProps[T]) => D["expectReturn"];
+}
+type CalendarEventProps = {
+    appearance: 'filled' | 'duotone' | 'subtle';
+    connotation: 'accent' | 'cta' | 'success' | 'alert' | 'warning' | 'information' | 'announcement';
+    description: string;
+    duration: number;
+    heading: string;
+    overlapCount: number;
+    start: number;
+};
+export declare class CalendarEventWrapper<D extends DriverT> extends BaseWrapper<D, VwcCalendarEventElement> {
+    type: "calendarEvent";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class CalendarEvent<D extends DriverT> extends BaseComponent<D, CalendarEventWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): CalendarEventWrapper<D>;
+    byTestId: (id: string) => CalendarEventWrapper<D>;
+}
+export declare class CalendarEventExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: CalendarEventWrapper<D>);
+    toHaveProp: <T extends keyof CalendarEventProps>(propName: T, value: CalendarEventProps[T]) => D["expectReturn"];
+}
+type CardProps = {
+    appearance: 'elevated' | 'ghost' | 'outlined';
+    clickableCard: boolean;
+    download: string;
+    elevation: 0 | 2 | 4 | 8 | 12 | 16 | 24;
+    headline: string;
+    href: string;
+    hreflang: string;
+    icon: IconId;
+    ping: string;
+    referrerpolicy: string;
+    rel: string;
+    subtitle: string;
+    target: '_self' | '_blank' | '_parent' | '_top';
+    text: string;
+    type: string;
+};
+export declare class CardWrapper<D extends DriverT> extends BaseWrapper<D, VwcCardElement> {
+    type: "card";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Card<D extends DriverT> extends BaseComponent<D, CardWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): CardWrapper<D>;
+    byTestId: (id: string) => CardWrapper<D>;
+}
+export declare class CardExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: CardWrapper<D>);
+    toHaveProp: <T extends keyof CardProps>(propName: T, value: CardProps[T]) => D["expectReturn"];
+    toHaveHeadline: (value: any) => D["expectReturn"];
+}
+type CheckboxProps = {
+    checked: boolean;
+    connotation: 'accent' | 'cta';
+    defaultChecked: boolean;
+    disabled: boolean;
+    errorText: string;
+    helperText: string;
+    indeterminate: boolean;
+    initialValue: string;
+    label: string;
+    name: string;
+    readonly: boolean;
+    required: boolean;
+    successText: string;
+    tabindex: string;
+    value: string;
+};
+export declare class CheckboxWrapper<D extends DriverT> extends BaseWrapper<D, VwcCheckboxElement> {
+    type: "checkbox";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    check: () => D["actionReturn"];
+    uncheck: () => D["actionReturn"];
+}
+export declare class Checkbox<D extends DriverT> extends BaseComponent<D, CheckboxWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): CheckboxWrapper<D>;
+    byTestId: (id: string) => CheckboxWrapper<D>;
+    byLabel: (label: string) => CheckboxWrapper<D>;
+}
+export declare class CheckboxExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: CheckboxWrapper<D>);
+    toHaveProp: <T extends keyof CheckboxProps>(propName: T, value: CheckboxProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+    toBeChecked: () => D["expectReturn"];
+    toBeUnchecked: () => D["expectReturn"];
+    toBeIndeterminate: () => D["expectReturn"];
+}
+type ComboboxProps = {
+    appearance: 'fieldset' | 'ghost';
+    autocomplete: 'inline' | 'list' | 'both' | 'none';
+    disabled: boolean;
+    errorText: string;
+    fixedDropdown: boolean;
+    helperText: string;
+    icon: IconId;
+    initialValue: string;
+    label: string;
+    name: string;
+    open: boolean;
+    placeholder: string;
+    placement: 'top' | 'bottom';
+    required: boolean;
+    scale: 'condensed' | 'normal';
+    shape: 'rounded' | 'pill';
+    successText: string;
+    value: string;
+};
+export declare class ComboboxWrapper<D extends DriverT> extends BaseWrapper<D, VwcComboboxElement> {
+    type: "combobox";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    fill: (text: string) => D["actionReturn"];
+    clear: () => D["actionReturn"];
+    selectOptionByText: (text: string) => D["actionReturn"];
+    selectOptionByValue: (value: string) => D["actionReturn"];
+}
+export declare class Combobox<D extends DriverT> extends BaseComponent<D, ComboboxWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): ComboboxWrapper<D>;
+    byTestId: (id: string) => ComboboxWrapper<D>;
+    byLabel: (label: string) => ComboboxWrapper<D>;
+}
+export declare class ComboboxExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: ComboboxWrapper<D>);
+    toHaveProp: <T extends keyof ComboboxProps>(propName: T, value: ComboboxProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+}
+type DataGridProps = {
+    fixedColumns: number;
+    generateHeader: 'none' | 'default' | 'sticky';
+    gridTemplateColumns: string;
+    noTabbing: boolean;
+    rowsData: any[];
+    selectionMode: 'none' | 'single-row' | 'multi-row' | 'single-cell' | 'multi-cell';
+};
+export declare class DataGridWrapper<D extends DriverT> extends BaseWrapper<D, VwcDataGridElement> {
+    type: "dataGrid";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class DataGrid<D extends DriverT> extends BaseComponent<D, DataGridWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): DataGridWrapper<D>;
+    byTestId: (id: string) => DataGridWrapper<D>;
+}
+export declare class DataGridExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: DataGridWrapper<D>);
+    toHaveProp: <T extends keyof DataGridProps>(propName: T, value: DataGridProps[T]) => D["expectReturn"];
+}
+type DataGridCellProps = {
+    cellType: 'default' | 'columnheader' | 'rowheader';
+    columnDefinition: object;
+    gridColumn: string;
+    selected: boolean;
+    sortDirection: 'none' | 'ascending' | 'descending' | 'other';
+};
+export declare class DataGridCellWrapper<D extends DriverT> extends BaseWrapper<D, VwcDataGridCellElement> {
+    type: "dataGridCell";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class DataGridCell<D extends DriverT> extends BaseComponent<D, DataGridCellWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): DataGridCellWrapper<D>;
+    byTestId: (id: string) => DataGridCellWrapper<D>;
+}
+export declare class DataGridCellExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: DataGridCellWrapper<D>);
+    toHaveProp: <T extends keyof DataGridCellProps>(propName: T, value: DataGridCellProps[T]) => D["expectReturn"];
+}
+type DataGridRowProps = {
+    gridTemplateColumns: string;
+    rowType: 'default' | 'header' | 'sticky-header';
+    selected: boolean;
+};
+export declare class DataGridRowWrapper<D extends DriverT> extends BaseWrapper<D, VwcDataGridRowElement> {
+    type: "dataGridRow";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class DataGridRow<D extends DriverT> extends BaseComponent<D, DataGridRowWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): DataGridRowWrapper<D>;
+    byTestId: (id: string) => DataGridRowWrapper<D>;
+}
+export declare class DataGridRowExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: DataGridRowWrapper<D>);
+    toHaveProp: <T extends keyof DataGridRowProps>(propName: T, value: DataGridRowProps[T]) => D["expectReturn"];
+}
+type DatePickerProps = {
+    disabled: boolean;
+    errorText: string;
+    helperText: string;
+    initialValue: string;
+    label: string;
+    max: string;
+    min: string;
+    name: string;
+    readonly: boolean;
+    required: boolean;
+    value: string;
+};
+export declare class DatePickerWrapper<D extends DriverT> extends BaseWrapper<D, VwcDatePickerElement> {
+    type: "datePicker";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    clear: () => D["actionReturn"];
+    selectDate: (date: string) => D["actionReturn"];
+}
+export declare class DatePicker<D extends DriverT> extends BaseComponent<D, DatePickerWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): DatePickerWrapper<D>;
+    byTestId: (id: string) => DatePickerWrapper<D>;
+    byLabel: (label: string) => DatePickerWrapper<D>;
+}
+export declare class DatePickerExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: DatePickerWrapper<D>);
+    toHaveProp: <T extends keyof DatePickerProps>(propName: T, value: DatePickerProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+}
+type DateRangePickerProps = {
+    disabled: boolean;
+    end: string;
+    errorText: string;
+    helperText: string;
+    initialEnd: string;
+    initialStart: string;
+    initialValue: string;
+    label: string;
+    max: string;
+    min: string;
+    name: string;
+    readonly: boolean;
+    required: boolean;
+    start: string;
+    value: string;
+};
+export declare class DateRangePickerWrapper<D extends DriverT> extends BaseWrapper<D, VwcDateRangePickerElement> {
+    type: "dateRangePicker";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    clear: () => D["actionReturn"];
+    selectDateRange: (range: [string, string]) => D["actionReturn"];
+}
+export declare class DateRangePicker<D extends DriverT> extends BaseComponent<D, DateRangePickerWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): DateRangePickerWrapper<D>;
+    byTestId: (id: string) => DateRangePickerWrapper<D>;
+    byLabel: (label: string) => DateRangePickerWrapper<D>;
+}
+export declare class DateRangePickerExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: DateRangePickerWrapper<D>);
+    toHaveProp: <T extends keyof DateRangePickerProps>(propName: T, value: DateRangePickerProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+    toHaveRange: (value: any) => D["expectReturn"];
+}
+type DateTimePickerProps = {
+    clock: '12h' | '24h';
+    disabled: boolean;
+    errorText: string;
+    helperText: string;
+    initialValue: string;
+    label: string;
+    max: string;
+    maxDate: string;
+    maxTime: string;
+    min: string;
+    minDate: string;
+    minTime: string;
+    minutesStep: number;
+    name: string;
+    readonly: boolean;
+    required: boolean;
+    secondsStep: number;
+    value: string;
+};
+export declare class DateTimePickerWrapper<D extends DriverT> extends BaseWrapper<D, VwcDateTimePickerElement> {
+    type: "dateTimePicker";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    clear: () => D["actionReturn"];
+    selectDateTime: (dateTime: string) => D["actionReturn"];
+}
+export declare class DateTimePicker<D extends DriverT> extends BaseComponent<D, DateTimePickerWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): DateTimePickerWrapper<D>;
+    byTestId: (id: string) => DateTimePickerWrapper<D>;
+    byLabel: (label: string) => DateTimePickerWrapper<D>;
+}
+export declare class DateTimePickerExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: DateTimePickerWrapper<D>);
+    toHaveProp: <T extends keyof DateTimePickerProps>(propName: T, value: DateTimePickerProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+}
+type DialPadProps = {
+    autofocus: boolean;
+    callActive: boolean;
+    callButtonLabel: string;
+    disabled: boolean;
+    endCallButtonLabel: string;
+    helperText: string;
+    noCall: boolean;
+    noInput: boolean;
+    pattern: string;
+    pending: boolean;
+    placeholder: string;
+    value: string;
+};
+export declare class DialPadWrapper<D extends DriverT> extends BaseWrapper<D, VwcDialPadElement> {
+    type: "dialPad";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class DialPad<D extends DriverT> extends BaseComponent<D, DialPadWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): DialPadWrapper<D>;
+    byTestId: (id: string) => DialPadWrapper<D>;
+}
+export declare class DialPadExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: DialPadWrapper<D>);
+    toHaveProp: <T extends keyof DialPadProps>(propName: T, value: DialPadProps[T]) => D["expectReturn"];
+}
+type DialogProps = {
+    dismissButtonAriaLabel: string;
+    fullWidthBody: boolean;
+    headline: string;
+    icon: IconId;
+    iconPlacement: 'top' | 'side';
+    modal: boolean;
+    noDismissButton: boolean;
+    noDismissOnEsc: boolean;
+    noLightDismiss: boolean;
+    nonDismissible: boolean;
+    open: boolean;
+    scrollableBody: boolean;
+    subtitle: string;
+};
+export declare class DialogWrapper<D extends DriverT> extends BaseWrapper<D, VwcDialogElement> {
+    type: "dialog";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    dismiss: () => D["actionReturn"];
+}
+export declare class Dialog<D extends DriverT> extends BaseComponent<D, DialogWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): DialogWrapper<D>;
+    byTestId: (id: string) => DialogWrapper<D>;
+    byHeadline: (headline: string) => DialogWrapper<D>;
+}
+export declare class DialogExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: DialogWrapper<D>);
+    toHaveProp: <T extends keyof DialogProps>(propName: T, value: DialogProps[T]) => D["expectReturn"];
+    toBeOpen: () => D["expectReturn"];
+    toBeClosed: () => D["expectReturn"];
+    toHaveHeadline: (value: any) => D["expectReturn"];
+}
+type DividerProps = {
+    appearance: 'ghost' | 'subtle';
+    orientation: 'horizontal' | 'vertical';
+};
+export declare class DividerWrapper<D extends DriverT> extends BaseWrapper<D, VwcDividerElement> {
+    type: "divider";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Divider<D extends DriverT> extends BaseComponent<D, DividerWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): DividerWrapper<D>;
+    byTestId: (id: string) => DividerWrapper<D>;
+}
+export declare class DividerExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: DividerWrapper<D>);
+    toHaveProp: <T extends keyof DividerProps>(propName: T, value: DividerProps[T]) => D["expectReturn"];
+}
+type EmptyStateProps = {
+    connotation: 'accent' | 'cta' | 'success' | 'alert' | 'warning' | 'information';
+    headline: string;
+    icon: IconId;
+    iconDecoration: 'outlined' | 'filled';
+};
+export declare class EmptyStateWrapper<D extends DriverT> extends BaseWrapper<D, VwcEmptyStateElement> {
+    type: "emptyState";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class EmptyState<D extends DriverT> extends BaseComponent<D, EmptyStateWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): EmptyStateWrapper<D>;
+    byTestId: (id: string) => EmptyStateWrapper<D>;
+}
+export declare class EmptyStateExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: EmptyStateWrapper<D>);
+    toHaveProp: <T extends keyof EmptyStateProps>(propName: T, value: EmptyStateProps[T]) => D["expectReturn"];
+}
+type FabProps = {
+    autofocus: boolean;
+    connotation: 'cta' | 'accent' | 'announcement';
+    disabled: boolean;
+    form: string;
+    formaction: string;
+    formenctype: string;
+    formmethod: string;
+    formnovalidate: boolean;
+    formtarget: '_self' | '_blank' | '_parent' | '_top';
+    icon: IconId;
+    iconTrailing: boolean;
+    initialValue: string;
+    label: string;
+    name: string;
+    required: boolean;
+    size: 'condensed' | 'normal' | 'expanded';
+    type: 'submit' | 'reset' | 'button';
+    value: string;
+};
+export declare class FabWrapper<D extends DriverT> extends BaseWrapper<D, VwcFabElement> {
+    type: "fab";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    click: () => D["actionReturn"];
+}
+export declare class Fab<D extends DriverT> extends BaseComponent<D, FabWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): FabWrapper<D>;
+    byTestId: (id: string) => FabWrapper<D>;
+    byLabel: (label: string) => FabWrapper<D>;
+}
+export declare class FabExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: FabWrapper<D>);
+    toHaveProp: <T extends keyof FabProps>(propName: T, value: FabProps[T]) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+}
+type FilePickerProps = {
+    accept: string;
+    disabled: boolean;
+    errorText: string;
+    fileTooBigError: string;
+    helperText: string;
+    initialValue: string;
+    invalidFileTypeError: string;
+    label: string;
+    maxFileSize: number;
+    maxFiles: number;
+    maxFilesExceededError: string;
+    name: string;
+    required: boolean;
+    singleFile: boolean;
+    size: 'normal' | 'expanded';
+    value: string;
+};
+export declare class FilePickerWrapper<D extends DriverT> extends BaseWrapper<D, VwcFilePickerElement> {
+    type: "filePicker";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class FilePicker<D extends DriverT> extends BaseComponent<D, FilePickerWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): FilePickerWrapper<D>;
+    byTestId: (id: string) => FilePickerWrapper<D>;
+    byLabel: (label: string) => FilePickerWrapper<D>;
+}
+export declare class FilePickerExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: FilePickerWrapper<D>);
+    toHaveProp: <T extends keyof FilePickerProps>(propName: T, value: FilePickerProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+}
+type HeaderProps = {
+    alternate: boolean;
+    elevationShadow: boolean;
+};
+export declare class HeaderWrapper<D extends DriverT> extends BaseWrapper<D, VwcHeaderElement> {
+    type: "header";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Header<D extends DriverT> extends BaseComponent<D, HeaderWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): HeaderWrapper<D>;
+    byTestId: (id: string) => HeaderWrapper<D>;
+}
+export declare class HeaderExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: HeaderWrapper<D>);
+    toHaveProp: <T extends keyof HeaderProps>(propName: T, value: HeaderProps[T]) => D["expectReturn"];
+}
+type IconProps = {
+    connotation: 'accent' | 'cta' | 'success' | 'alert' | 'warning' | 'information' | 'announcement';
+    label: string;
+    name: IconId;
+    size: -6 | -5 | -4 | -3 | -2 | -1 | 0 | 1 | 2 | 3 | 4 | 5;
+};
+export declare class IconWrapper<D extends DriverT> extends BaseWrapper<D, VwcIconElement> {
+    type: "icon";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Icon<D extends DriverT> extends BaseComponent<D, IconWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): IconWrapper<D>;
+    byTestId: (id: string) => IconWrapper<D>;
+}
+export declare class IconExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: IconWrapper<D>);
+    toHaveProp: <T extends keyof IconProps>(propName: T, value: IconProps[T]) => D["expectReturn"];
+    toHaveName: (value: any) => D["expectReturn"];
+}
+type LayoutProps = {
+    autoSizing: 'fit' | 'fill';
+    columnBasis: 'small' | 'medium' | 'large' | 'block';
+    columnSpacing: 'small' | 'medium' | 'large';
+    gutters: 'small' | 'medium' | 'large';
+    rowSpacing: 'small' | 'medium' | 'large';
+};
+export declare class LayoutWrapper<D extends DriverT> extends BaseWrapper<D, VwcLayoutElement> {
+    type: "layout";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Layout<D extends DriverT> extends BaseComponent<D, LayoutWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): LayoutWrapper<D>;
+    byTestId: (id: string) => LayoutWrapper<D>;
+}
+export declare class LayoutExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: LayoutWrapper<D>);
+    toHaveProp: <T extends keyof LayoutProps>(propName: T, value: LayoutProps[T]) => D["expectReturn"];
+}
+type MenuProps = {
+    anchor: string | HTMLElement;
+    autoDismiss: boolean;
+    offset: number;
+    open: boolean;
+    placement: 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+    positionStrategy: 'absolute' | 'fixed';
+    trigger: 'auto' | 'legacy' | 'off';
+};
+export declare class MenuWrapper<D extends DriverT> extends BaseWrapper<D, VwcMenuElement> {
+    type: "menu";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Menu<D extends DriverT> extends BaseComponent<D, MenuWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): MenuWrapper<D>;
+    byTestId: (id: string) => MenuWrapper<D>;
+    byLabel: (label: string) => MenuWrapper<D>;
+}
+export declare class MenuExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: MenuWrapper<D>);
+    toHaveProp: <T extends keyof MenuProps>(propName: T, value: MenuProps[T]) => D["expectReturn"];
+    toBeOpen: () => D["expectReturn"];
+    toBeClosed: () => D["expectReturn"];
+}
+type MenuItemProps = {
+    checkAppearance: 'normal' | 'tick-only';
+    checkTrailing: boolean;
+    checked: boolean;
+    connotation: 'cta' | 'accent';
+    controlType: 'checkbox' | 'radio';
+    disabled: boolean;
+    expanded: boolean;
+    icon: IconId;
+    text: string;
+    textSecondary: string;
+};
+export declare class MenuItemWrapper<D extends DriverT> extends BaseWrapper<D, VwcMenuItemElement> {
+    type: "menuItem";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    click: () => D["actionReturn"];
+}
+export declare class MenuItem<D extends DriverT> extends BaseComponent<D, MenuItemWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): MenuItemWrapper<D>;
+    byTestId: (id: string) => MenuItemWrapper<D>;
+    byText: (text: string) => MenuItemWrapper<D>;
+}
+export declare class MenuItemExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: MenuItemWrapper<D>);
+    toHaveProp: <T extends keyof MenuItemProps>(propName: T, value: MenuItemProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toBeChecked: () => D["expectReturn"];
+    toBeUnchecked: () => D["expectReturn"];
+    toHaveDisabled: (value: any) => D["expectReturn"];
+}
+export declare class NavWrapper<D extends DriverT> extends BaseWrapper<D, VwcNavElement> {
+    type: "nav";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Nav<D extends DriverT> extends BaseComponent<D, NavWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): NavWrapper<D>;
+    byTestId: (id: string) => NavWrapper<D>;
+}
+export declare class NavExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: NavWrapper<D>);
+    toHaveProp: (propName: never, value: never) => never;
+}
+type NavDisclosureProps = {
+    appearance: 'ghost' | 'ghost-light';
+    connotation: 'accent' | 'cta';
+    current: boolean;
+    icon: IconId;
+    label: string;
+    open: boolean;
+};
+export declare class NavDisclosureWrapper<D extends DriverT> extends BaseWrapper<D, VwcNavDisclosureElement> {
+    type: "navDisclosure";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    expand: () => D["actionReturn"];
+    collapse: () => D["actionReturn"];
+}
+export declare class NavDisclosure<D extends DriverT> extends BaseComponent<D, NavDisclosureWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): NavDisclosureWrapper<D>;
+    byTestId: (id: string) => NavDisclosureWrapper<D>;
+    byLabel: (label: string) => NavDisclosureWrapper<D>;
+}
+export declare class NavDisclosureExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: NavDisclosureWrapper<D>);
+    toHaveProp: <T extends keyof NavDisclosureProps>(propName: T, value: NavDisclosureProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toBeCurrent: () => D["expectReturn"];
+    notToBeCurrent: () => D["expectReturn"];
+    toBeOpen: () => D["expectReturn"];
+    toBeClosed: () => D["expectReturn"];
+}
+type NavItemProps = {
+    appearance: 'ghost' | 'ghost-light';
+    connotation: 'accent' | 'cta';
+    current: boolean;
+    download: string;
+    href: string;
+    hreflang: string;
+    icon: IconId;
+    ping: string;
+    referrerpolicy: string;
+    rel: string;
+    target: '_self' | '_blank' | '_parent' | '_top';
+    text: string;
+    type: string;
+};
+export declare class NavItemWrapper<D extends DriverT> extends BaseWrapper<D, VwcNavItemElement> {
+    type: "navItem";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    click: () => D["actionReturn"];
+}
+export declare class NavItem<D extends DriverT> extends BaseComponent<D, NavItemWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): NavItemWrapper<D>;
+    byTestId: (id: string) => NavItemWrapper<D>;
+    byLabel: (label: string) => NavItemWrapper<D>;
+}
+export declare class NavItemExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: NavItemWrapper<D>);
+    toHaveProp: <T extends keyof NavItemProps>(propName: T, value: NavItemProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toBeCurrent: () => D["expectReturn"];
+    notToBeCurrent: () => D["expectReturn"];
+}
+type NoteProps = {
+    connotation: 'accent' | 'information' | 'success' | 'warning' | 'announcement' | 'alert';
+    headline: string;
+    icon: IconId;
+};
+export declare class NoteWrapper<D extends DriverT> extends BaseWrapper<D, VwcNoteElement> {
+    type: "note";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Note<D extends DriverT> extends BaseComponent<D, NoteWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): NoteWrapper<D>;
+    byTestId: (id: string) => NoteWrapper<D>;
+}
+export declare class NoteExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: NoteWrapper<D>);
+    toHaveProp: <T extends keyof NoteProps>(propName: T, value: NoteProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+}
+type NumberFieldProps = {
+    appearance: 'fieldset' | 'ghost';
+    autoComplete: string;
+    autofocus: boolean;
+    decrementButtonAriaLabel: string;
+    disabled: boolean;
+    errorText: string;
+    helperText: string;
+    icon: IconId;
+    incrementButtonAriaLabel: string;
+    initialValue: string;
+    label: string;
+    list: string;
+    max: number;
+    maxlength: number;
+    min: number;
+    minlength: number;
+    name: string;
+    placeholder: string;
+    readonly: boolean;
+    required: boolean;
+    scale: 'condensed' | 'normal';
+    shape: 'rounded' | 'pill';
+    size: number;
+    step: number;
+    successText: string;
+    value: string;
+    valueAsNumber: number;
+};
+export declare class NumberFieldWrapper<D extends DriverT> extends BaseWrapper<D, VwcNumberFieldElement> {
+    type: "numberField";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    fill: (text: string) => D["actionReturn"];
+    clear: () => D["actionReturn"];
+    clickIncrement: () => D["actionReturn"];
+    clickDecrement: () => D["actionReturn"];
+}
+export declare class NumberField<D extends DriverT> extends BaseComponent<D, NumberFieldWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): NumberFieldWrapper<D>;
+    byTestId: (id: string) => NumberFieldWrapper<D>;
+    byLabel: (label: string) => NumberFieldWrapper<D>;
+}
+export declare class NumberFieldExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: NumberFieldWrapper<D>);
+    toHaveProp: <T extends keyof NumberFieldProps>(propName: T, value: NumberFieldProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+    toHaveValueAsNumber: (value: any) => D["expectReturn"];
+}
+type OptionProps = {
+    checked: boolean;
+    defaultSelected: boolean;
+    disabled: boolean;
+    icon: IconId;
+    iconTrailing: boolean;
+    label: string;
+    matchedText: string;
+    selected: boolean;
+    tagConnotation: 'accent' | 'cta';
+    text: string;
+    textSecondary: string;
+    value: string;
+};
+export declare class OptionWrapper<D extends DriverT> extends BaseWrapper<D, VwcOptionElement> {
+    type: "option";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    click: () => D["actionReturn"];
+}
+export declare class Option<D extends DriverT> extends BaseComponent<D, OptionWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): OptionWrapper<D>;
+    byTestId: (id: string) => OptionWrapper<D>;
+}
+export declare class OptionExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: OptionWrapper<D>);
+    toHaveProp: <T extends keyof OptionProps>(propName: T, value: OptionProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+}
+type PaginationProps = {
+    navIcons: boolean;
+    selectedIndex: number;
+    shape: 'rounded' | 'pill';
+    size: 'super-condensed' | 'condensed' | 'normal';
+    total: number;
+};
+export declare class PaginationWrapper<D extends DriverT> extends BaseWrapper<D, VwcPaginationElement> {
+    type: "pagination";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    clickNext: () => D["actionReturn"];
+    clickPrev: () => D["actionReturn"];
+    clickPageIndex: (pageIndex: number) => D["actionReturn"];
+}
+export declare class Pagination<D extends DriverT> extends BaseComponent<D, PaginationWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): PaginationWrapper<D>;
+    byTestId: (id: string) => PaginationWrapper<D>;
+}
+export declare class PaginationExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: PaginationWrapper<D>);
+    toHaveProp: <T extends keyof PaginationProps>(propName: T, value: PaginationProps[T]) => D["expectReturn"];
+    toHaveTotal: (value: any) => D["expectReturn"];
+    toHaveSelectedPage: (value: any) => D["expectReturn"];
+}
+type ProgressProps = {
+    connotation: 'accent' | 'success' | 'alert' | 'cta' | 'pacific';
+    max: number;
+    min: number;
+    paused: boolean;
+    reverse: boolean;
+    shape: 'rounded' | 'sharp';
+    value: number;
+};
+export declare class ProgressWrapper<D extends DriverT> extends BaseWrapper<D, VwcProgressElement> {
+    type: "progress";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Progress<D extends DriverT> extends BaseComponent<D, ProgressWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): ProgressWrapper<D>;
+    byTestId: (id: string) => ProgressWrapper<D>;
+}
+export declare class ProgressExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: ProgressWrapper<D>);
+    toHaveProp: <T extends keyof ProgressProps>(propName: T, value: ProgressProps[T]) => D["expectReturn"];
+}
+type ProgressRingProps = {
+    connotation: 'accent' | 'success' | 'alert' | 'cta';
+    max: number;
+    min: number;
+    paused: boolean;
+    size: -6 | -5 | -4 | -3 | -2 | -1 | 0 | 1 | 2 | 3 | 4 | 5;
+    value: number;
+};
+export declare class ProgressRingWrapper<D extends DriverT> extends BaseWrapper<D, VwcProgressRingElement> {
+    type: "progressRing";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class ProgressRing<D extends DriverT> extends BaseComponent<D, ProgressRingWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): ProgressRingWrapper<D>;
+    byTestId: (id: string) => ProgressRingWrapper<D>;
+}
+export declare class ProgressRingExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: ProgressRingWrapper<D>);
+    toHaveProp: <T extends keyof ProgressRingProps>(propName: T, value: ProgressRingProps[T]) => D["expectReturn"];
+}
+type RadioProps = {
+    checked: boolean;
+    connotation: 'accent' | 'cta';
+    defaultChecked: boolean;
+    disabled: boolean;
+    errorText: string;
+    initialValue: string;
+    label: string;
+    name: string;
+    readonly: boolean;
+    required: boolean;
+    value: string;
+};
+export declare class RadioWrapper<D extends DriverT> extends BaseWrapper<D, VwcRadioElement> {
+    type: "radio";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    check: () => D["actionReturn"];
+}
+export declare class Radio<D extends DriverT> extends BaseComponent<D, RadioWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): RadioWrapper<D>;
+    byTestId: (id: string) => RadioWrapper<D>;
+    byLabel: (label: string) => RadioWrapper<D>;
+}
+export declare class RadioExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: RadioWrapper<D>);
+    toHaveProp: <T extends keyof RadioProps>(propName: T, value: RadioProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+    toBeChecked: () => D["expectReturn"];
+    toBeUnchecked: () => D["expectReturn"];
+}
+type RadioGroupProps = {
+    disabled: boolean;
+    errorText: string;
+    helperText: string;
+    label: string;
+    name: string;
+    orientation: 'horizontal' | 'vertical' | 'horizontal' | 'vertical';
+    readonly: boolean;
+    required: boolean;
+    value: string;
+};
+export declare class RadioGroupWrapper<D extends DriverT> extends BaseWrapper<D, VwcRadioGroupElement> {
+    type: "radioGroup";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class RadioGroup<D extends DriverT> extends BaseComponent<D, RadioGroupWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): RadioGroupWrapper<D>;
+    byTestId: (id: string) => RadioGroupWrapper<D>;
+}
+export declare class RadioGroupExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: RadioGroupWrapper<D>);
+    toHaveProp: <T extends keyof RadioGroupProps>(propName: T, value: RadioGroupProps[T]) => D["expectReturn"];
+}
+type RangeSliderProps = {
+    ariaEndLabel: string;
+    ariaStartLabel: string;
+    connotation: 'accent' | 'cta';
+    disabled: boolean;
+    end: string;
+    endAsNumber: number;
+    initialEnd: string;
+    initialStart: string;
+    initialValue: string;
+    label: string;
+    markers: boolean;
+    max: number;
+    min: number;
+    name: string;
+    orientation: 'horizontal' | 'vertical';
+    pin: boolean;
+    required: boolean;
+    start: string;
+    startAsNumber: number;
+    step: number;
+    value: string;
+};
+export declare class RangeSliderWrapper<D extends DriverT> extends BaseWrapper<D, VwcRangeSliderElement> {
+    type: "rangeSlider";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    slideStartTo: (value: number) => D["actionReturn"];
+    slideEndTo: (value: number) => D["actionReturn"];
+}
+export declare class RangeSlider<D extends DriverT> extends BaseComponent<D, RangeSliderWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): RangeSliderWrapper<D>;
+    byTestId: (id: string) => RangeSliderWrapper<D>;
+    byLabel: (label: string) => RangeSliderWrapper<D>;
+}
+export declare class RangeSliderExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: RangeSliderWrapper<D>);
+    toHaveProp: <T extends keyof RangeSliderProps>(propName: T, value: RangeSliderProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+    toHaveRange: (value: any) => D["expectReturn"];
+}
+type RichTextEditorProps = {
+    placeholder: string;
+    selectionEnd: number;
+    selectionStart: number;
+};
+export declare class RichTextEditorWrapper<D extends DriverT> extends BaseWrapper<D, VwcRichTextEditorElement> {
+    type: "richTextEditor";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class RichTextEditor<D extends DriverT> extends BaseComponent<D, RichTextEditorWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): RichTextEditorWrapper<D>;
+    byTestId: (id: string) => RichTextEditorWrapper<D>;
+}
+export declare class RichTextEditorExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: RichTextEditorWrapper<D>);
+    toHaveProp: <T extends keyof RichTextEditorProps>(propName: T, value: RichTextEditorProps[T]) => D["expectReturn"];
+}
+type SearchableSelectProps = {
+    appearance: 'fieldset' | 'ghost';
+    clearable: boolean;
+    disabled: boolean;
+    errorText: string;
+    externalTags: boolean;
+    fixedDropdown: boolean;
+    helperText: string;
+    icon: IconId;
+    iconTrailing: boolean;
+    initialValue: string;
+    label: string;
+    loading: boolean;
+    maxLines: number;
+    maxSelected: number;
+    multiple: boolean;
+    name: string;
+    open: boolean;
+    optionFilter: any;
+    placeholder: string;
+    required: boolean;
+    shape: 'rounded' | 'pill';
+    successText: string;
+    value: string;
+    values: string[];
+};
+export declare class SearchableSelectWrapper<D extends DriverT> extends BaseWrapper<D, VwcSearchableSelectElement> {
+    type: "searchableSelect";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    selectOptionByValue: (value: string) => D["actionReturn"];
+    selectOptionByText: (text: string) => D["actionReturn"];
+}
+export declare class SearchableSelect<D extends DriverT> extends BaseComponent<D, SearchableSelectWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): SearchableSelectWrapper<D>;
+    byTestId: (id: string) => SearchableSelectWrapper<D>;
+    byLabel: (label: string) => SearchableSelectWrapper<D>;
+}
+export declare class SearchableSelectExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: SearchableSelectWrapper<D>);
+    toHaveProp: <T extends keyof SearchableSelectProps>(propName: T, value: SearchableSelectProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+    toHaveValues: (value: any) => D["expectReturn"];
+    toHaveSelectedOptions: (value: any) => D["expectReturn"];
+}
+type SelectProps = {
+    appearance: 'fieldset' | 'ghost';
+    disabled: boolean;
+    errorText: string;
+    fixedDropdown: boolean;
+    helperText: string;
+    icon: IconId;
+    iconTrailing: boolean;
+    initialValue: string;
+    label: string;
+    multiple: boolean;
+    name: string;
+    open: boolean;
+    placeholder: string;
+    required: boolean;
+    scale: 'condensed' | 'normal';
+    shape: 'rounded' | 'pill';
+    successText: string;
+    value: string;
+};
+export declare class SelectWrapper<D extends DriverT> extends BaseWrapper<D, VwcSelectElement> {
+    type: "select";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    selectOptionByValue: (value: string) => D["actionReturn"];
+    selectOptionByText: (text: string) => D["actionReturn"];
+}
+export declare class Select<D extends DriverT> extends BaseComponent<D, SelectWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): SelectWrapper<D>;
+    byTestId: (id: string) => SelectWrapper<D>;
+    byLabel: (label: string) => SelectWrapper<D>;
+}
+export declare class SelectExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: SelectWrapper<D>);
+    toHaveProp: <T extends keyof SelectProps>(propName: T, value: SelectProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+}
+type SelectableBoxProps = {
+    checked: boolean;
+    clickableBox: boolean;
+    connotation: 'accent' | 'cta';
+    controlPlacement: 'start' | 'start-stacked' | 'end' | 'end-stacked';
+    controlType: 'checkbox' | 'radio';
+    tight: boolean;
+};
+export declare class SelectableBoxWrapper<D extends DriverT> extends BaseWrapper<D, VwcSelectableBoxElement> {
+    type: "selectableBox";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    check: () => D["actionReturn"];
+    uncheck: () => D["actionReturn"];
+}
+export declare class SelectableBox<D extends DriverT> extends BaseComponent<D, SelectableBoxWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): SelectableBoxWrapper<D>;
+    byTestId: (id: string) => SelectableBoxWrapper<D>;
+}
+export declare class SelectableBoxExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: SelectableBoxWrapper<D>);
+    toHaveProp: <T extends keyof SelectableBoxProps>(propName: T, value: SelectableBoxProps[T]) => D["expectReturn"];
+    toBeChecked: () => D["expectReturn"];
+    toBeUnchecked: () => D["expectReturn"];
+}
+type SideDrawerProps = {
+    alternate: boolean;
+    modal: boolean;
+    open: boolean;
+    trailing: boolean;
+};
+export declare class SideDrawerWrapper<D extends DriverT> extends BaseWrapper<D, VwcSideDrawerElement> {
+    type: "sideDrawer";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class SideDrawer<D extends DriverT> extends BaseComponent<D, SideDrawerWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): SideDrawerWrapper<D>;
+    byTestId: (id: string) => SideDrawerWrapper<D>;
+}
+export declare class SideDrawerExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: SideDrawerWrapper<D>);
+    toHaveProp: <T extends keyof SideDrawerProps>(propName: T, value: SideDrawerProps[T]) => D["expectReturn"];
+}
+type SimpleColorPickerProps = {
+    anchor: string | HTMLElement;
+    disabled: boolean;
+    initialValue: string;
+    label: string;
+    name: string;
+    open: boolean;
+    placement: 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+    required: boolean;
+    swatchesPerRow: number;
+    value: string;
+};
+export declare class SimpleColorPickerWrapper<D extends DriverT> extends BaseWrapper<D, VwcSimpleColorPickerElement> {
+    type: "simpleColorPicker";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class SimpleColorPicker<D extends DriverT> extends BaseComponent<D, SimpleColorPickerWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): SimpleColorPickerWrapper<D>;
+    byTestId: (id: string) => SimpleColorPickerWrapper<D>;
+    byLabel: (label: string) => SimpleColorPickerWrapper<D>;
+}
+export declare class SimpleColorPickerExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: SimpleColorPickerWrapper<D>);
+    toHaveProp: <T extends keyof SimpleColorPickerProps>(propName: T, value: SimpleColorPickerProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+}
+type SliderProps = {
+    connotation: 'accent' | 'cta';
+    disabled: boolean;
+    initialValue: string;
+    markers: boolean;
+    max: number;
+    min: number;
+    mode: 'single-value';
+    name: string;
+    orientation: 'horizontal' | 'vertical';
+    pin: boolean;
+    readonly: boolean;
+    required: boolean;
+    step: number;
+    value: string;
+    valueAsNumber: number;
+};
+export declare class SliderWrapper<D extends DriverT> extends BaseWrapper<D, VwcSliderElement> {
+    type: "slider";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    slideTo: (value: number) => D["actionReturn"];
+}
+export declare class Slider<D extends DriverT> extends BaseComponent<D, SliderWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): SliderWrapper<D>;
+    byTestId: (id: string) => SliderWrapper<D>;
+    byLabel: (label: string) => SliderWrapper<D>;
+}
+export declare class SliderExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: SliderWrapper<D>);
+    toHaveProp: <T extends keyof SliderProps>(propName: T, value: SliderProps[T]) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+    toHaveValueAsNumber: (value: any) => D["expectReturn"];
+}
+type SplitButtonProps = {
+    appearance: 'filled' | 'outlined' | 'ghost' | 'outlined-light';
+    connotation: 'accent' | 'announcement' | 'cta' | 'success' | 'alert';
+    disabled: boolean;
+    icon: IconId;
+    indicatorAriaLabel: string;
+    label: string;
+    shape: 'rounded' | 'pill';
+    size: 'super-condensed' | 'condensed' | 'normal' | 'expanded';
+    splitIndicator: string;
+};
+export declare class SplitButtonWrapper<D extends DriverT> extends BaseWrapper<D, VwcSplitButtonElement> {
+    type: "splitButton";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    clickAction: () => D["actionReturn"];
+    clickIndicator: () => D["actionReturn"];
+}
+export declare class SplitButton<D extends DriverT> extends BaseComponent<D, SplitButtonWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): SplitButtonWrapper<D>;
+    byTestId: (id: string) => SplitButtonWrapper<D>;
+    byLabel: (label: string) => SplitButtonWrapper<D>;
+}
+export declare class SplitButtonExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: SplitButtonWrapper<D>);
+    toHaveProp: <T extends keyof SplitButtonProps>(propName: T, value: SplitButtonProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+}
+type SwitchProps = {
+    checked: boolean;
+    connotation: 'accent' | 'alert' | 'announcement' | 'success' | 'cta';
+    defaultChecked: boolean;
+    disabled: boolean;
+    initialValue: string;
+    label: string;
+    name: string;
+    readonly: boolean;
+    required: boolean;
+    value: string;
+};
+export declare class SwitchWrapper<D extends DriverT> extends BaseWrapper<D, VwcSwitchElement> {
+    type: "switch";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    check: () => D["actionReturn"];
+    uncheck: () => D["actionReturn"];
+}
+export declare class Switch<D extends DriverT> extends BaseComponent<D, SwitchWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): SwitchWrapper<D>;
+    byTestId: (id: string) => SwitchWrapper<D>;
+    byLabel: (label: string) => SwitchWrapper<D>;
+}
+export declare class SwitchExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: SwitchWrapper<D>);
+    toHaveProp: <T extends keyof SwitchProps>(propName: T, value: SwitchProps[T]) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+    toBeChecked: () => D["expectReturn"];
+    toBeUnchecked: () => D["expectReturn"];
+}
+type TabProps = {
+    connotation: 'accent' | 'cta';
+    disabled: boolean;
+    icon: IconId;
+    iconTrailing: boolean;
+    label: string;
+    removable: boolean;
+    shape: 'rounded' | 'sharp';
+    tabIndex: number;
+};
+export declare class TabWrapper<D extends DriverT> extends BaseWrapper<D, VwcTabElement> {
+    type: "tab";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    select: () => D["actionReturn"];
+}
+export declare class Tab<D extends DriverT> extends BaseComponent<D, TabWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): TabWrapper<D>;
+    byTestId: (id: string) => TabWrapper<D>;
+    byLabel: (label: string) => TabWrapper<D>;
+}
+export declare class TabExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: TabWrapper<D>);
+    toHaveProp: <T extends keyof TabProps>(propName: T, value: TabProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toBeActive: () => D["expectReturn"];
+    toBeInactive: () => D["expectReturn"];
+}
+export declare class TabPanelWrapper<D extends DriverT> extends BaseWrapper<D, VwcTabPanelElement> {
+    type: "tabPanel";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class TabPanel<D extends DriverT> extends BaseComponent<D, TabPanelWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): TabPanelWrapper<D>;
+    byTestId: (id: string) => TabPanelWrapper<D>;
+}
+export declare class TabPanelExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: TabPanelWrapper<D>);
+    toHaveProp: (propName: never, value: never) => never;
+}
+type TabsProps = {
+    activeid: string;
+    activeindicator: boolean;
+    connotation: 'accent' | 'cta';
+    gutters: 'none' | 'small';
+    orientation: 'vertical' | 'horizontal';
+    scrollablePanel: boolean;
+    tabsLayout: 'align-start' | 'stretch';
+};
+export declare class TabsWrapper<D extends DriverT> extends BaseWrapper<D, VwcTabsElement> {
+    type: "tabs";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Tabs<D extends DriverT> extends BaseComponent<D, TabsWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): TabsWrapper<D>;
+    byTestId: (id: string) => TabsWrapper<D>;
+}
+export declare class TabsExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: TabsWrapper<D>);
+    toHaveProp: <T extends keyof TabsProps>(propName: T, value: TabsProps[T]) => D["expectReturn"];
+}
+type TagProps = {
+    appearance: 'subtle' | 'duotone' | 'subtle-light';
+    connotation: 'accent' | 'cta';
+    disabled: boolean;
+    icon: IconId;
+    label: string;
+    removable: boolean;
+    selectable: boolean;
+    selected: boolean;
+    shape: 'rounded' | 'pill';
+};
+export declare class TagWrapper<D extends DriverT> extends BaseWrapper<D, VwcTagElement> {
+    type: "tag";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    click: () => D["actionReturn"];
+    remove: () => D["actionReturn"];
+    select: () => D["actionReturn"];
+    unselect: () => D["actionReturn"];
+}
+export declare class Tag<D extends DriverT> extends BaseComponent<D, TagWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): TagWrapper<D>;
+    byTestId: (id: string) => TagWrapper<D>;
+    byLabel: (label: string) => TagWrapper<D>;
+}
+export declare class TagExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: TagWrapper<D>);
+    toHaveProp: <T extends keyof TagProps>(propName: T, value: TagProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toBeSelected: () => D["expectReturn"];
+    toBeUnselected: () => D["expectReturn"];
+    toBeDisabled: () => D["expectReturn"];
+    notToBeDisabled: () => D["expectReturn"];
+}
+export declare class TagGroupWrapper<D extends DriverT> extends BaseWrapper<D, VwcTagGroupElement> {
+    type: "tagGroup";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class TagGroup<D extends DriverT> extends BaseComponent<D, TagGroupWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): TagGroupWrapper<D>;
+    byTestId: (id: string) => TagGroupWrapper<D>;
+}
+export declare class TagGroupExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: TagGroupWrapper<D>);
+    toHaveProp: (propName: never, value: never) => never;
+}
+type TextAreaProps = {
+    autofocus: boolean;
+    charCount: boolean;
+    cols: number;
+    disabled: boolean;
+    errorText: string;
+    form: string;
+    helperText: string;
+    initialValue: string;
+    label: string;
+    list: string;
+    maxlength: number;
+    minlength: number;
+    name: string;
+    placeholder: string;
+    readOnly: boolean;
+    required: boolean;
+    resize: 'none' | 'both' | 'horizontal' | 'vertical';
+    rows: number;
+    spellcheck: boolean;
+    successText: string;
+    value: string;
+    wrap: 'hard' | 'soft' | 'off';
+};
+export declare class TextAreaWrapper<D extends DriverT> extends BaseWrapper<D, VwcTextAreaElement> {
+    type: "textArea";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    fill: (text: string) => D["actionReturn"];
+    clear: () => D["actionReturn"];
+}
+export declare class TextArea<D extends DriverT> extends BaseComponent<D, TextAreaWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): TextAreaWrapper<D>;
+    byTestId: (id: string) => TextAreaWrapper<D>;
+    byLabel: (label: string) => TextAreaWrapper<D>;
+}
+export declare class TextAreaExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: TextAreaWrapper<D>);
+    toHaveProp: <T extends keyof TextAreaProps>(propName: T, value: TextAreaProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+}
+type TextFieldProps = {
+    appearance: 'fieldset' | 'ghost';
+    autoComplete: string;
+    autofocus: boolean;
+    charCount: boolean;
+    disabled: boolean;
+    errorText: string;
+    helperText: string;
+    icon: IconId;
+    initialValue: string;
+    inputmode: string;
+    label: string;
+    list: string;
+    maxlength: number;
+    minlength: number;
+    name: string;
+    pattern: string;
+    placeholder: string;
+    readonly: boolean;
+    required: boolean;
+    scale: 'condensed' | 'normal';
+    shape: 'rounded' | 'pill';
+    size: number;
+    spellcheck: boolean;
+    successText: string;
+    type: 'email' | 'password' | 'tel' | 'text' | 'url';
+    value: string;
+};
+export declare class TextFieldWrapper<D extends DriverT> extends BaseWrapper<D, VwcTextFieldElement> {
+    type: "textField";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    fill: (text: string) => D["actionReturn"];
+    clear: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class TextField<D extends DriverT> extends BaseComponent<D, TextFieldWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): TextFieldWrapper<D>;
+    byTestId: (id: string) => TextFieldWrapper<D>;
+    byLabel: (label: string) => TextFieldWrapper<D>;
+}
+export declare class TextFieldExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: TextFieldWrapper<D>);
+    toHaveProp: <T extends keyof TextFieldProps>(propName: T, value: TextFieldProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+}
+type TimePickerProps = {
+    clock: '12h' | '24h';
+    disabled: boolean;
+    errorText: string;
+    helperText: string;
+    initialValue: string;
+    label: string;
+    max: string;
+    min: string;
+    minutesStep: number;
+    name: string;
+    readonly: boolean;
+    required: boolean;
+    secondsStep: number;
+    value: string;
+};
+export declare class TimePickerWrapper<D extends DriverT> extends BaseWrapper<D, VwcTimePickerElement> {
+    type: "timePicker";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+    clear: () => D["actionReturn"];
+    selectTime: (time: string) => D["actionReturn"];
+}
+export declare class TimePicker<D extends DriverT> extends BaseComponent<D, TimePickerWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): TimePickerWrapper<D>;
+    byTestId: (id: string) => TimePickerWrapper<D>;
+    byLabel: (label: string) => TimePickerWrapper<D>;
+}
+export declare class TimePickerExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: TimePickerWrapper<D>);
+    toHaveProp: <T extends keyof TimePickerProps>(propName: T, value: TimePickerProps[T]) => D["expectReturn"];
+    toHaveVisibleError: (value: any) => D["expectReturn"];
+    toHaveValue: (value: any) => D["expectReturn"];
+}
+type ToggletipProps = {
+    alternate: boolean;
+    anchor: string | HTMLElement;
+    headline: string;
+    open: boolean;
+    placement: 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+};
+export declare class ToggletipWrapper<D extends DriverT> extends BaseWrapper<D, VwcToggletipElement> {
+    type: "toggletip";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Toggletip<D extends DriverT> extends BaseComponent<D, ToggletipWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): ToggletipWrapper<D>;
+    byTestId: (id: string) => ToggletipWrapper<D>;
+    byHeadline: (headline: string) => ToggletipWrapper<D>;
+}
+export declare class ToggletipExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: ToggletipWrapper<D>);
+    toHaveProp: <T extends keyof ToggletipProps>(propName: T, value: ToggletipProps[T]) => D["expectReturn"];
+    toBeOpen: () => D["expectReturn"];
+    toBeClosed: () => D["expectReturn"];
+}
+type TooltipProps = {
+    anchor: string | HTMLElement;
+    open: boolean;
+    placement: 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+    text: string;
+};
+export declare class TooltipWrapper<D extends DriverT> extends BaseWrapper<D, VwcTooltipElement> {
+    type: "tooltip";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class Tooltip<D extends DriverT> extends BaseComponent<D, TooltipWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): TooltipWrapper<D>;
+    byTestId: (id: string) => TooltipWrapper<D>;
+    byText: (text: string) => TooltipWrapper<D>;
+}
+export declare class TooltipExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: TooltipWrapper<D>);
+    toHaveProp: <T extends keyof TooltipProps>(propName: T, value: TooltipProps[T]) => D["expectReturn"];
+    toBeOpen: () => D["expectReturn"];
+    toBeClosed: () => D["expectReturn"];
+}
+type TreeItemProps = {
+    disabled: boolean;
+    expanded: boolean;
+    icon: IconId;
+    selected: boolean;
+    text: string;
+};
+export declare class TreeItemWrapper<D extends DriverT> extends BaseWrapper<D, VwcTreeItemElement> {
+    type: "treeItem";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class TreeItem<D extends DriverT> extends BaseComponent<D, TreeItemWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): TreeItemWrapper<D>;
+    byTestId: (id: string) => TreeItemWrapper<D>;
+}
+export declare class TreeItemExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: TreeItemWrapper<D>);
+    toHaveProp: <T extends keyof TreeItemProps>(propName: T, value: TreeItemProps[T]) => D["expectReturn"];
+    toHaveIcon: (value: any) => D["expectReturn"];
+}
+type TreeViewProps = {
+    renderCollapsedNodes: boolean;
+};
+export declare class TreeViewWrapper<D extends DriverT> extends BaseWrapper<D, VwcTreeViewElement> {
+    type: "treeView";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class TreeView<D extends DriverT> extends BaseComponent<D, TreeViewWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): TreeViewWrapper<D>;
+    byTestId: (id: string) => TreeViewWrapper<D>;
+}
+export declare class TreeViewExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: TreeViewWrapper<D>);
+    toHaveProp: <T extends "renderCollapsedNodes">(propName: T, value: TreeViewProps[T]) => D["expectReturn"];
+}
+type VideoPlayerProps = {
+    autoplay: boolean;
+    loop: boolean;
+    playbackRates: string;
+    poster: string;
+    skipBy: '0' | '5' | '10' | '30';
+    src: string;
+};
+export declare class VideoPlayerWrapper<D extends DriverT> extends BaseWrapper<D, VwcVideoPlayerElement> {
+    type: "videoPlayer";
+    componentInfo: {
+        name: string;
+    };
+    hover: () => D["actionReturn"];
+    focus: () => D["actionReturn"];
+    blur: () => D["actionReturn"];
+}
+export declare class VideoPlayer<D extends DriverT> extends BaseComponent<D, VideoPlayerWrapper<D>> {
+    componentInfo: {
+        name: string;
+    };
+    wrap(locator: D['locator']): VideoPlayerWrapper<D>;
+    byTestId: (id: string) => VideoPlayerWrapper<D>;
+}
+export declare class VideoPlayerExpectations<D extends DriverT> {
+    private readonly ctx;
+    private readonly wrapper;
+    constructor(ctx: Context<D>, wrapper: VideoPlayerWrapper<D>);
+    toHaveProp: <T extends keyof VideoPlayerProps>(propName: T, value: VideoPlayerProps[T]) => D["expectReturn"];
+}
+type Expectations<D extends DriverT> = {
+    collection: ComponentCollectionExpectations<D>;
+    accordion: AccordionExpectations<D>;
+    accordionItem: AccordionItemExpectations<D>;
+    actionGroup: ActionGroupExpectations<D>;
+    alert: AlertExpectations<D>;
+    audioPlayer: AudioPlayerExpectations<D>;
+    avatar: AvatarExpectations<D>;
+    badge: BadgeExpectations<D>;
+    banner: BannerExpectations<D>;
+    breadcrumb: BreadcrumbExpectations<D>;
+    breadcrumbItem: BreadcrumbItemExpectations<D>;
+    button: ButtonExpectations<D>;
+    calendar: CalendarExpectations<D>;
+    calendarEvent: CalendarEventExpectations<D>;
+    card: CardExpectations<D>;
+    checkbox: CheckboxExpectations<D>;
+    combobox: ComboboxExpectations<D>;
+    dataGrid: DataGridExpectations<D>;
+    dataGridCell: DataGridCellExpectations<D>;
+    dataGridRow: DataGridRowExpectations<D>;
+    datePicker: DatePickerExpectations<D>;
+    dateRangePicker: DateRangePickerExpectations<D>;
+    dateTimePicker: DateTimePickerExpectations<D>;
+    dialPad: DialPadExpectations<D>;
+    dialog: DialogExpectations<D>;
+    divider: DividerExpectations<D>;
+    emptyState: EmptyStateExpectations<D>;
+    fab: FabExpectations<D>;
+    filePicker: FilePickerExpectations<D>;
+    header: HeaderExpectations<D>;
+    icon: IconExpectations<D>;
+    layout: LayoutExpectations<D>;
+    menu: MenuExpectations<D>;
+    menuItem: MenuItemExpectations<D>;
+    nav: NavExpectations<D>;
+    navDisclosure: NavDisclosureExpectations<D>;
+    navItem: NavItemExpectations<D>;
+    note: NoteExpectations<D>;
+    numberField: NumberFieldExpectations<D>;
+    option: OptionExpectations<D>;
+    pagination: PaginationExpectations<D>;
+    progress: ProgressExpectations<D>;
+    progressRing: ProgressRingExpectations<D>;
+    radio: RadioExpectations<D>;
+    radioGroup: RadioGroupExpectations<D>;
+    rangeSlider: RangeSliderExpectations<D>;
+    richTextEditor: RichTextEditorExpectations<D>;
+    searchableSelect: SearchableSelectExpectations<D>;
+    select: SelectExpectations<D>;
+    selectableBox: SelectableBoxExpectations<D>;
+    sideDrawer: SideDrawerExpectations<D>;
+    simpleColorPicker: SimpleColorPickerExpectations<D>;
+    slider: SliderExpectations<D>;
+    splitButton: SplitButtonExpectations<D>;
+    switch: SwitchExpectations<D>;
+    tab: TabExpectations<D>;
+    tabPanel: TabPanelExpectations<D>;
+    tabs: TabsExpectations<D>;
+    tag: TagExpectations<D>;
+    tagGroup: TagGroupExpectations<D>;
+    textArea: TextAreaExpectations<D>;
+    textField: TextFieldExpectations<D>;
+    timePicker: TimePickerExpectations<D>;
+    toggletip: ToggletipExpectations<D>;
+    tooltip: TooltipExpectations<D>;
+    treeItem: TreeItemExpectations<D>;
+    treeView: TreeViewExpectations<D>;
+    videoPlayer: VideoPlayerExpectations<D>;
+};
+type ComponentLocator<D extends DriverT> = BaseWrapper<D> & {
+    type: keyof Expectations<D>;
+};
+export declare class VividWrapper<D extends DriverT> {
+    protected readonly ctx: Context<D>;
+    constructor(ctx: Context<D>);
+    expect<K extends ComponentLocator<D> | ComponentCollectionLocator<D, any>>(componentLocator: K): Expectations<D>[K['type']];
+    accordion: Accordion<D>;
+    accordionItem: AccordionItem<D>;
+    actionGroup: ActionGroup<D>;
+    alert: Alert<D>;
+    audioPlayer: AudioPlayer<D>;
+    avatar: Avatar<D>;
+    badge: Badge<D>;
+    banner: Banner<D>;
+    breadcrumb: Breadcrumb<D>;
+    breadcrumbItem: BreadcrumbItem<D>;
+    button: Button<D>;
+    calendar: Calendar<D>;
+    calendarEvent: CalendarEvent<D>;
+    card: Card<D>;
+    checkbox: Checkbox<D>;
+    combobox: Combobox<D>;
+    dataGrid: DataGrid<D>;
+    dataGridCell: DataGridCell<D>;
+    dataGridRow: DataGridRow<D>;
+    datePicker: DatePicker<D>;
+    dateRangePicker: DateRangePicker<D>;
+    dateTimePicker: DateTimePicker<D>;
+    dialPad: DialPad<D>;
+    dialog: Dialog<D>;
+    divider: Divider<D>;
+    emptyState: EmptyState<D>;
+    fab: Fab<D>;
+    filePicker: FilePicker<D>;
+    header: Header<D>;
+    icon: Icon<D>;
+    layout: Layout<D>;
+    menu: Menu<D>;
+    menuItem: MenuItem<D>;
+    nav: Nav<D>;
+    navDisclosure: NavDisclosure<D>;
+    navItem: NavItem<D>;
+    note: Note<D>;
+    numberField: NumberField<D>;
+    option: Option<D>;
+    pagination: Pagination<D>;
+    progress: Progress<D>;
+    progressRing: ProgressRing<D>;
+    radio: Radio<D>;
+    radioGroup: RadioGroup<D>;
+    rangeSlider: RangeSlider<D>;
+    richTextEditor: RichTextEditor<D>;
+    searchableSelect: SearchableSelect<D>;
+    select: Select<D>;
+    selectableBox: SelectableBox<D>;
+    sideDrawer: SideDrawer<D>;
+    simpleColorPicker: SimpleColorPicker<D>;
+    slider: Slider<D>;
+    splitButton: SplitButton<D>;
+    switch: Switch<D>;
+    tab: Tab<D>;
+    tabPanel: TabPanel<D>;
+    tabs: Tabs<D>;
+    tag: Tag<D>;
+    tagGroup: TagGroup<D>;
+    textArea: TextArea<D>;
+    textField: TextField<D>;
+    timePicker: TimePicker<D>;
+    toggletip: Toggletip<D>;
+    tooltip: Tooltip<D>;
+    treeItem: TreeItem<D>;
+    treeView: TreeView<D>;
+    videoPlayer: VideoPlayer<D>;
+}
+export {};