@vonage/vivid-test-utils 5.2.0

package/dist/components.generated-DY7hz_DE.js

@@ -0,0 +1,3311 @@
+class n {
+  constructor(r, s) {
+    this.ctx = r, this.locator = s;
+  }
+  unwrap() {
+    return this.locator;
+  }
+  assert(r, s, e, i) {
+    return this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.locator,
+        fn: s,
+        arg: i
+      },
+      e,
+      `Failed to assert condition: "${r}"`
+    );
+  }
+}
+class a {
+  constructor(r) {
+    this.ctx = r, this.all = this.ctx.driver.wrapSelector(
+      () => new le(
+        this.ctx,
+        this,
+        this.ctx.driver.querySelectorAll(
+          this.ctx.rootLocator,
+          `[data-vvd-component="${this.componentInfo.name}"]`
+        )
+      )
+    );
+  }
+}
+class le {
+  constructor(r, s, e) {
+    this.ctx = r, this.component = s, this.locator = e, this.type = "collection", this.nth = this.ctx.driver.wrapSelector(
+      (i) => this.component.wrap(this.ctx.driver.nth(this.locator, i))
+    );
+  }
+}
+class xe {
+  constructor(r, s) {
+    this.ctx = r, this.locator = s, this.toHaveCount = this.ctx.driver.wrapExpect(
+      (e) => this.ctx.driver.expectEq(
+        {
+          el: this.locator.locator,
+          // FIXME: retrieve the locator correctly
+          type: "count"
+        },
+        e,
+        `toHaveCount(${e})`
+      )
+    );
+  }
+}
+const ve = (t) => t.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "\\'"), A = (t, r) => r.map(
+  ([s, e]) => `[data-vvd-component="${t}"][${s}="${ve(
+    e
+  )}"]`
+).join(",");
+function h(t) {
+  return this.wrap(
+    this.ctx.driver.querySelector(
+      this.ctx.rootLocator,
+      A(this.componentInfo.name, [
+        ["data-testid", t],
+        ["data-test-id", t],
+        ["data-cy", t]
+      ])
+    )
+  );
+}
+function v(t) {
+  return this.wrap(
+    this.ctx.driver.querySelector(
+      this.ctx.rootLocator,
+      A(this.componentInfo.name, [
+        ["label", t],
+        ["aria-label", t],
+        ["data-vvd-aria-label", t]
+      ])
+    )
+  );
+}
+function ue(t) {
+  return this.wrap(
+    this.ctx.driver.querySelector(
+      this.ctx.rootLocator,
+      A(this.componentInfo.name, [["heading", t]])
+    )
+  );
+}
+function B(t) {
+  return this.wrap(
+    this.ctx.driver.querySelector(
+      this.ctx.rootLocator,
+      A(this.componentInfo.name, [["headline", t]])
+    )
+  );
+}
+function k(t) {
+  return this.wrap(
+    this.ctx.driver.querySelector(
+      this.ctx.rootLocator,
+      A(this.componentInfo.name, [["text", t]])
+    )
+  );
+}
+const m = (t) => {
+  if (!t.length)
+    return;
+  const r = t[0], s = t.slice(1), e = r();
+  return e instanceof Promise ? e.then(() => m(s)) : m(s);
+};
+function I(t) {
+  return t.checked;
+}
+function g(t) {
+  return t.indeterminate ? "indeterminate" : t.checked ? "checked" : "unchecked";
+}
+function f(t) {
+  return t.errorValidationMessage;
+}
+function _(t) {
+  return t.headline;
+}
+function E(t) {
+  return t.open;
+}
+function w(t) {
+  return t.value;
+}
+function z(t) {
+  return t.valueAsNumber;
+}
+function we(t) {
+  return t.values;
+}
+function be(t) {
+  return t.selectedOptions.map((r) => r.label);
+}
+function R(t) {
+  return t.expanded;
+}
+function L(t) {
+  return t.active;
+}
+function H(t) {
+  return t.current;
+}
+function O(t) {
+  return t.selected;
+}
+function q(t) {
+  return t.disabled;
+}
+function me(t) {
+  return [t.start, t.end];
+}
+function fe(t) {
+  return [t.startAsNumber, t.endAsNumber];
+}
+function Ee(t) {
+  return t.name;
+}
+function ye(t) {
+  return t.total;
+}
+function Ie(t) {
+  return t.selectedIndex + 1 || null;
+}
+function u(t) {
+  const r = t.shadowRoot.querySelector("slot[name=icon]");
+  if (r) {
+    const e = r.assignedElements()[0];
+    if ((e == null ? void 0 : e.dataset.vvdComponent) === "icon")
+      return e.name;
+  }
+  const s = t.shadowRoot.querySelector(
+    'slot[name="icon"] [data-vvd-component="icon"], span.icon [data-vvd-component="icon"]'
+  );
+  return s ? s.name : null;
+}
+function b(t) {
+  return this.ctx.driver.userClick(t());
+}
+function V(t, r) {
+  return this.ctx.driver.userFill(t(), r);
+}
+function ge(t) {
+  return m([
+    () => this.ctx.driver.userFill(this.control(), t),
+    () => this.ctx.driver.userBlur(this.control())
+    // Combobox only updates value on blur
+  ]);
+}
+function W(t) {
+  return this.ctx.driver.userClear(t());
+}
+function Ae() {
+  return m([
+    () => this.ctx.driver.userClear(this.control()),
+    () => this.ctx.driver.userBlur(this.control())
+    // Combobox only updates value on blur
+  ]);
+}
+function J(t) {
+  return m([
+    () => this.assert(
+      "Component is unchecked before it can be checked",
+      g,
+      "unchecked"
+    ),
+    () => this.ctx.driver.userClick(t()),
+    () => this.assert(
+      "Component is checked after checking it",
+      g,
+      "checked"
+    )
+  ]);
+}
+function K(t) {
+  return m([
+    () => this.assert(
+      "Component is checked before it can be unchecked",
+      g,
+      "checked"
+    ),
+    () => this.ctx.driver.userClick(t()),
+    () => this.assert(
+      "Component is unchecked after unchecking it",
+      g,
+      "unchecked"
+    )
+  ]);
+}
+function p(t) {
+  return this.ctx.driver.userFocus(t());
+}
+function d(t) {
+  return this.ctx.driver.userBlur(t());
+}
+function l(t) {
+  return this.ctx.driver.userHover(t());
+}
+function D(t) {
+  return Q.call(this, A("option", [["value", t]]));
+}
+function G(t) {
+  return Q.call(this, A("option", [["text", t]]));
+}
+function Q(t) {
+  return this.ctx.driver.eval(
+    this.locator,
+    (r) => r.open,
+    void 0,
+    (r) => m([
+      // Open the component if needed
+      () => {
+        if (!r)
+          return this.ctx.driver.userClick(this.locator);
+      },
+      () => this.ctx.driver.expectEq(
+        {
+          type: "eval",
+          el: this.ctx.driver.querySelector(this.locator, t),
+          fn: (s) => !!s.selected
+        },
+        !1,
+        "Option is unselected before it can be selected"
+      ),
+      () => this.ctx.driver.expectEq(
+        {
+          type: "eval",
+          el: this.ctx.driver.querySelector(this.locator, t),
+          fn: (s) => !!s.disabled
+        },
+        !1,
+        "Option is not disabled before it can be selected"
+      ),
+      // Click the option to select it
+      // Note: simulate click instead of using userClick to work around Cypress bug
+      // When clicking on an option, Cypress incorrectly blurs the host, which in case of combobox closes it
+      () => this.ctx.driver.eval(
+        this.ctx.driver.querySelector(this.locator, t),
+        (s) => s.click()
+      ),
+      () => this.ctx.driver.expectEq(
+        {
+          type: "eval",
+          el: this.ctx.driver.querySelector(this.locator, t),
+          fn: (s) => !!s.selected
+        },
+        !0,
+        "Option is selected after selecting it"
+      )
+    ])
+  );
+}
+function C(t) {
+  return t().click();
+}
+const $ = (t) => {
+  const [r, s, e] = t.split("-");
+  return `${s}/${e}/${r}`;
+};
+function He(t) {
+  return m([
+    () => this.control().fill($(t)),
+    () => this.control().blur()
+  ]);
+}
+function P() {
+  return m([
+    () => this.pickerButton().click(),
+    () => this.clearButton().click()
+  ]);
+}
+const X = (t) => {
+  const [r, s, e] = t.split(":"), i = +r % 12 || 12, c = +r < 12 ? "AM" : "PM";
+  return `${i}:${s}:${e} ${c}`;
+};
+function $e(t) {
+  return m([
+    () => this.control().fill(X(t)),
+    () => this.control().blur()
+  ]);
+}
+const Pe = ([t, r]) => `${$(t)} – ${$(r)}`;
+function Se(t) {
+  return m([
+    () => this.control().fill(Pe(t)),
+    () => this.control().blur()
+  ]);
+}
+const qe = (t) => {
+  const [r, s] = t.split("T");
+  return `${$(r)} ${X(s)}`;
+};
+function Ce(t) {
+  return m([
+    () => this.control().fill(qe(t)),
+    () => this.control().blur()
+  ]);
+}
+function T(t, r, s) {
+  return this.ctx.driver.userDragSlider(this.locator, t(), r(), s);
+}
+function Te(t) {
+  return this.ctx.driver.userClick(
+    this.ctx.driver.querySelector(
+      this.ctx.driver.enterShadow(this.locator),
+      `.vwc-pagination-button[label="${t + 1}"]`
+    )
+  );
+}
+function F(t) {
+  return m([
+    () => this.assert(
+      `Component is ${t ? "collapsed" : "expanded"} before it can be ${t ? "expanded" : "collapsed"}`,
+      (r) => !!r.expanded,
+      !t
+    ),
+    () => this.ctx.driver.userClick(this.button()),
+    () => this.assert(
+      `Component is ${t ? "expanded" : "collapsed"} after ${t ? "expanding" : "collapsing"} it`,
+      (r) => !!r.expanded,
+      t
+    )
+  ]);
+}
+function U(t) {
+  return m([
+    () => this.assert(
+      `Component is ${t ? "closed" : "open"} before it can be ${t ? "expanded" : "collapsed"}`,
+      (r) => !!r.open,
+      !t
+    ),
+    () => this.ctx.driver.userClick(this.summary()),
+    () => this.assert(
+      `Component is ${t ? "open" : "closed"} after ${t ? "expanding" : "collapsing"} it`,
+      (r) => !!r.open,
+      t
+    )
+  ]);
+}
+function M(t) {
+  return m([
+    () => this.ctx.driver.userClick(this.base()),
+    () => this.assert(
+      `Component is ${t ? "selected" : "unselected"} after ${t ? "selecting" : "unselecting"} it`,
+      (r) => !!r.selected,
+      t
+    )
+  ]);
+}
+function Be(t) {
+  return this.ctx.driver.querySelector(this.unwrap(), t);
+}
+function x(t) {
+  return this.ctx.driver.querySelector(
+    this.ctx.driver.enterShadow(this.unwrap()),
+    t
+  );
+}
+function ke(t, r) {
+  return this.ctx.driver.querySelector(
+    this.ctx.driver.enterShadow(
+      this.ctx.driver.querySelector(
+        this.ctx.driver.enterShadow(this.unwrap()),
+        t
+      )
+    ),
+    r
+  );
+}
+function y(t) {
+  return new at(
+    this.ctx,
+    this.ctx.driver.querySelector(
+      this.ctx.driver.enterShadow(this.unwrap()),
+      t
+    )
+  );
+}
+function S(t) {
+  return new ce(
+    this.ctx,
+    this.ctx.driver.querySelector(
+      this.ctx.driver.enterShadow(this.unwrap()),
+      t
+    )
+  );
+}
+const Y = {
+  name: "accordion"
+};
+class Ve extends n {
+  constructor() {
+    super(...arguments), this.type = "accordion", this.componentInfo = Y, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class We extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Y, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Ve(this.ctx, r);
+  }
+}
+class De {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const Z = {
+  name: "accordion-item"
+};
+class Ge extends n {
+  constructor() {
+    super(...arguments), this.type = "accordionItem", this.componentInfo = Z, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.expand = this.ctx.driver.wrapAction(F.bind(this, !0)), this.collapse = this.ctx.driver.wrapAction(F.bind(this, !1)), this.button = x.bind(this, ".heading-button");
+  }
+}
+class Re extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Z, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byHeading = this.ctx.driver.wrapSelector(ue.bind(this));
+  }
+  wrap(r) {
+    return new Ge(this.ctx, r);
+  }
+}
+class Le {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toBeExpanded = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: R
+      },
+      !0,
+      "toBeExpanded()"
+    )), this.toBeCollapsed = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: R
+      },
+      !1,
+      "toBeCollapsed()"
+    ));
+  }
+}
+const N = {
+  name: "action-group"
+};
+class Oe extends n {
+  constructor() {
+    super(...arguments), this.type = "actionGroup", this.componentInfo = N, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Fe extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = N, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Oe(this.ctx, r);
+  }
+}
+class Ue {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const tt = {
+  name: "alert"
+};
+class Me extends n {
+  constructor() {
+    super(...arguments), this.type = "alert", this.componentInfo = tt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class je extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = tt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byHeadline = this.ctx.driver.wrapSelector(B.bind(this));
+  }
+  wrap(r) {
+    return new Me(this.ctx, r);
+  }
+}
+class _e {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toBeOpen = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !0,
+      "toBeOpen()"
+    )), this.toBeClosed = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !1,
+      "toBeClosed()"
+    ));
+  }
+}
+const et = {
+  name: "audio-player"
+};
+class ze extends n {
+  constructor() {
+    super(...arguments), this.type = "audioPlayer", this.componentInfo = et, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Je extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = et, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new ze(this.ctx, r);
+  }
+}
+class Ke {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const rt = {
+  name: "avatar"
+};
+class Qe extends n {
+  constructor() {
+    super(...arguments), this.type = "avatar", this.componentInfo = rt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Xe extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = rt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Qe(this.ctx, r);
+  }
+}
+class Ye {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const it = {
+  name: "badge"
+};
+class Ze extends n {
+  constructor() {
+    super(...arguments), this.type = "badge", this.componentInfo = it, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Ne extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = it, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Ze(this.ctx, r);
+  }
+}
+class tr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    ));
+  }
+}
+const st = {
+  name: "banner"
+};
+class er extends n {
+  constructor() {
+    super(...arguments), this.type = "banner", this.componentInfo = st, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.dismiss = this.ctx.driver.wrapAction(C.bind(this, () => this.dismissButton())), this.dismissButton = y.bind(this, ".dismiss-button");
+  }
+}
+class rr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = st, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byText = this.ctx.driver.wrapSelector(k.bind(this));
+  }
+  wrap(r) {
+    return new er(this.ctx, r);
+  }
+}
+class ir {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    ));
+  }
+}
+const ct = {
+  name: "breadcrumb"
+};
+class sr extends n {
+  constructor() {
+    super(...arguments), this.type = "breadcrumb", this.componentInfo = ct, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class cr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = ct, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new sr(this.ctx, r);
+  }
+}
+class or {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = (e, i) => {
+      throw new Error("Component does not have props.");
+    };
+  }
+}
+const ot = {
+  name: "breadcrumb-item"
+};
+class nr extends n {
+  constructor() {
+    super(...arguments), this.type = "breadcrumbItem", this.componentInfo = ot, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class ar extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = ot, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new nr(this.ctx, r);
+  }
+}
+class hr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const nt = {
+  name: "button"
+};
+class at extends n {
+  constructor() {
+    super(...arguments), this.type = "button", this.componentInfo = nt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.click = this.ctx.driver.wrapAction(b.bind(this, () => this.control())), this.control = x.bind(this, "button.control");
+  }
+}
+class pr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = nt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new at(this.ctx, r);
+  }
+}
+class dr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    ));
+  }
+}
+const ht = {
+  name: "calendar"
+};
+class lr extends n {
+  constructor() {
+    super(...arguments), this.type = "calendar", this.componentInfo = ht, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class xr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = ht, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new lr(this.ctx, r);
+  }
+}
+class vr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const pt = {
+  name: "calendar-event"
+};
+class ur extends n {
+  constructor() {
+    super(...arguments), this.type = "calendarEvent", this.componentInfo = pt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class wr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = pt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new ur(this.ctx, r);
+  }
+}
+class br {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const dt = {
+  name: "card"
+};
+class mr extends n {
+  constructor() {
+    super(...arguments), this.type = "card", this.componentInfo = dt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class fr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = dt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new mr(this.ctx, r);
+  }
+}
+class Er {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveHeadline = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: _
+      },
+      e,
+      "toHaveHeadline(${value})"
+    ));
+  }
+}
+const lt = {
+  name: "checkbox"
+};
+class yr extends n {
+  constructor() {
+    super(...arguments), this.type = "checkbox", this.componentInfo = lt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.check = this.ctx.driver.wrapAction(J.bind(this, () => this.control())), this.uncheck = this.ctx.driver.wrapAction(K.bind(this, () => this.control())), this.control = x.bind(this, "div.control");
+  }
+}
+class Ir extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = lt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new yr(this.ctx, r);
+  }
+}
+class gr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    )), this.toBeChecked = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: g
+      },
+      "checked",
+      "toBeChecked()"
+    )), this.toBeUnchecked = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: g
+      },
+      "unchecked",
+      "toBeUnchecked()"
+    )), this.toBeIndeterminate = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: g
+      },
+      "indeterminate",
+      "toBeIndeterminate()"
+    ));
+  }
+}
+const xt = {
+  name: "combobox"
+};
+class Ar extends n {
+  constructor() {
+    super(...arguments), this.type = "combobox", this.componentInfo = xt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.fill = this.ctx.driver.wrapAction(ge.bind(this)), this.clear = this.ctx.driver.wrapAction(Ae.bind(this)), this.selectOptionByText = this.ctx.driver.wrapAction(G.bind(this)), this.selectOptionByValue = this.ctx.driver.wrapAction(D.bind(this)), this.control = x.bind(this, "input.control");
+  }
+}
+class Hr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = xt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Ar(this.ctx, r);
+  }
+}
+class $r {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    ));
+  }
+}
+const vt = {
+  name: "data-grid"
+};
+class Pr extends n {
+  constructor() {
+    super(...arguments), this.type = "dataGrid", this.componentInfo = vt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Sr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = vt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Pr(this.ctx, r);
+  }
+}
+class qr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const ut = {
+  name: "data-grid-cell"
+};
+class Cr extends n {
+  constructor() {
+    super(...arguments), this.type = "dataGridCell", this.componentInfo = ut, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Tr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = ut, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Cr(this.ctx, r);
+  }
+}
+class Br {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const wt = {
+  name: "data-grid-row"
+};
+class kr extends n {
+  constructor() {
+    super(...arguments), this.type = "dataGridRow", this.componentInfo = wt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Vr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = wt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new kr(this.ctx, r);
+  }
+}
+class Wr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const bt = {
+  name: "date-picker"
+};
+class Dr extends n {
+  constructor() {
+    super(...arguments), this.type = "datePicker", this.componentInfo = bt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.clear = this.ctx.driver.wrapAction(P.bind(this)), this.selectDate = this.ctx.driver.wrapAction(He.bind(this)), this.control = S.bind(this, "[data-vvd-component=text-field].control"), this.pickerButton = y.bind(this, "#picker-button"), this.clearButton = y.bind(this, "#clear-button");
+  }
+}
+class Gr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = bt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Dr(this.ctx, r);
+  }
+}
+class Rr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    ));
+  }
+}
+const mt = {
+  name: "date-range-picker"
+};
+class Lr extends n {
+  constructor() {
+    super(...arguments), this.type = "dateRangePicker", this.componentInfo = mt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.clear = this.ctx.driver.wrapAction(P.bind(this)), this.selectDateRange = this.ctx.driver.wrapAction(Se.bind(this)), this.control = S.bind(this, "[data-vvd-component=text-field].control"), this.pickerButton = y.bind(this, "#picker-button"), this.clearButton = y.bind(this, "#clear-button");
+  }
+}
+class Or extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = mt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Lr(this.ctx, r);
+  }
+}
+class Fr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    )), this.toHaveRange = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: me
+      },
+      e,
+      "toHaveRange(${value})"
+    ));
+  }
+}
+const ft = {
+  name: "date-time-picker"
+};
+class Ur extends n {
+  constructor() {
+    super(...arguments), this.type = "dateTimePicker", this.componentInfo = ft, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.clear = this.ctx.driver.wrapAction(P.bind(this)), this.selectDateTime = this.ctx.driver.wrapAction(Ce.bind(this)), this.control = S.bind(this, "[data-vvd-component=text-field].control"), this.pickerButton = y.bind(this, "#picker-button"), this.clearButton = y.bind(this, "#clear-button");
+  }
+}
+class Mr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = ft, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Ur(this.ctx, r);
+  }
+}
+class jr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    ));
+  }
+}
+const Et = {
+  name: "dial-pad"
+};
+class _r extends n {
+  constructor() {
+    super(...arguments), this.type = "dialPad", this.componentInfo = Et, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class zr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Et, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new _r(this.ctx, r);
+  }
+}
+class Jr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const yt = {
+  name: "dialog"
+};
+class Kr extends n {
+  constructor() {
+    super(...arguments), this.type = "dialog", this.componentInfo = yt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.dismiss = this.ctx.driver.wrapAction(b.bind(this, () => this.dismissButton())), this.dismissButton = x.bind(this, ".dismiss-button");
+  }
+}
+class Qr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = yt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byHeadline = this.ctx.driver.wrapSelector(B.bind(this));
+  }
+  wrap(r) {
+    return new Kr(this.ctx, r);
+  }
+}
+class Xr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toBeOpen = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !0,
+      "toBeOpen()"
+    )), this.toBeClosed = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !1,
+      "toBeClosed()"
+    )), this.toHaveHeadline = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: _
+      },
+      e,
+      "toHaveHeadline(${value})"
+    ));
+  }
+}
+const It = {
+  name: "divider"
+};
+class Yr extends n {
+  constructor() {
+    super(...arguments), this.type = "divider", this.componentInfo = It, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Zr extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = It, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Yr(this.ctx, r);
+  }
+}
+class Nr {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const gt = {
+  name: "empty-state"
+};
+class ti extends n {
+  constructor() {
+    super(...arguments), this.type = "emptyState", this.componentInfo = gt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class ei extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = gt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new ti(this.ctx, r);
+  }
+}
+class ri {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const At = {
+  name: "fab"
+};
+class ii extends n {
+  constructor() {
+    super(...arguments), this.type = "fab", this.componentInfo = At, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.click = this.ctx.driver.wrapAction(b.bind(this, () => this.control())), this.control = x.bind(this, "button.control");
+  }
+}
+class si extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = At, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new ii(this.ctx, r);
+  }
+}
+class ci {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    ));
+  }
+}
+const Ht = {
+  name: "file-picker"
+};
+class oi extends n {
+  constructor() {
+    super(...arguments), this.type = "filePicker", this.componentInfo = Ht, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class ni extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Ht, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new oi(this.ctx, r);
+  }
+}
+class ai {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    ));
+  }
+}
+const $t = {
+  name: "header"
+};
+class hi extends n {
+  constructor() {
+    super(...arguments), this.type = "header", this.componentInfo = $t, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class pi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = $t, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new hi(this.ctx, r);
+  }
+}
+class di {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const Pt = {
+  name: "icon"
+};
+class li extends n {
+  constructor() {
+    super(...arguments), this.type = "icon", this.componentInfo = Pt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class xi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Pt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new li(this.ctx, r);
+  }
+}
+class vi {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveName = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: Ee
+      },
+      e,
+      "toHaveName(${value})"
+    ));
+  }
+}
+const St = {
+  name: "layout"
+};
+class ui extends n {
+  constructor() {
+    super(...arguments), this.type = "layout", this.componentInfo = St, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class wi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = St, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new ui(this.ctx, r);
+  }
+}
+class bi {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const qt = {
+  name: "menu"
+};
+class mi extends n {
+  constructor() {
+    super(...arguments), this.type = "menu", this.componentInfo = qt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class fi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = qt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new mi(this.ctx, r);
+  }
+}
+class Ei {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toBeOpen = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !0,
+      "toBeOpen()"
+    )), this.toBeClosed = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !1,
+      "toBeClosed()"
+    ));
+  }
+}
+const Ct = {
+  name: "menu-item"
+};
+class yi extends n {
+  constructor() {
+    super(...arguments), this.type = "menuItem", this.componentInfo = Ct, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.click = this.ctx.driver.wrapAction(b.bind(this, () => this.base())), this.base = x.bind(this, ".base");
+  }
+}
+class Ii extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Ct, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byText = this.ctx.driver.wrapSelector(k.bind(this));
+  }
+  wrap(r) {
+    return new yi(this.ctx, r);
+  }
+}
+class gi {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toBeChecked = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: I
+      },
+      !0,
+      "toBeChecked()"
+    )), this.toBeUnchecked = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: I
+      },
+      !1,
+      "toBeUnchecked()"
+    )), this.toHaveDisabled = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: q
+      },
+      e,
+      "toHaveDisabled(${value})"
+    ));
+  }
+}
+const Tt = {
+  name: "nav"
+};
+class Ai extends n {
+  constructor() {
+    super(...arguments), this.type = "nav", this.componentInfo = Tt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Hi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Tt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Ai(this.ctx, r);
+  }
+}
+class $i {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = (e, i) => {
+      throw new Error("Component does not have props.");
+    };
+  }
+}
+const Bt = {
+  name: "nav-disclosure"
+};
+class Pi extends n {
+  constructor() {
+    super(...arguments), this.type = "navDisclosure", this.componentInfo = Bt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.expand = this.ctx.driver.wrapAction(U.bind(this, !0)), this.collapse = this.ctx.driver.wrapAction(U.bind(this, !1)), this.summary = x.bind(this, "summary");
+  }
+}
+class Si extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Bt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Pi(this.ctx, r);
+  }
+}
+class qi {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toBeCurrent = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: H
+      },
+      !0,
+      "toBeCurrent()"
+    )), this.notToBeCurrent = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: H
+      },
+      !1,
+      "notToBeCurrent()"
+    )), this.toBeOpen = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !0,
+      "toBeOpen()"
+    )), this.toBeClosed = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !1,
+      "toBeClosed()"
+    ));
+  }
+}
+const kt = {
+  name: "nav-item"
+};
+class Ci extends n {
+  constructor() {
+    super(...arguments), this.type = "navItem", this.componentInfo = kt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.click = this.ctx.driver.wrapAction(b.bind(this, () => this.control())), this.control = x.bind(this, ".control");
+  }
+}
+class Ti extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = kt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Ci(this.ctx, r);
+  }
+}
+class Bi {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toBeCurrent = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: H
+      },
+      !0,
+      "toBeCurrent()"
+    )), this.notToBeCurrent = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: H
+      },
+      !1,
+      "notToBeCurrent()"
+    ));
+  }
+}
+const Vt = {
+  name: "note"
+};
+class ki extends n {
+  constructor() {
+    super(...arguments), this.type = "note", this.componentInfo = Vt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Vi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Vt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new ki(this.ctx, r);
+  }
+}
+class Wi {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    ));
+  }
+}
+const Wt = {
+  name: "number-field"
+};
+class Di extends n {
+  constructor() {
+    super(...arguments), this.type = "numberField", this.componentInfo = Wt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.fill = this.ctx.driver.wrapAction(V.bind(this, () => this.control())), this.clear = this.ctx.driver.wrapAction(W.bind(this, () => this.control())), this.clickIncrement = this.ctx.driver.wrapAction(C.bind(this, () => this.incrementButton())), this.clickDecrement = this.ctx.driver.wrapAction(C.bind(this, () => this.decrementButton())), this.control = x.bind(this, "input.control"), this.incrementButton = y.bind(this, "#add"), this.decrementButton = y.bind(this, "#subtract");
+  }
+}
+class Gi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Wt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Di(this.ctx, r);
+  }
+}
+class Ri {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    )), this.toHaveValueAsNumber = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: z
+      },
+      e,
+      "toHaveValueAsNumber(${value})"
+    ));
+  }
+}
+const Dt = {
+  name: "option"
+};
+class Li extends n {
+  constructor() {
+    super(...arguments), this.type = "option", this.componentInfo = Dt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.click = this.ctx.driver.wrapAction(b.bind(this, () => this.locator));
+  }
+}
+class Oi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Dt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Li(this.ctx, r);
+  }
+}
+class Fi {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    ));
+  }
+}
+const Gt = {
+  name: "pagination"
+};
+class Ui extends n {
+  constructor() {
+    super(...arguments), this.type = "pagination", this.componentInfo = Gt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.clickNext = this.ctx.driver.wrapAction(b.bind(this, () => this.nextButton())), this.clickPrev = this.ctx.driver.wrapAction(b.bind(this, () => this.prevButton())), this.clickPageIndex = this.ctx.driver.wrapAction(Te.bind(this)), this.nextButton = x.bind(this, ".next-button"), this.prevButton = x.bind(this, ".prev-button");
+  }
+}
+class Mi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Gt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Ui(this.ctx, r);
+  }
+}
+class ji {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveTotal = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: ye
+      },
+      e,
+      "toHaveTotal(${value})"
+    )), this.toHaveSelectedPage = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: Ie
+      },
+      e,
+      "toHaveSelectedPage(${value})"
+    ));
+  }
+}
+const Rt = {
+  name: "progress"
+};
+class _i extends n {
+  constructor() {
+    super(...arguments), this.type = "progress", this.componentInfo = Rt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class zi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Rt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new _i(this.ctx, r);
+  }
+}
+class Ji {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const Lt = {
+  name: "progress-ring"
+};
+class Ki extends n {
+  constructor() {
+    super(...arguments), this.type = "progressRing", this.componentInfo = Lt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Qi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Lt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Ki(this.ctx, r);
+  }
+}
+class Xi {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const Ot = {
+  name: "radio"
+};
+class Yi extends n {
+  constructor() {
+    super(...arguments), this.type = "radio", this.componentInfo = Ot, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.check = this.ctx.driver.wrapAction(b.bind(this, () => this.control())), this.control = x.bind(this, ".control");
+  }
+}
+class Zi extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Ot, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Yi(this.ctx, r);
+  }
+}
+class Ni {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    )), this.toBeChecked = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: I
+      },
+      !0,
+      "toBeChecked()"
+    )), this.toBeUnchecked = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: I
+      },
+      !1,
+      "toBeUnchecked()"
+    ));
+  }
+}
+const Ft = {
+  name: "radio-group"
+};
+class ts extends n {
+  constructor() {
+    super(...arguments), this.type = "radioGroup", this.componentInfo = Ft, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class es extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Ft, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new ts(this.ctx, r);
+  }
+}
+class rs {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const Ut = {
+  name: "range-slider"
+};
+class is extends n {
+  constructor() {
+    super(...arguments), this.type = "rangeSlider", this.componentInfo = Ut, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.slideStartTo = this.ctx.driver.wrapAction(T.bind(this, () => this.track(), () => this.startThumb())), this.slideEndTo = this.ctx.driver.wrapAction(T.bind(this, () => this.track(), () => this.endThumb())), this.track = x.bind(this, ".control"), this.startThumb = x.bind(this, "#start-thumb"), this.endThumb = x.bind(this, "#end-thumb");
+  }
+}
+class ss extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Ut, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new is(this.ctx, r);
+  }
+}
+class cs {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    )), this.toHaveRange = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: fe
+      },
+      e,
+      "toHaveRange(${value})"
+    ));
+  }
+}
+const Mt = {
+  name: "rich-text-editor"
+};
+class os extends n {
+  constructor() {
+    super(...arguments), this.type = "richTextEditor", this.componentInfo = Mt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class ns extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Mt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new os(this.ctx, r);
+  }
+}
+class as {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const jt = {
+  name: "searchable-select"
+};
+class hs extends n {
+  constructor() {
+    super(...arguments), this.type = "searchableSelect", this.componentInfo = jt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.selectOptionByValue = this.ctx.driver.wrapAction(D.bind(this)), this.selectOptionByText = this.ctx.driver.wrapAction(G.bind(this));
+  }
+}
+class ps extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = jt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new hs(this.ctx, r);
+  }
+}
+class ds {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    )), this.toHaveValues = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: we
+      },
+      e,
+      "toHaveValues(${value})"
+    )), this.toHaveSelectedOptions = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: be
+      },
+      e,
+      "toHaveSelectedOptions(${value})"
+    ));
+  }
+}
+const _t = {
+  name: "select"
+};
+class ls extends n {
+  constructor() {
+    super(...arguments), this.type = "select", this.componentInfo = _t, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.selectOptionByValue = this.ctx.driver.wrapAction(D.bind(this)), this.selectOptionByText = this.ctx.driver.wrapAction(G.bind(this));
+  }
+}
+class xs extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = _t, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new ls(this.ctx, r);
+  }
+}
+class vs {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    ));
+  }
+}
+const zt = {
+  name: "selectable-box"
+};
+class us extends n {
+  constructor() {
+    super(...arguments), this.type = "selectableBox", this.componentInfo = zt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.check = this.ctx.driver.wrapAction(J.bind(this, () => this.control())), this.uncheck = this.ctx.driver.wrapAction(K.bind(this, () => this.control())), this.control = ke.bind(this, "[data-vvd-component].control", "div.control");
+  }
+}
+class ws extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = zt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new us(this.ctx, r);
+  }
+}
+class bs {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toBeChecked = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: I
+      },
+      !0,
+      "toBeChecked()"
+    )), this.toBeUnchecked = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: I
+      },
+      !1,
+      "toBeUnchecked()"
+    ));
+  }
+}
+const Jt = {
+  name: "side-drawer"
+};
+class ms extends n {
+  constructor() {
+    super(...arguments), this.type = "sideDrawer", this.componentInfo = Jt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class fs extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Jt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new ms(this.ctx, r);
+  }
+}
+class Es {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const Kt = {
+  name: "simple-color-picker"
+};
+class ys extends n {
+  constructor() {
+    super(...arguments), this.type = "simpleColorPicker", this.componentInfo = Kt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Is extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Kt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new ys(this.ctx, r);
+  }
+}
+class gs {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    ));
+  }
+}
+const Qt = {
+  name: "slider"
+};
+class As extends n {
+  constructor() {
+    super(...arguments), this.type = "slider", this.componentInfo = Qt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.slideTo = this.ctx.driver.wrapAction(T.bind(this, () => this.track(), () => this.thumb())), this.track = x.bind(this, ".control"), this.thumb = x.bind(this, ".thumb-container");
+  }
+}
+class Hs extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Qt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new As(this.ctx, r);
+  }
+}
+class $s {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    )), this.toHaveValueAsNumber = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: z
+      },
+      e,
+      "toHaveValueAsNumber(${value})"
+    ));
+  }
+}
+const Xt = {
+  name: "split-button"
+};
+class Ps extends n {
+  constructor() {
+    super(...arguments), this.type = "splitButton", this.componentInfo = Xt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.clickAction = this.ctx.driver.wrapAction(b.bind(this, () => this.actionButton())), this.clickIndicator = this.ctx.driver.wrapAction(b.bind(this, () => this.indicatorButton())), this.actionButton = x.bind(this, "button.control"), this.indicatorButton = x.bind(this, "button.indicator");
+  }
+}
+class Ss extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Xt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Ps(this.ctx, r);
+  }
+}
+class qs {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    ));
+  }
+}
+const Yt = {
+  name: "switch"
+};
+class Cs extends n {
+  constructor() {
+    super(...arguments), this.type = "switch", this.componentInfo = Yt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.check = this.ctx.driver.wrapAction(b.bind(this, () => this.switch())), this.uncheck = this.ctx.driver.wrapAction(b.bind(this, () => this.switch())), this.switch = x.bind(this, ".switch");
+  }
+}
+class Ts extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Yt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Cs(this.ctx, r);
+  }
+}
+class Bs {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    )), this.toBeChecked = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: I
+      },
+      !0,
+      "toBeChecked()"
+    )), this.toBeUnchecked = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: I
+      },
+      !1,
+      "toBeUnchecked()"
+    ));
+  }
+}
+const Zt = {
+  name: "tab"
+};
+class ks extends n {
+  constructor() {
+    super(...arguments), this.type = "tab", this.componentInfo = Zt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.select = this.ctx.driver.wrapAction(b.bind(this, () => this.base())), this.base = x.bind(this, ".base");
+  }
+}
+class Vs extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Zt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new ks(this.ctx, r);
+  }
+}
+class Ws {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toBeActive = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: L
+      },
+      !0,
+      "toBeActive()"
+    )), this.toBeInactive = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: L
+      },
+      !1,
+      "toBeInactive()"
+    ));
+  }
+}
+const Nt = {
+  name: "tab-panel"
+};
+class Ds extends n {
+  constructor() {
+    super(...arguments), this.type = "tabPanel", this.componentInfo = Nt, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Gs extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = Nt, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Ds(this.ctx, r);
+  }
+}
+class Rs {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = (e, i) => {
+      throw new Error("Component does not have props.");
+    };
+  }
+}
+const te = {
+  name: "tabs"
+};
+class Ls extends n {
+  constructor() {
+    super(...arguments), this.type = "tabs", this.componentInfo = te, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class Os extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = te, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new Ls(this.ctx, r);
+  }
+}
+class Fs {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const ee = {
+  name: "tag"
+};
+class Us extends n {
+  constructor() {
+    super(...arguments), this.type = "tag", this.componentInfo = ee, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.click = this.ctx.driver.wrapAction(b.bind(this, () => this.base())), this.remove = this.ctx.driver.wrapAction(b.bind(this, () => this.dismissButton())), this.select = this.ctx.driver.wrapAction(M.bind(this, !0)), this.unselect = this.ctx.driver.wrapAction(M.bind(this, !1)), this.base = x.bind(this, ".base"), this.dismissButton = x.bind(this, ".dismiss-button");
+  }
+}
+class Ms extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = ee, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Us(this.ctx, r);
+  }
+}
+class js {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toBeSelected = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: O
+      },
+      !0,
+      "toBeSelected()"
+    )), this.toBeUnselected = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: O
+      },
+      !1,
+      "toBeUnselected()"
+    )), this.toBeDisabled = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: q
+      },
+      !0,
+      "toBeDisabled()"
+    )), this.notToBeDisabled = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: q
+      },
+      !1,
+      "notToBeDisabled()"
+    ));
+  }
+}
+const re = {
+  name: "tag-group"
+};
+class _s extends n {
+  constructor() {
+    super(...arguments), this.type = "tagGroup", this.componentInfo = re, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class zs extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = re, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new _s(this.ctx, r);
+  }
+}
+class Js {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = (e, i) => {
+      throw new Error("Component does not have props.");
+    };
+  }
+}
+const ie = {
+  name: "text-area"
+};
+class Ks extends n {
+  constructor() {
+    super(...arguments), this.type = "textArea", this.componentInfo = ie, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.fill = this.ctx.driver.wrapAction(V.bind(this, () => this.control())), this.clear = this.ctx.driver.wrapAction(W.bind(this, () => this.control())), this.control = x.bind(this, ".control");
+  }
+}
+class Qs extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = ie, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Ks(this.ctx, r);
+  }
+}
+class Xs {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    ));
+  }
+}
+const se = {
+  name: "text-field"
+};
+class ce extends n {
+  constructor() {
+    super(...arguments), this.type = "textField", this.componentInfo = se, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.fill = this.ctx.driver.wrapAction(V.bind(this, () => this.control())), this.clear = this.ctx.driver.wrapAction(W.bind(this, () => this.control())), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.control())), this.control = Be.bind(this, 'input[slot="_control"]');
+  }
+}
+class Ys extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = se, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new ce(this.ctx, r);
+  }
+}
+class Zs {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    ));
+  }
+}
+const oe = {
+  name: "time-picker"
+};
+class Ns extends n {
+  constructor() {
+    super(...arguments), this.type = "timePicker", this.componentInfo = oe, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator)), this.clear = this.ctx.driver.wrapAction(P.bind(this)), this.selectTime = this.ctx.driver.wrapAction($e.bind(this)), this.control = S.bind(this, "[data-vvd-component=text-field].control"), this.pickerButton = y.bind(this, "#picker-button"), this.clearButton = y.bind(this, "#clear-button");
+  }
+}
+class tc extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = oe, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byLabel = this.ctx.driver.wrapSelector(v.bind(this));
+  }
+  wrap(r) {
+    return new Ns(this.ctx, r);
+  }
+}
+class ec {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveVisibleError = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: f
+      },
+      e,
+      "toHaveVisibleError(${value})"
+    )), this.toHaveValue = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: w
+      },
+      e,
+      "toHaveValue(${value})"
+    ));
+  }
+}
+const ne = {
+  name: "toggletip"
+};
+class rc extends n {
+  constructor() {
+    super(...arguments), this.type = "toggletip", this.componentInfo = ne, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class ic extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = ne, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byHeadline = this.ctx.driver.wrapSelector(B.bind(this));
+  }
+  wrap(r) {
+    return new rc(this.ctx, r);
+  }
+}
+class sc {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toBeOpen = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !0,
+      "toBeOpen()"
+    )), this.toBeClosed = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !1,
+      "toBeClosed()"
+    ));
+  }
+}
+const ae = {
+  name: "tooltip"
+};
+class cc extends n {
+  constructor() {
+    super(...arguments), this.type = "tooltip", this.componentInfo = ae, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class oc extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = ae, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this)), this.byText = this.ctx.driver.wrapSelector(k.bind(this));
+  }
+  wrap(r) {
+    return new cc(this.ctx, r);
+  }
+}
+class nc {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toBeOpen = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !0,
+      "toBeOpen()"
+    )), this.toBeClosed = this.ctx.driver.wrapExpect(() => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: E
+      },
+      !1,
+      "toBeClosed()"
+    ));
+  }
+}
+const he = {
+  name: "tree-item"
+};
+class ac extends n {
+  constructor() {
+    super(...arguments), this.type = "treeItem", this.componentInfo = he, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class hc extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = he, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new ac(this.ctx, r);
+  }
+}
+class pc {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    )), this.toHaveIcon = this.ctx.driver.wrapExpect((e) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: u
+      },
+      e,
+      "toHaveIcon(${value})"
+    ));
+  }
+}
+const pe = {
+  name: "tree-view"
+};
+class dc extends n {
+  constructor() {
+    super(...arguments), this.type = "treeView", this.componentInfo = pe, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class lc extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = pe, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new dc(this.ctx, r);
+  }
+}
+class xc {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const de = {
+  name: "video-player"
+};
+class vc extends n {
+  constructor() {
+    super(...arguments), this.type = "videoPlayer", this.componentInfo = de, this.hover = this.ctx.driver.wrapAction(l.bind(this, () => this.locator)), this.focus = this.ctx.driver.wrapAction(p.bind(this, () => this.locator)), this.blur = this.ctx.driver.wrapAction(d.bind(this, () => this.locator));
+  }
+}
+class uc extends a {
+  constructor() {
+    super(...arguments), this.componentInfo = de, this.byTestId = this.ctx.driver.wrapSelector(h.bind(this));
+  }
+  wrap(r) {
+    return new vc(this.ctx, r);
+  }
+}
+class wc {
+  constructor(r, s) {
+    this.ctx = r, this.wrapper = s, this.toHaveProp = this.ctx.driver.wrapExpect((e, i) => this.ctx.driver.expectEq(
+      {
+        type: "eval",
+        el: this.wrapper.unwrap(),
+        fn: (c, o) => c[o],
+        arg: e
+      },
+      i,
+      `toHaveProp("${e}", ${i})`
+    ));
+  }
+}
+const j = {
+  collection: xe,
+  accordion: De,
+  accordionItem: Le,
+  actionGroup: Ue,
+  alert: _e,
+  audioPlayer: Ke,
+  avatar: Ye,
+  badge: tr,
+  banner: ir,
+  breadcrumb: or,
+  breadcrumbItem: hr,
+  button: dr,
+  calendar: vr,
+  calendarEvent: br,
+  card: Er,
+  checkbox: gr,
+  combobox: $r,
+  dataGrid: qr,
+  dataGridCell: Br,
+  dataGridRow: Wr,
+  datePicker: Rr,
+  dateRangePicker: Fr,
+  dateTimePicker: jr,
+  dialPad: Jr,
+  dialog: Xr,
+  divider: Nr,
+  emptyState: ri,
+  fab: ci,
+  filePicker: ai,
+  header: di,
+  icon: vi,
+  layout: bi,
+  menu: Ei,
+  menuItem: gi,
+  nav: $i,
+  navDisclosure: qi,
+  navItem: Bi,
+  note: Wi,
+  numberField: Ri,
+  option: Fi,
+  pagination: ji,
+  progress: Ji,
+  progressRing: Xi,
+  radio: Ni,
+  radioGroup: rs,
+  rangeSlider: cs,
+  richTextEditor: as,
+  searchableSelect: ds,
+  select: vs,
+  selectableBox: bs,
+  sideDrawer: Es,
+  simpleColorPicker: gs,
+  slider: $s,
+  splitButton: qs,
+  switch: Bs,
+  tab: Ws,
+  tabPanel: Rs,
+  tabs: Fs,
+  tag: js,
+  tagGroup: Js,
+  textArea: Xs,
+  textField: Zs,
+  timePicker: ec,
+  toggletip: sc,
+  tooltip: nc,
+  treeItem: pc,
+  treeView: xc,
+  videoPlayer: wc
+};
+class bc {
+  constructor(r) {
+    this.ctx = r, this.accordion = new We(this.ctx), this.accordionItem = new Re(this.ctx), this.actionGroup = new Fe(this.ctx), this.alert = new je(this.ctx), this.audioPlayer = new Je(this.ctx), this.avatar = new Xe(this.ctx), this.badge = new Ne(this.ctx), this.banner = new rr(this.ctx), this.breadcrumb = new cr(this.ctx), this.breadcrumbItem = new ar(this.ctx), this.button = new pr(this.ctx), this.calendar = new xr(this.ctx), this.calendarEvent = new wr(this.ctx), this.card = new fr(this.ctx), this.checkbox = new Ir(this.ctx), this.combobox = new Hr(this.ctx), this.dataGrid = new Sr(this.ctx), this.dataGridCell = new Tr(this.ctx), this.dataGridRow = new Vr(this.ctx), this.datePicker = new Gr(this.ctx), this.dateRangePicker = new Or(this.ctx), this.dateTimePicker = new Mr(this.ctx), this.dialPad = new zr(this.ctx), this.dialog = new Qr(this.ctx), this.divider = new Zr(this.ctx), this.emptyState = new ei(this.ctx), this.fab = new si(this.ctx), this.filePicker = new ni(this.ctx), this.header = new pi(this.ctx), this.icon = new xi(this.ctx), this.layout = new wi(this.ctx), this.menu = new fi(this.ctx), this.menuItem = new Ii(this.ctx), this.nav = new Hi(this.ctx), this.navDisclosure = new Si(this.ctx), this.navItem = new Ti(this.ctx), this.note = new Vi(this.ctx), this.numberField = new Gi(this.ctx), this.option = new Oi(this.ctx), this.pagination = new Mi(this.ctx), this.progress = new zi(this.ctx), this.progressRing = new Qi(this.ctx), this.radio = new Zi(this.ctx), this.radioGroup = new es(this.ctx), this.rangeSlider = new ss(this.ctx), this.richTextEditor = new ns(this.ctx), this.searchableSelect = new ps(this.ctx), this.select = new xs(this.ctx), this.selectableBox = new ws(this.ctx), this.sideDrawer = new fs(this.ctx), this.simpleColorPicker = new Is(this.ctx), this.slider = new Hs(this.ctx), this.splitButton = new Ss(this.ctx), this.switch = new Ts(this.ctx), this.tab = new Vs(this.ctx), this.tabPanel = new Gs(this.ctx), this.tabs = new Os(this.ctx), this.tag = new Ms(this.ctx), this.tagGroup = new zs(this.ctx), this.textArea = new Qs(this.ctx), this.textField = new Ys(this.ctx), this.timePicker = new tc(this.ctx), this.toggletip = new ic(this.ctx), this.tooltip = new oc(this.ctx), this.treeItem = new hc(this.ctx), this.treeView = new lc(this.ctx), this.videoPlayer = new uc(this.ctx);
+  }
+  expect(r) {
+    if (r.type in j)
+      return new j[r.type](
+        this.ctx,
+        r
+      );
+    throw new Error(`Unknown component type: ${r.type}`);
+  }
+}
+export {
+  bc as V
+};