@dynatrace/strato-components-testing 1.18.0 → 3.1.0

package/jest/testing-helpers/filters/filter-field.js

@@ -0,0 +1,436 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var filter_field_exports = {};
+__export(filter_field_exports, {
+  FilterFieldHelper: () => FilterFieldHelper,
+  FilterFieldPinnedAndRecentSuggestionBase: () => FilterFieldPinnedAndRecentSuggestionBase,
+  FilterFieldPinnedSuggestion: () => FilterFieldPinnedSuggestion,
+  FilterFieldRecentSuggestion: () => FilterFieldRecentSuggestion,
+  getFilterFieldHelper: () => getFilterFieldHelper
+});
+module.exports = __toCommonJS(filter_field_exports);
+var import_react = require("@testing-library/react");
+var import_user_event = require("@testing-library/user-event");
+var import_isFakeTimersEnabled = require("../utils/isFakeTimersEnabled.js");
+var import_setup_user_event = require("../utils/setup-user-event.js");
+class FilterFieldPinnedAndRecentSuggestionBase {
+  constructor(suggestionRoot) {
+    this.suggestionRoot = suggestionRoot;
+  }
+  get pinButtonElement() {
+    return this.suggestionRoot.querySelector(
+      "button[aria-checked]"
+    );
+  }
+  /**
+   * Receives the value of the suggestion that would be applied.
+   */
+  get value() {
+    return this.suggestionRoot.childNodes.item(1).textContent;
+  }
+  /**
+   * Returns if the current suggestion is currently pinned or not.
+   */
+  get pinned() {
+    if (this.pinButtonElement) {
+      return this.pinButtonElement.getAttribute("aria-checked") === "true";
+    }
+    return false;
+  }
+  /**
+   * Applies the suggestion to the filter field.
+   */
+  async apply() {
+    await (0, import_setup_user_event.setupUserEvent)({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).click(this.suggestionRoot);
+  }
+  get pinEnabled() {
+    if (this.pinButtonElement) {
+      return this.pinButtonElement.getAttribute("aria-disabled") === "false";
+    }
+    return false;
+  }
+  /**
+   * Allows the suggestion to be pinned if not pinned already.
+   */
+  async pin() {
+    if (this.pinned === true) {
+      return;
+    }
+    if (this.pinButtonElement) {
+      await (0, import_setup_user_event.setupUserEvent)({
+        pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+      }).click(this.pinButtonElement);
+      if ((0, import_isFakeTimersEnabled.isFakeTimersEnabled)()) {
+        await (0, import_react.act)(async () => {
+          jest.runOnlyPendingTimers();
+        });
+      }
+    }
+  }
+  /**
+   * Allows the suggestion to be unpinned if not unpinned already.
+   */
+  async unpin() {
+    if (this.pinned === false) {
+      return;
+    }
+    if (this.pinButtonElement) {
+      await (0, import_setup_user_event.setupUserEvent)({
+        pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+      }).click(this.pinButtonElement);
+      if ((0, import_isFakeTimersEnabled.isFakeTimersEnabled)()) {
+        await (0, import_react.act)(async () => {
+          jest.runOnlyPendingTimers();
+        });
+      }
+    }
+  }
+}
+class FilterFieldPinnedSuggestion extends FilterFieldPinnedAndRecentSuggestionBase {
+  /**
+   * Receives the value of the suggestion that would be applied.
+   */
+  get value() {
+    return this.suggestionRoot.childNodes.item(0).textContent;
+  }
+}
+class FilterFieldRecentSuggestion extends FilterFieldPinnedAndRecentSuggestionBase {
+  /**
+   * Receives the value of the suggestion that would be applied.
+   */
+  get value() {
+    return this.suggestionRoot.querySelector('[role="option"]')?.childNodes.item(0).textContent ?? null;
+  }
+  /**
+   * Receives time offset indicating when the filter statement has last been used.
+   */
+  get lastUsed() {
+    return this.suggestionRoot.querySelector('[role="option"]')?.childNodes.item(1).textContent ?? null;
+  }
+}
+class FilterFieldHelper {
+  constructor(dataTestId) {
+    this.dataTestId = dataTestId;
+  }
+  get filterFieldWrapper() {
+    return import_react.screen.getByTestId(this.dataTestId);
+  }
+  get editorView() {
+    return this.filterFieldWrapper.querySelector(
+      ".cm-content"
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    )?.cmTile.view;
+  }
+  get inputElement() {
+    return (0, import_react.within)(this.filterFieldWrapper).getAllByRole(
+      "textbox",
+      { hidden: true }
+    )[1];
+  }
+  get filterFieldElement() {
+    return (0, import_react.within)(this.filterFieldWrapper).getByRole(
+      "textbox",
+      {
+        name: "Filter field",
+        hidden: true
+      }
+    );
+  }
+  get placeholderElement() {
+    return this.filterFieldWrapper.querySelector(".cm-placeholder");
+  }
+  get suggestionsContainer() {
+    return import_react.screen.queryByTestId(`filterfield-suggestions-${this.dataTestId}`);
+  }
+  /** Returns the value of the native text input. */
+  get value() {
+    return this.inputElement.value;
+  }
+  /** Returns the value of the filter field. */
+  get filterFieldValue() {
+    return this.filterFieldElement.textContent || "";
+  }
+  /**
+   * The placeholder text shown in the filter field.
+   * Undefined if the placeholder is currently not rendered.
+   */
+  get placeholder() {
+    return this.placeholderElement?.textContent || void 0;
+  }
+  /** Focus the filter field if not already focused. */
+  async focus() {
+    if (!this.filterFieldWrapper.contains(document.activeElement)) {
+      await (0, import_react.act)(async () => {
+        this.inputElement.focus();
+      });
+      expect(
+        this.filterFieldWrapper.contains(document.activeElement)
+      ).toBeTruthy();
+      if ((0, import_isFakeTimersEnabled.isFakeTimersEnabled)()) {
+        await (0, import_react.act)(async () => {
+          jest.runOnlyPendingTimers();
+        });
+      }
+    }
+  }
+  /** Blur the filter field by tabbing out of it. */
+  async blur() {
+    await (0, import_react.act)(async () => {
+      this.filterFieldElement.blur();
+    });
+    if ((0, import_isFakeTimersEnabled.isFakeTimersEnabled)()) {
+      await (0, import_react.act)(async () => {
+        jest.runOnlyPendingTimers();
+      });
+    }
+  }
+  /** Fill a provided value into the filter field. */
+  async type(text, cursorIndex) {
+    const regEx = new RegExp(text, "g");
+    const matches = this.value.match(regEx);
+    await this.moveCursorTo(cursorIndex ?? -1);
+    await (0, import_setup_user_event.setupUserEvent)({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).keyboard(text);
+    await (0, import_react.waitFor)(() => {
+      expect(this.value.match(regEx) ?? []).toHaveLength(
+        (matches?.length ?? 0) + 1
+      );
+    });
+    if ((0, import_isFakeTimersEnabled.isFakeTimersEnabled)()) {
+      await (0, import_react.act)(async () => {
+        jest.runOnlyPendingTimers();
+      });
+    }
+  }
+  /** Clears the filter field value. */
+  async clear() {
+    if (this.value !== "") {
+      await (0, import_setup_user_event.setupUserEvent)({
+        pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+      }).click(
+        await (0, import_react.within)(this.filterFieldWrapper).findByRole("button", {
+          name: "Clear filter",
+          hidden: true
+        })
+      );
+      if ((0, import_isFakeTimersEnabled.isFakeTimersEnabled)()) {
+        await (0, import_react.act)(async () => {
+          jest.runOnlyPendingTimers();
+        });
+      }
+    }
+  }
+  /**
+   * Moves the cursor to the given index.
+   * -1 moves to the end of the input.
+   */
+  async moveCursorTo(index) {
+    const user = (0, import_setup_user_event.setupUserEvent)({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    });
+    if (index === -1) {
+      await (0, import_react.act)(async () => {
+        await this.focus();
+      });
+      await user.keyboard("{PageDown}");
+      return;
+    }
+    if (!this.editorView) {
+      console.warn("FilterField editor could not be found. Panic now.");
+      return;
+    }
+    await (0, import_react.act)(async () => {
+      await this.focus();
+      this.editorView.dispatch({
+        selection: {
+          anchor: Math.min(index, this.editorView.state.doc.length)
+        }
+      });
+    });
+    if ((0, import_isFakeTimersEnabled.isFakeTimersEnabled)()) {
+      await (0, import_react.act)(async () => {
+        jest.runOnlyPendingTimers();
+      });
+    }
+  }
+  /** Open the suggestions overlay with the keyboard shortcut. */
+  async openSuggestions() {
+    await (0, import_react.act)(async () => {
+      await this.focus();
+    });
+    await (0, import_setup_user_event.setupUserEvent)({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).keyboard("{Control>}{Space}{/Control}");
+    await (0, import_react.waitFor)(
+      async () => expect(this.suggestionsContainer).toBeInTheDocument()
+    );
+    if ((0, import_isFakeTimersEnabled.isFakeTimersEnabled)()) {
+      await (0, import_react.act)(async () => {
+        jest.runOnlyPendingTimers();
+      });
+    }
+  }
+  /**
+   * Close the suggestions overlay using the `Escape` key.
+   * If the filter field is focused, the focus will stay in the filter field.
+   */
+  async closeSuggestions() {
+    await (0, import_react.act)(async () => {
+      await this.focus();
+    });
+    await (0, import_setup_user_event.setupUserEvent)({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).keyboard("{Escape}");
+    if (this.suggestionsContainer !== null) {
+      await (0, import_react.waitForElementToBeRemoved)(() => this.suggestionsContainer);
+    }
+  }
+  /** Apply the suggestion with the given text. */
+  async applySuggestion(queryString) {
+    await (0, import_react.act)(async () => {
+      await this.focus();
+    });
+    await (0, import_react.waitFor)(() => {
+      expect(this.suggestionsContainer).toBeInTheDocument();
+    });
+    if (!this.suggestionsContainer) {
+      console.warn(
+        "The filter field suggestions overlay seems to be closed. Make sure to open it before applying a suggestion."
+      );
+      return;
+    }
+    const showMore = (0, import_react.within)(this.suggestionsContainer).queryByRole("option", {
+      name: "Show more"
+    });
+    if (showMore) {
+      await (0, import_setup_user_event.setupUserEvent)({
+        pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+      }).click(showMore);
+    }
+    let suggestions = (0, import_react.within)(this.suggestionsContainer).queryAllByTestId(
+      queryString,
+      { exact: true }
+    );
+    if (suggestions.length > 0) {
+      suggestions = suggestions.reduce((acc, container) => {
+        const suggestion = (0, import_react.within)(container).queryByRole("option");
+        if (suggestion) {
+          acc.push(suggestion);
+        }
+        return acc;
+      }, []);
+    }
+    if (suggestions.length === 0) {
+      suggestions.push(
+        ...(0, import_react.within)(this.suggestionsContainer).queryAllByText(
+          (_, element) => element?.getAttribute("role") === "option" && // The replace is needed to ignore non-breaking spaces
+          element.firstElementChild?.textContent?.replace(/\s+/g, " ") === queryString.replace(/\s+/g, " ")
+        )
+      );
+    }
+    if (suggestions.length === 0) {
+      console.warn(
+        `Could not query a suggestion with the given queryString '${queryString}' (trying queryByTestId and queryByText).`
+      );
+      return;
+    }
+    if (suggestions.length > 1) {
+      console.warn(
+        "Found multiple suggestions with the given testId. Will apply the first one"
+      );
+    }
+    await (0, import_setup_user_event.setupUserEvent)({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).click(suggestions[0]);
+  }
+  /** Get recent suggestions */
+  async getRecentSuggestions() {
+    if (this.suggestionsContainer) {
+      const recentGroup = (0, import_react.within)(this.suggestionsContainer).getByRole("group", {
+        name: "Recently used filters"
+      });
+      const suggestions = (0, import_react.within)(recentGroup).getAllByRole(
+        "group",
+        {
+          hidden: true,
+          name(_accessibleName, element) {
+            return element.getAttribute(
+              "data-strato-filter-field-virtual-focus-type"
+            ) === "recent-suggestion";
+          }
+        }
+      );
+      return suggestions.map((el) => new FilterFieldRecentSuggestion(el));
+    }
+    return [];
+  }
+  /** Get pinned suggestions */
+  async getPinnedSuggestions() {
+    if (this.suggestionsContainer) {
+      try {
+        await (0, import_react.waitFor)(
+          () => import_react.screen.getByRole("group", {
+            name: "Pinned filters",
+            hidden: true,
+            suggest: false
+          })
+        );
+        const pinnedGroup = (0, import_react.within)(this.suggestionsContainer).getByRole(
+          "group",
+          {
+            name: "Pinned filters",
+            hidden: true
+          }
+        );
+        const suggestions = (0, import_react.within)(pinnedGroup).getAllByRole(
+          "group",
+          {
+            hidden: true,
+            name(_accessibleName, element) {
+              return element.getAttribute(
+                "data-strato-filter-field-virtual-focus-type"
+              ) === "pinned-suggestion";
+            }
+          }
+        );
+        return suggestions.map((el) => new FilterFieldPinnedSuggestion(el));
+      } catch {
+        return [];
+      }
+    }
+    return [];
+  }
+  /** Paste text at the current cursor position */
+  async paste(text, cursorIndex) {
+    await this.moveCursorTo(cursorIndex ?? -1);
+    await (0, import_setup_user_event.setupUserEvent)({
+      pointerEventsCheck: import_user_event.PointerEventsCheckLevel.Never
+    }).paste(text);
+    if ((0, import_isFakeTimersEnabled.isFakeTimersEnabled)()) {
+      await (0, import_react.act)(async () => {
+        jest.runOnlyPendingTimers();
+      });
+    }
+  }
+}
+function getFilterFieldHelper(dataTestId) {
+  return new FilterFieldHelper(dataTestId);
+}

package/jest/testing-helpers/forms/base-input.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Helper class for interacting with the text input
+ * @public
+ */
+export declare class BaseInputHelper {
+    protected dataTestId: string;
+    protected get inputWrapper(): HTMLElement;
+    protected get inputElement(): HTMLInputElement;
+    constructor(dataTestId: string);
+    /** Returns the value of the native input element. */
+    get value(): string;
+    focus(): void;
+    /** Fill a provided value into the text input. */
+    type(text: string): Promise<void>;
+    /** Clears the text input value. */
+    clear(): Promise<void>;
+}

package/jest/testing-helpers/forms/base-input.js

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base_input_exports = {};
+__export(base_input_exports, {
+  BaseInputHelper: () => BaseInputHelper
+});
+module.exports = __toCommonJS(base_input_exports);
+var import_react = require("@testing-library/react");
+var import_setup_user_event = require("../utils/setup-user-event.js");
+class BaseInputHelper {
+  constructor(dataTestId) {
+    this.dataTestId = dataTestId;
+  }
+  get inputWrapper() {
+    return import_react.screen.getByTestId(this.dataTestId);
+  }
+  get inputElement() {
+    return (0, import_react.within)(this.inputWrapper).getByRole("textbox", { hidden: true });
+  }
+  /** Returns the value of the native input element. */
+  get value() {
+    return this.inputElement.value;
+  }
+  focus() {
+    this.inputElement.focus();
+  }
+  /** Fill a provided value into the text input. */
+  async type(text) {
+    await (0, import_setup_user_event.setupUserEvent)().type(this.inputElement, text);
+  }
+  /** Clears the text input value. */
+  async clear() {
+    await (0, import_setup_user_event.setupUserEvent)().clear(this.inputElement);
+  }
+}

package/jest/testing-helpers/forms/password-input.d.ts

@@ -0,0 +1,16 @@
+import { BaseInputHelper } from './base-input.js';
+/**
+ * Helper class for interacting with the text input
+ * @public
+ */
+export declare class PasswordInputHelper extends BaseInputHelper {
+    showPassword(): Promise<void>;
+    hidePassword(): Promise<void>;
+}
+/**
+ * Helper function that returns the password input element with its testing utilities.
+ * @public
+ */
+export declare function getPasswordInputHelper(
+/** The accessible test id used to locate the password input wrapper. */
+dataTestId: string): PasswordInputHelper;

package/jest/testing-helpers/forms/password-input.js

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var password_input_exports = {};
+__export(password_input_exports, {
+  PasswordInputHelper: () => PasswordInputHelper,
+  getPasswordInputHelper: () => getPasswordInputHelper
+});
+module.exports = __toCommonJS(password_input_exports);
+var import_react = require("@testing-library/react");
+var import_base_input = require("./base-input.js");
+var import_setup_user_event = require("../utils/setup-user-event.js");
+class PasswordInputHelper extends import_base_input.BaseInputHelper {
+  async showPassword() {
+    if (this.inputElement.getAttribute("type") === "password") {
+      const passwordButton = (0, import_react.within)(this.inputWrapper).getByRole("button", {
+        hidden: true
+      });
+      await (0, import_setup_user_event.setupUserEvent)().click(passwordButton);
+    }
+  }
+  async hidePassword() {
+    if (this.inputElement.getAttribute("type") === "text") {
+      const passwordButton = (0, import_react.within)(this.inputWrapper).getByRole("button", {
+        hidden: true
+      });
+      await (0, import_setup_user_event.setupUserEvent)().click(passwordButton);
+    }
+  }
+}
+function getPasswordInputHelper(dataTestId) {
+  return new PasswordInputHelper(dataTestId);
+}

package/jest/testing-helpers/forms/search-input.d.ts

@@ -0,0 +1,20 @@
+import { BaseInputHelper } from './base-input.js';
+/**
+ * Helper class for interacting with the search input
+ * @public
+ */
+export declare class SearchInputHelper extends BaseInputHelper {
+    protected get inputElement(): HTMLInputElement;
+    /**
+     * Helper that will let you call a specific suffix button
+     * within the SearchInput component.
+     */
+    clickButton(name: string): Promise<void>;
+}
+/**
+ * Helper function that returns the search input element with its testing utilities.
+ * @public
+ */
+export declare function getSearchInputHelper(
+/** The accessible test id used to locate the input wrapper. */
+dataTestId: string): SearchInputHelper;

package/jest/testing-helpers/forms/search-input.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var search_input_exports = {};
+__export(search_input_exports, {
+  SearchInputHelper: () => SearchInputHelper,
+  getSearchInputHelper: () => getSearchInputHelper
+});
+module.exports = __toCommonJS(search_input_exports);
+var import_react = require("@testing-library/react");
+var import_base_input = require("./base-input.js");
+var import_setup_user_event = require("../utils/setup-user-event.js");
+class SearchInputHelper extends import_base_input.BaseInputHelper {
+  get inputElement() {
+    return (0, import_react.within)(this.inputWrapper).getByRole("searchbox", { hidden: true });
+  }
+  /**
+   * Helper that will let you call a specific suffix button
+   * within the SearchInput component.
+   */
+  async clickButton(name) {
+    const button = (0, import_react.within)(this.inputWrapper).getByRole("button", {
+      hidden: true,
+      name
+    });
+    await (0, import_setup_user_event.setupUserEvent)().click(button);
+  }
+}
+function getSearchInputHelper(dataTestId) {
+  return new SearchInputHelper(dataTestId);
+}

package/jest/testing-helpers/forms/select.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Helper class for interacting with the select.
+ * @public
+ */
+export declare class SelectTestingHelper {
+    protected dataTestId: string;
+    constructor(dataTestId: string);
+    /**
+     * Gets the root element of the select.
+     */
+    get element(): HTMLDivElement;
+    /**
+     * Gets the trigger element of the select.
+     */
+    get trigger(): HTMLDivElement;
+    /**
+     * Gets the text value of the trigger display value of the select.
+     */
+    get displayValue(): string;
+    /**
+     * Gets the overlay (content) of the select.
+     */
+    get overlay(): HTMLDivElement;
+    /**
+     * Gets the text value of the select filter in the overlay.
+     */
+    get filterValue(): string;
+    /**
+     * Gets the currently selected option(s).
+     */
+    get selectedOptions(): Array<string>;
+    /**
+     * Gets the open state of the select overlay.
+     */
+    get openState(): boolean;
+    /**
+     * Gets the option with the corresponding label.
+     */
+    getOption(label: string): HTMLOptionElement;
+    /**
+     * Selects the option with the corresponding label.
+     */
+    selectOption(label: string): Promise<void>;
+    /**
+     * Opens the select overlay.
+     */
+    open(): Promise<void>;
+    /**
+     * Closes the select overlay.
+     */
+    close(): Promise<void>;
+    /**
+     * Types in the filter of the select.
+     */
+    typeInFilter(text: string): Promise<void>;
+    /**
+     * Clears the filter / search of the select overlay.
+     */
+    clearFilter(): Promise<void>;
+}
+/**
+ * Helper function that returns the select element with its testing utilities.
+ * @public
+ */
+export declare function getSelectTestingHelper(dataTestId: string): SelectTestingHelper;