@atomic-testing/component-driver-mui-v9 0.0.0

package/dist/index.d.mts

@@ -0,0 +1,1391 @@
+import { HTMLButtonDriver, HTMLCheckboxDriver, HTMLElementDriver, HTMLRadioButtonGroupDriver, HTMLSelectDriver, HTMLTextInputDriver } from "@atomic-testing/component-driver-html";
+import { ComponentDriver, ComponentDriverCtor, ContainerDriver, ErrorBase, IComponentDriverOption, IContainerDriverOption, IFormFieldDriver, IInputDriver, IToggleDriver, Interactor, ListComponentDriver, ListComponentDriverSpecificOption, LocatorRelativePosition, Nullable, Optional, PartLocator, ScenePart } from "@atomic-testing/core";
+
+//#region src/components/AccordionDriver.d.ts
+declare const parts$13: {
+  /**
+   * The clickable area to expand/collapse the accordion.
+   */
+  disclosure: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+  summary: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+  content: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+};
+/**
+ * Driver for Material UI v9 Accordion component.
+ * @see https://mui.com/material-ui/react-accordion/
+ */
+declare class AccordionDriver extends ComponentDriver<typeof parts$13> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  /**
+   * Get the title/summary of the accordion.
+   * @returns The title/summary of the accordion.
+   */
+  getSummary(): Promise<string | null>;
+  /**
+   * Whether the accordion is expanded.
+   * @returns True if the accordion is expanded, false if collapsed.
+   */
+  isExpanded(): Promise<boolean>;
+  /**
+   * Whether the accordion is disabled.
+   * @returns True if the accordion is disabled, false if enabled.
+   */
+  isDisabled(): Promise<boolean>;
+  click(): Promise<void>;
+  /**
+   * Expand the accordion.
+   */
+  expand(): Promise<void>;
+  /**
+   * Collapse the accordion.
+   */
+  collapse(): Promise<void>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/AlertDriver.d.ts
+declare const parts$12: {
+  title: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+  message: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+};
+/**
+ * Driver for Material UI v9 Alert component.
+ * @see https://mui.com/material-ui/react-alert/
+ */
+declare class AlertDriver<ContentT extends ScenePart = {}> extends ContainerDriver<ContentT, typeof parts$12> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IContainerDriverOption>);
+  getTitle(): Promise<string | null>;
+  getMessage(): Promise<string | null>;
+  getSeverity(): Promise<string | null>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/AvatarDriver.d.ts
+/**
+ * Driver for the Material UI v9 Avatar component.
+ *
+ * An Avatar renders a `.MuiAvatar-root`; with a `src` it contains an
+ * `img.MuiAvatar-img`, otherwise it shows letter initials (or an icon). The
+ * driver reads the image's `alt`, the presence of the image, and the letter
+ * initials accordingly.
+ * @see https://mui.com/material-ui/react-avatar/
+ */
+declare class AvatarDriver extends ComponentDriver {
+  private get imageLocator();
+  /**
+   * Whether the avatar renders an image (vs letter/icon fallback).
+   */
+  hasImage(): Promise<boolean>;
+  /**
+   * The image's alt text, or `undefined` when the avatar has no image.
+   */
+  getAltText(): Promise<Optional<string>>;
+  /**
+   * The letter initials of a text avatar, or `undefined` for an image or icon
+   * avatar (which render no text).
+   */
+  getInitials(): Promise<Optional<string>>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/AvatarGroupDriver.d.ts
+declare const defaultAvatarGroupDriverOption: ListComponentDriverSpecificOption<AvatarDriver>;
+type AvatarGroupDriverOption<ItemT extends AvatarDriver> = ListComponentDriverSpecificOption<ItemT> & Partial<IComponentDriverOption<any>>;
+/**
+ * Driver for the Material UI v9 AvatarGroup component.
+ *
+ * AvatarGroup renders up to `max` avatars plus a surplus "+N" avatar when there
+ * are more. This is a {@link ListComponentDriver} over the rendered avatars
+ * (surplus included via `getItems`), with helpers to count the real avatars and
+ * read the surplus label.
+ * @see https://mui.com/material-ui/react-avatar/#grouped
+ */
+declare class AvatarGroupDriver<ItemT extends AvatarDriver = AvatarDriver> extends ListComponentDriver<ItemT> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<AvatarGroupDriverOption<ItemT>>);
+  /**
+   * The number of real avatars shown, excluding the surplus "+N" indicator.
+   */
+  getVisibleCount(): Promise<number>;
+  /**
+   * The surplus indicator's label (e.g. "+3"), or `undefined` when every avatar
+   * fits within `max` and no surplus is shown.
+   */
+  getSurplusLabel(): Promise<Optional<string>>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/AutoCompleteDriver.d.ts
+declare const parts$11: {
+  input: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLTextInputDriver;
+  };
+  dropdown: {
+    locator: import("@atomic-testing/core").LinkedCssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+};
+/**
+ * The match type of the autocomplete, default to 'exact'
+ * 'exact': The value must match exactly to one of the options
+ * 'first-available': The value will be set to the first available option
+ */
+type AutoCompleteMatchType = 'exact' | 'first-available';
+interface AutoCompleteDriverSpecificOption {
+  matchType: AutoCompleteMatchType;
+}
+interface AutoCompleteDriverOption extends IComponentDriverOption, AutoCompleteDriverSpecificOption {}
+declare const defaultAutoCompleteDriverOption: AutoCompleteDriverSpecificOption;
+declare class AutoCompleteDriver extends ComponentDriver<typeof parts$11> implements IInputDriver<string | null> {
+  private _option;
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<AutoCompleteDriverOption>);
+  /**
+   * Get the display of the autocomplete
+   */
+  getValue(): Promise<string | null>;
+  /**
+   * Set the value of the autocomplete, how selection happens
+   * depends on the option assigned to AutoCompleteDriver
+   * By default, when the option has matchType set to exact, only option with matching text would be selected
+   * When the option has matchType set to first-available, the first option would be selected regardless of the text
+   *
+   * Option of auto complete can be set at the time of part definition, for example
+   * ```
+   * {
+   *   myAutoComplete: {
+   *     locator: byCssSelector('my-auto-complete'),
+   *     driver: AutoCompleteDriver,
+   *     option: {
+   *       matchType: 'first-available',
+   *     },
+   *   },
+   * }
+   * ```
+   *
+   * @param value
+   * @returns
+   */
+  setValue(value: string | null): Promise<boolean>;
+  isDisabled(): Promise<boolean>;
+  isReadonly(): Promise<boolean>;
+  /**
+   * Whether the popup is currently showing its loading indicator (the
+   * `loadingText`). Only meaningful while the popup is open — open it first
+   * (e.g. by typing into the input), since MUI renders nothing otherwise.
+   */
+  isLoading(): Promise<boolean>;
+  /**
+   * Whether the popup is currently showing its "no options" message. Same
+   * open-the-popup-first caveat as {@link AutoCompleteDriver.isLoading}.
+   */
+  hasNoOptions(): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/BadgeDriver.d.ts
+declare const parts$10: {
+  contentDisplay: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+};
+/**
+ * Driver for Material UI v9 Badge component.
+ * @see https://mui.com/material-ui/react-badge/
+ */
+declare class BadgeDriver extends ComponentDriver<typeof parts$10> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  /**
+   * Get the content of the badge.
+   * @returns The content of the badge.
+   */
+  getContent(): Promise<string | null>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/BottomNavigationActionDriver.d.ts
+/**
+ * Driver for a single Material UI v9 BottomNavigationAction.
+ *
+ * Each action renders as a `<button>` (no explicit ARIA role); MUI marks the
+ * active one with the `Mui-selected` state class, so selection is read from the
+ * class while `getText`/`click`/`isDisabled` come from {@link HTMLButtonDriver}
+ * and the base `ComponentDriver`.
+ * @see https://mui.com/material-ui/react-bottom-navigation/
+ */
+declare class BottomNavigationActionDriver extends HTMLButtonDriver {
+  /**
+   * Whether this action is selected (MUI applies the `Mui-selected` state class).
+   */
+  isSelected(): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/BottomNavigationDriver.d.ts
+interface BottomNavigationActionInfo {
+  /** The action's visible label. */
+  label: Optional<string>;
+  /** Whether the action is currently selected. */
+  selected: boolean;
+}
+type BottomNavigationDriverOption<ItemT extends BottomNavigationActionDriver> = ListComponentDriverSpecificOption<ItemT> & Partial<IComponentDriverOption<any>>;
+/**
+ * Driver for the Material UI v9 BottomNavigation component.
+ *
+ * A {@link ListComponentDriver} over the action buttons, exposing the selected
+ * index/label, selection by index/label, and per-action info, plus per-action
+ * {@link BottomNavigationActionDriver} instances via `getItems`/`getItemByIndex`/
+ * `getItemByLabel`.
+ * @see https://mui.com/material-ui/react-bottom-navigation/
+ */
+declare class BottomNavigationDriver<ItemT extends BottomNavigationActionDriver = BottomNavigationActionDriver> extends ListComponentDriver<ItemT> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<BottomNavigationDriverOption<ItemT>>);
+  /**
+   * Every action with its label and selected state, in order.
+   */
+  getActions(): Promise<BottomNavigationActionInfo[]>;
+  /**
+   * Zero-based index of the selected action, or `-1` when none is selected.
+   */
+  getSelectedIndex(): Promise<number>;
+  /**
+   * Label of the selected action, or `null` when none is selected. Returns `null`
+   * (not `undefined`) to match the sibling `TabsDriver.getSelectedLabel` contract.
+   */
+  getSelectedLabel(): Promise<Nullable<string>>;
+  /**
+   * Select the action at the given zero-based index.
+   * @returns `false` when the index is out of range.
+   */
+  selectByIndex(index: number): Promise<boolean>;
+  /**
+   * Select the first action whose visible label equals `label`.
+   * @returns `false` when no action matches.
+   */
+  selectByLabel(label: string): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/ButtonDriver.d.ts
+/**
+ * Driver for Material UI v9 Button component.
+ * @see https://mui.com/material-ui/react-button/
+ */
+declare class ButtonDriver extends HTMLButtonDriver {
+  getValue(): Promise<string | null>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/CheckboxDriver.d.ts
+declare const checkboxPart: {
+  checkbox: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLCheckboxDriver;
+  };
+};
+type CheckboxScenePart = typeof checkboxPart;
+declare class CheckboxDriver extends ComponentDriver<CheckboxScenePart> implements IFormFieldDriver<string | null>, IToggleDriver {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  isSelected(): Promise<boolean>;
+  setSelected(selected: boolean): Promise<void>;
+  getValue(): Promise<string | null>;
+  isIndeterminate(): Promise<boolean>;
+  isDisabled(): Promise<boolean>;
+  isReadonly(): Promise<boolean>;
+  /**
+   * Get the text of the label associated with the checkbox, or `undefined` when the checkbox
+   * is rendered without one (e.g. a bare `<Checkbox>` outside of a `FormControlLabel`).
+   *
+   * MUI's `FormControlLabel` does not expose a `for`/`id` or `aria-labelledby` association; it
+   * labels the control implicitly by wrapping it in a `<label>` and rendering the text as a
+   * sibling. The label therefore lives outside this driver's own subtree, so we re-root at the
+   * enclosing `<label>` — matched against this checkbox via `:has()`, while preserving the
+   * surrounding scope — and read its text. This resolves to a single CSS selector, so it behaves
+   * identically across every interactor (DOM/React/Vue and Playwright).
+   */
+  getLabel(): Promise<Optional<string>>;
+  /**
+   * Build a locator for the `<label>` that encloses this checkbox, scoped to the same ancestor
+   * context as the checkbox itself so that sibling checkboxes are never mismatched.
+   */
+  private getEnclosingLabelLocator;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/ChipDriver.d.ts
+declare const parts$9: {
+  contentDisplay: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+  removeButton: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+};
+/**
+ * Driver for Material UI v9 Chip component.
+ * @see https://mui.com/material-ui/react-chip/
+ */
+declare class ChipDriver extends ComponentDriver<typeof parts$9> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  /**
+   * Get the label content of the chip.
+   * @returns The label text content of the chip.
+   */
+  getLabel(): Promise<string | null>;
+  clickRemove(): Promise<void>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/DialogDriver.d.ts
+declare const parts$8: {
+  title: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+  dialogContainer: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+};
+declare class DialogDriver<ContentT extends ScenePart> extends ContainerDriver<ContentT, typeof parts$8> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IContainerDriverOption>);
+  overriddenParentLocator(): Optional<PartLocator>;
+  overrideLocatorRelativePosition(): Optional<LocatorRelativePosition>;
+  getTitle(): Promise<string | null>;
+  /**
+   * Dismiss the dialog by clicking outside its content, then wait for it to close.
+   *
+   * MUI's "backdrop click" is handled on the `.MuiDialog-container` surface (which
+   * overlays the visual `.MuiBackdrop-root`), firing `onClose` only when the click
+   * target is the container itself. The click therefore lands on the container near
+   * its top-left corner to avoid the centered paper. Whether it actually closes
+   * depends on the consumer's `onClose` handling (MUI reports a `"backdropClick"`
+   * reason); the returned boolean reflects the observed close, not merely the click.
+   *
+   * @param timeoutMs How long to wait for the close transition to finish
+   * @returns true if the dialog closed
+   */
+  closeByBackdropClick(timeoutMs?: number): Promise<boolean>;
+  /**
+   * Wait for dialog to open
+   * @param timeoutMs
+   * @returns true open has performed successfully
+   */
+  waitForOpen(timeoutMs?: number): Promise<boolean>;
+  /**
+   * Wait for dialog to close
+   * @param timeoutMs
+   * @returns true open has performed successfully
+   */
+  waitForClose(timeoutMs?: number): Promise<boolean>;
+  /**
+   * Check if the dialog box is open.  Caution, because of animation, upon an open/close action is performed
+   * use waitForOpen() or waitForClose() before using isOpen() would result a more accurate open state of the dialog
+   * @returns true if dialog box is open
+   */
+  isOpen(): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/OverlayDriver.d.ts
+/**
+ * Shared base for MUI portal-rendered overlays (Drawer today; Dialog, Menu,
+ * Popover and SpeedDial are prospective consumers). It owns the open/close
+ * lifecycle that {@link DialogDriver} first proved out: `isOpen` derived from the
+ * visible surface, `waitForOpen`/`waitForClose` spanning the transition, and
+ * `closeByBackdrop`.
+ *
+ * Subclasses supply {@link getSurfaceLocator} (the element whose visibility means
+ * "open") and, when the overlay is portal-rendered, override
+ * `overriddenParentLocator()`/`overrideLocatorRelativePosition()` to re-root.
+ *
+ * `closeByEscape` is intentionally absent: keyboard dismissal needs a key-press
+ * primitive the `Interactor` interface does not yet expose, which would have to be
+ * added to every interactor (DOM/React/Vue/Playwright). It is deferred rather than
+ * partially implemented.
+ */
+declare abstract class OverlayDriver<ContentT extends ScenePart, T extends ScenePart = {}> extends ContainerDriver<ContentT, T> {
+  /**
+   * Locator of the surface whose visibility reflects the open state (e.g. the
+   * drawer/dialog paper).
+   */
+  protected abstract getSurfaceLocator(): PartLocator;
+  /**
+   * Locator of the dismissible backdrop. Defaults to MUI's `.MuiBackdrop-root`.
+   */
+  protected getBackdropLocator(): PartLocator;
+  /**
+   * Whether the overlay is mounted and its surface is visible. Because of open/close
+   * transitions, prefer `waitForOpen()`/`waitForClose()` immediately after an action.
+   */
+  isOpen(): Promise<boolean>;
+  /**
+   * Wait until the overlay is open.
+   * @returns true once open within the timeout.
+   */
+  waitForOpen(timeoutMs?: number): Promise<boolean>;
+  /**
+   * Wait until the overlay is closed.
+   * @returns true once closed within the timeout.
+   */
+  waitForClose(timeoutMs?: number): Promise<boolean>;
+  /**
+   * Dismiss by clicking the backdrop, then wait for the close transition. Whether
+   * it actually closes depends on the consumer honoring the backdrop dismissal; the
+   * returned boolean reflects the observed close, not merely the click.
+   */
+  closeByBackdrop(timeoutMs?: number): Promise<boolean>;
+}
+//#endregion
+//#region src/components/DrawerDriver.d.ts
+declare const drawerParts: {
+  paper: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+};
+type DrawerAnchor = 'left' | 'right' | 'top' | 'bottom';
+/**
+ * Driver for the Material UI v9 Drawer (and SwipeableDrawer) component.
+ *
+ * A temporary Drawer is a portal-rendered Modal: its root `role="presentation"`
+ * (`.MuiDrawer-root`) carries the anchor class and holds a `.MuiBackdrop-root` plus
+ * the `.MuiDrawer-paper` panel. Open/close/backdrop behavior is inherited from
+ * {@link OverlayDriver}; this driver adds the anchor read and the portal re-rooting.
+ * @see https://mui.com/material-ui/react-drawer/
+ */
+declare class DrawerDriver<ContentT extends ScenePart> extends OverlayDriver<ContentT, typeof drawerParts> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IContainerDriverOption>);
+  overriddenParentLocator(): Optional<PartLocator>;
+  overrideLocatorRelativePosition(): Optional<LocatorRelativePosition>;
+  protected getSurfaceLocator(): PartLocator;
+  /**
+   * The side the drawer is anchored to, read from the portal root's anchor class, or
+   * `undefined` when the drawer is closed/unmounted.
+   *
+   * The anchor class sits on the `role="presentation"` root itself, so it is read
+   * directly off {@link drawerRootLocator} rather than through a part (parts resolve
+   * as descendants of that root, but the class is on the root).
+   */
+  getAnchor(): Promise<Optional<DrawerAnchor>>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/FabDriver.d.ts
+/**
+ * Driver for Material UI v9 Floating Action Button component.
+ * @see https://mui.com/material-ui/react-floating-action-button/
+ */
+declare class FabDriver extends ButtonDriver {
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/InputDriver.d.ts
+declare const parts$7: {
+  singlelineInput: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLTextInputDriver;
+  };
+  multilineInput: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLTextInputDriver;
+  };
+};
+/**
+ * A driver for the Material UI v9 Input, FilledInput, OutlinedInput, and StandardInput components.
+ */
+declare class InputDriver extends ComponentDriver<typeof parts$7> implements IInputDriver<string | null> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  private getInputType;
+  /**
+   * Retrieve the current value of the input element, handling both single line
+   * and multiline configurations.
+   */
+  getValue(): Promise<string | null>;
+  /**
+   * Set the value of the underlying input element.
+   *
+   * @param value The text to assign to the input.
+   */
+  setValue(value: string | null): Promise<boolean>;
+  /**
+   * Determine whether the input element is disabled.
+   */
+  isDisabled(): Promise<boolean>;
+  /**
+   * Determine whether the input element is read only.
+   */
+  isReadonly(): Promise<boolean>;
+  /**
+   * Identifier for this driver.
+   */
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/ListItemDriver.d.ts
+/**
+ * @internal
+ */
+declare class ListItemDriver extends ComponentDriver {
+  label(): Promise<string | null>;
+  isSelected(): Promise<boolean>;
+  isDisabled(): Promise<boolean>;
+  click(): Promise<void>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/ListDriver.d.ts
+type ListDriverOption<ItemT extends ListItemDriver> = ListComponentDriverSpecificOption<ItemT> & Partial<IComponentDriverOption<any>>;
+declare class ListDriver<ItemT extends ListItemDriver = ListItemDriver> extends ListComponentDriver<ItemT> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: ListDriverOption<ItemT>);
+  getSelected(): Promise<ListItemDriver | null>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/MenuItemDriver.d.ts
+/**
+ * @internal
+ */
+declare class MenuItemDriver extends ListItemDriver {
+  value(): Promise<string | null>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/MenuDriver.d.ts
+declare const parts$6: {
+  menu: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+};
+declare class MenuDriver extends ComponentDriver<typeof parts$6> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  overriddenParentLocator(): Optional<PartLocator>;
+  overrideLocatorRelativePosition(): Optional<LocatorRelativePosition>;
+  getMenuItemByLabel(label: string): Promise<MenuItemDriver | null>;
+  selectByLabel(label: string): Promise<void>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/PaginationDriver.d.ts
+/**
+ * Driver for the Material UI v9 Pagination component.
+ *
+ * Pagination renders a `<nav>` whose `MuiPaginationItem` buttons are each wrapped
+ * in their own `<li>` (so they are not siblings — positional `:nth-of-type`
+ * iteration does not apply). Page controls are read by their accessible name
+ * instead: every page button's aria-label ends in its page number ("Go to page N",
+ * or "page N" once selected), and first/previous/next/last carry stable
+ * aria-labels and become `disabled` at the bounds.
+ * @see https://mui.com/material-ui/react-pagination/
+ */
+declare class PaginationDriver extends ComponentDriver {
+  private get pageItemsLocator();
+  /**
+   * The selected page number, or `-1` when no page is marked current.
+   */
+  getSelectedPage(): Promise<number>;
+  /**
+   * Total number of pages, taken from the highest numbered page control. MUI
+   * always renders the upper boundary page (boundaryCount >= 1), so this is exact
+   * even when middle pages collapse into an ellipsis.
+   */
+  getPageCount(): Promise<number>;
+  /**
+   * Click the numbered control for `page`. A no-op (returns `true`) when `page` is
+   * already selected.
+   * @returns `false` when that page is not currently rendered (e.g. hidden behind
+   * an ellipsis) or is disabled.
+   */
+  goToPage(page: number): Promise<boolean>;
+  /**
+   * Click a navigation control unless it is absent or disabled (at a bound).
+   * @returns whether the click was performed.
+   */
+  private clickNavButton;
+  /** Go to the next page. Returns `false` when on the last page or the control is hidden. */
+  next(): Promise<boolean>;
+  /** Go to the previous page. Returns `false` when on the first page or the control is hidden. */
+  previous(): Promise<boolean>;
+  /** Jump to the first page. Returns `false` when already there or the control is hidden (needs `showFirstButton`). */
+  first(): Promise<boolean>;
+  /** Jump to the last page. Returns `false` when already there or the control is hidden (needs `showLastButton`). */
+  last(): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/ProgressDriver.d.ts
+declare const parts$5: {
+  choices: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLRadioButtonGroupDriver;
+  };
+};
+declare class ProgressDriver extends ComponentDriver<typeof parts$5> implements IInputDriver<number | null> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  getValue(): Promise<number | null>;
+  getType(): Promise<'linear' | 'circular'>;
+  isDeterminate(): Promise<boolean>;
+  setValue(value: number | null): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/RadioDriver.d.ts
+/**
+ * Driver for a single Material UI v9 Radio option (a `FormControlLabel` wrapping a
+ * `Radio`). Its label text is the `FormControlLabel`'s text; selected/value/disabled
+ * state is read from the underlying radio `<input>`.
+ *
+ * Used as the item driver of {@link RadioGroupDriver}, but also usable on its own
+ * when a single radio option is addressed directly. It declares no parts (so it
+ * composes as a list item) and reads the input via descendant locators.
+ * @see https://mui.com/material-ui/react-radio-button/
+ */
+declare class RadioDriver extends ComponentDriver {
+  private get input();
+  /**
+   * The option's visible label, or `undefined` when it renders without text.
+   */
+  getLabel(): Promise<Optional<string>>;
+  /**
+   * The option's `value` attribute.
+   */
+  getValue(): Promise<string | null>;
+  /**
+   * Whether this option is the selected one in its group.
+   */
+  isSelected(): Promise<boolean>;
+  /**
+   * Whether this option is disabled.
+   */
+  isDisabled(): Promise<boolean>;
+  /**
+   * Select this option by clicking its radio input. No-op effect when already selected.
+   */
+  select(): Promise<void>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/RadioGroupDriver.d.ts
+/**
+ * Radio options are located by their `FormControlLabel` root, which wraps the
+ * radio `<input>` and renders the label text — the unit a {@link RadioDriver}
+ * drives.
+ */
+declare const defaultRadioGroupDriverOption: ListComponentDriverSpecificOption<RadioDriver>;
+type RadioGroupDriverOption<ItemT extends RadioDriver> = ListComponentDriverSpecificOption<ItemT> & Partial<IComponentDriverOption<any>>;
+/**
+ * Driver for the Material UI v9 RadioGroup component.
+ *
+ * `<RadioGroup>` renders a `role="radiogroup"` whose options are `FormControlLabel`s
+ * wrapping a radio `<input>`. This driver is a {@link ListComponentDriver} over those
+ * options, so per-option {@link RadioDriver} instances are available via
+ * `getItems`/`getItemByIndex`/`getItemByLabel`, on top of the group-level value and
+ * label helpers. The selected value is read from the checked `<input>` and selection
+ * is made by value or label.
+ * @see https://mui.com/material-ui/react-radio-button/
+ */
+declare class RadioGroupDriver<ItemT extends RadioDriver = RadioDriver> extends ListComponentDriver<ItemT> implements IInputDriver<string | null> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<RadioGroupDriverOption<ItemT>>);
+  /**
+   * The `value` of the selected option, or `null` when none is selected.
+   */
+  getValue(): Promise<string | null>;
+  /**
+   * Select the option whose radio `<input>` has the given `value`.
+   * @returns `false` when no option has that value, or when `value` is `null`.
+   */
+  setValue(value: string | null): Promise<boolean>;
+  /**
+   * The visible label of every option, in DOM order.
+   */
+  getOptions(): Promise<string[]>;
+  /**
+   * The label of the selected option, or `null` when none is selected.
+   */
+  getSelectedLabel(): Promise<Nullable<string>>;
+  /**
+   * Select the first option whose visible label equals `label`.
+   * @returns `false` when no option matches.
+   */
+  selectByLabel(label: string): Promise<boolean>;
+  /**
+   * Whether the option with the given label is disabled.
+   * @returns `false` when no option matches.
+   */
+  isOptionDisabled(label: string): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/RatingDriver.d.ts
+declare const parts$4: {
+  choices: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLRadioButtonGroupDriver;
+  };
+};
+declare class RatingDriver extends ComponentDriver<typeof parts$4> implements IInputDriver<number | null> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  getValue(): Promise<number | null>;
+  /**
+   * Read the value of a read-only Rating.
+   *
+   * Primary source is the root's `aria-label`, which MUI populates with the accessible
+   * name (e.g. `"2.5 Stars"`) — accessibility-first and precision-accurate. When a
+   * caller supplies a custom, non-numeric `aria-label`, fall back to counting the
+   * filled star icons; that count is exact for whole-star ratings.
+   */
+  private getReadOnlyValue;
+  /**
+   * Whether the Rating is disabled. `disabled` is reflected as the `Mui-disabled`
+   * class on the root span (the composed radio-group driver exposes no `isDisabled`).
+   */
+  isDisabled(): Promise<boolean>;
+  setValue(value: number | null): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/SelectDriver.d.ts
+declare const selectPart: {
+  trigger: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLButtonDriver;
+  };
+  dropdown: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+  input: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLTextInputDriver;
+  };
+  nativeSelect: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLSelectDriver;
+  };
+};
+type SelectScenePart$1 = typeof selectPart;
+interface MenuItemGetOption {
+  /**
+   * When true, the driver will not check if the dropdown is open, which helps speed the process up.
+   */
+  skipDropdownCheck?: boolean;
+}
+declare class SelectDriver extends ComponentDriver<SelectScenePart$1> implements IInputDriver<string | null> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  isNative(): Promise<boolean>;
+  getValue(): Promise<string | null>;
+  setValue(value: string | null): Promise<boolean>;
+  /**
+   * Select menu item by its label, if it exists
+   * Limitation, this method will not work if the dropdown is a native select.
+   * @param label
+   * @returns
+   */
+  getMenuItemByLabel(label: string, option?: MenuItemGetOption): Promise<MenuItemDriver | null>;
+  /**
+   * Selects an option by its label
+   * @param label
+   * @returns
+   */
+  selectByLabel(label: string): Promise<void>;
+  getSelectedLabel(): Promise<string | null>;
+  exists(): Promise<boolean>;
+  /**
+   * Check if the dropdown is open, or if it is a native select, it is always open because there is no known way check its open state
+   * @returns For native dropdown it is always true. For custom dropdown, it is true if the dropdown is open.
+   */
+  isDropdownOpen(): Promise<boolean>;
+  openDropdown(): Promise<void>;
+  closeDropdown(): Promise<void>;
+  isDisabled(): Promise<boolean>;
+  isReadonly(): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/SliderDriver.d.ts
+declare const parts$3: {
+  input: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLTextInputDriver;
+  };
+};
+type SelectScenePart = typeof parts$3;
+declare class SliderDriver extends ComponentDriver<SelectScenePart> implements IInputDriver<number> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  /**
+   * Return the first occurrence of the Slider input
+   * @returns
+   */
+  getValue(): Promise<number>;
+  /**
+   * Set slider's range value.  Do not use as it will throw an error
+   * @param values
+   * @see https://github.com/atomic-testing/atomic-testing/issues/73
+   */
+  setValue(value: number): Promise<boolean>;
+  getRangeValues(count?: number): Promise<readonly number[]>;
+  private getInputLocator;
+  /**
+   * Set slider's range values.  Do not use as it will throw an error
+   * @param values
+   * @see https://github.com/atomic-testing/atomic-testing/issues/73
+   */
+  setRangeValues(_values: readonly number[]): Promise<boolean>;
+  isDisabled(): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/SnackbarDriver.d.ts
+declare const parts$2: {
+  contentDisplay: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+  actionArea: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+};
+/**
+ * Driver for Material UI v9 Snackbar component.
+ * @see https://mui.com/material-ui/react-snackbar/
+ */
+declare class SnackbarDriver extends ComponentDriver<typeof parts$2> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  /**
+   * Get the label content of the snackbar.
+   * @returns The label text content of the snackbar.
+   */
+  getLabel(): Promise<string | null>;
+  /**
+   * Get a driver instance of a component in the action area of the snackbar.
+   * @param locator
+   * @param driverClass
+   * @returns
+   */
+  getActionComponent<ItemClass extends ComponentDriver>(locator: PartLocator, driverClass: ComponentDriverCtor<ItemClass>): Promise<ItemClass | null>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/SpeedDialDriver.d.ts
+/**
+ * Driver for the Material UI v9 SpeedDial component.
+ *
+ * SpeedDial renders a trigger FAB (`.MuiSpeedDial-fab`, `aria-expanded` reflects
+ * open state) and a set of action FABs (`.MuiSpeedDialAction-fab`, each
+ * aria-labelled with its name). The actions stay mounted but are only revealed
+ * when open, so open state is read from the FAB's `aria-expanded` rather than
+ * action presence.
+ * @see https://mui.com/material-ui/react-speed-dial/
+ */
+declare class SpeedDialDriver extends ComponentDriver {
+  private get fab();
+  /**
+   * Whether the speed dial is open (its FAB reports `aria-expanded="true"`).
+   */
+  isOpen(): Promise<boolean>;
+  /**
+   * Open the speed dial by hovering its FAB. No-op when already open.
+   *
+   * Hover (`onMouseEnter`) is the trigger that opens consistently across MUI
+   * versions and browsers — clicking only focuses-then-opens in Chromium, and
+   * focus opens in v7 but not v5, whereas hover opens everywhere.
+   */
+  open(): Promise<void>;
+  /**
+   * Close the speed dial by moving the pointer off its FAB. No-op when already closed.
+   */
+  close(): Promise<void>;
+  /**
+   * The labels of every action, in order (read from each action FAB's aria-label).
+   */
+  getActionLabels(): Promise<string[]>;
+  /**
+   * Trigger the action with the given label, opening the dial first if needed.
+   * @returns `false` when no action has that label.
+   */
+  triggerActionByLabel(label: string): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/StepperDriver.d.ts
+interface StepInfo {
+  /** The step's visible label. */
+  label: Optional<string>;
+  /** Whether this is the active step (MUI marks the label `Mui-active`). */
+  active: boolean;
+  /** Whether the step has been completed (`Mui-completed`). */
+  completed: boolean;
+  /** Whether the step is disabled (`Mui-disabled`). */
+  disabled: boolean;
+}
+/**
+ * Driver for the Material UI v9 Stepper component.
+ *
+ * Each step's state lives on its `.MuiStepLabel-label` (`Mui-active`,
+ * `Mui-completed`, `Mui-disabled`); reading every label's class in one pass gives
+ * the step states and count in document order. Steps are addressed positionally
+ * for label text and clicks via {@link stepLabelAt}/{@link stepButtonAt}.
+ *
+ * Supported layouts: the default horizontal stepper and the vertical orientation.
+ * In v9 every `.MuiStep-root` is a consecutive sibling (the connector lives inside
+ * the step), and every step renders a text label, so positional addressing lines up
+ * with the document-order class list. The unsupported case is icon-only steps, which
+ * render no `.MuiStepLabel-label`; under those the document-order class list has fewer
+ * entries than steps and the two desynchronize. Robustly supporting that needs an
+ * interactor primitive to address the n-th of non-sibling matches
+ * (CSS `:nth-child(of S)` is unsupported in jsdom), which is out of this driver's scope.
+ * @see https://mui.com/material-ui/react-stepper/
+ */
+declare class StepperDriver extends ComponentDriver {
+  private getStepClassList;
+  /**
+   * The number of steps.
+   */
+  getStepCount(): Promise<number>;
+  /**
+   * Zero-based index of the active step, or `-1` when none is active.
+   */
+  getActiveStepIndex(): Promise<number>;
+  /**
+   * Every step with its label and active/completed/disabled state, in order.
+   */
+  getSteps(): Promise<StepInfo[]>;
+  /**
+   * Navigate to the step at `index` by clicking its control (requires a clickable
+   * `StepButton`, e.g. a non-linear stepper).
+   * @returns `false` when the step is out of range, has no button, or is disabled.
+   */
+  goToStep(index: number): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/SwitchDriver.d.ts
+declare const parts$1: {
+  input: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLCheckboxDriver;
+  };
+};
+declare class SwitchDriver extends ComponentDriver<typeof parts$1> implements IFormFieldDriver<string | null>, IToggleDriver {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  exists(): Promise<boolean>;
+  isSelected(): Promise<boolean>;
+  setSelected(selected: boolean): Promise<void>;
+  getValue(): Promise<string | null>;
+  isDisabled(): Promise<boolean>;
+  isReadonly(): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/TableCellDriver.d.ts
+/**
+ * Driver for a single Material UI v9 TableCell (`<td>`/`<th>`, `.MuiTableCell-root`).
+ *
+ * A cell's content is plain text, so it relies on the inherited `getText()`/`exists()`;
+ * it exists as a distinct type so {@link TableRowDriver} can expose typed cell drivers.
+ * @see https://mui.com/material-ui/react-table/
+ */
+declare class TableCellDriver extends ComponentDriver {
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/TableRowDriver.d.ts
+/**
+ * Cells are located by `.MuiTableCell-root`, covering both `<td>` body cells and
+ * `<th>` header cells.
+ */
+declare const defaultTableRowDriverOption: ListComponentDriverSpecificOption<TableCellDriver>;
+type TableRowDriverOption<ItemT extends TableCellDriver> = ListComponentDriverSpecificOption<ItemT> & Partial<IComponentDriverOption<any>>;
+/**
+ * Driver for a single Material UI v9 TableRow (`.MuiTableRow-root`).
+ *
+ * A {@link ListComponentDriver} over the row's cells, exposing per-cell
+ * {@link TableCellDriver}s (via `getItems`/`getItemByIndex`) plus convenience reads
+ * of the cell texts.
+ *
+ * Cells are addressed positionally via `:nth-of-type`, which counts per element type.
+ * This assumes a row's cells are homogeneous (all `<td>`, or all `<th>` for a header
+ * row) — the common MUI rendering. A row mixing a leading `<th scope="row">` with
+ * `<td>` data cells would desynchronize the index (the `<td>`s start at type-index 1
+ * after the `<th>`); such rows are out of scope.
+ * @see https://mui.com/material-ui/react-table/
+ */
+declare class TableRowDriver<ItemT extends TableCellDriver = TableCellDriver> extends ListComponentDriver<ItemT> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<TableRowDriverOption<ItemT>>);
+  /**
+   * The number of cells in the row.
+   */
+  getCellCount(): Promise<number>;
+  /**
+   * The cell driver at the given zero-based column index, or `null` when out of range.
+   */
+  getCell(index: number): Promise<ItemT | null>;
+  /**
+   * The text of every cell, in column order.
+   */
+  getCellTexts(): Promise<string[]>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/TableDriver.d.ts
+/** Reported sort state of a column, mirroring the `aria-sort` values MUI emits. */
+type TableSortDirection = 'ascending' | 'descending';
+/**
+ * Body rows are located under `.MuiTableBody-root`, so header rows are never
+ * mistaken for data rows.
+ */
+declare const defaultTableDriverOption: ListComponentDriverSpecificOption<TableRowDriver>;
+type TableDriverOption<ItemT extends TableRowDriver> = ListComponentDriverSpecificOption<ItemT> & Partial<IComponentDriverOption<any>>;
+/**
+ * Driver for the Material UI v9 Table component.
+ *
+ * A {@link ListComponentDriver} over the data rows (`.MuiTableBody-root > .MuiTableRow-root`),
+ * exposing per-row {@link TableRowDriver}s plus header reads and column sort state.
+ * Locators key off MUI's structural classes (`MuiTableHead/Body/Row/Cell-root`),
+ * which are stable across v9. Sort state is read from the header cell's `aria-sort`
+ * and driven by clicking its `TableSortLabel`.
+ * @see https://mui.com/material-ui/react-table/
+ */
+declare class TableDriver<ItemT extends TableRowDriver = TableRowDriver> extends ListComponentDriver<ItemT> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<TableDriverOption<ItemT>>);
+  /**
+   * The number of data (body) rows.
+   */
+  getRowCount(): Promise<number>;
+  /**
+   * The data-row driver at the given zero-based index, or `null` when out of range.
+   */
+  getRow(index: number): Promise<ItemT | null>;
+  /**
+   * The header row as a {@link TableRowDriver}, or `null` when the table has no header.
+   */
+  getHeaderRow(): Promise<TableRowDriver | null>;
+  /**
+   * The number of columns, derived from the header cell count (0 when no header).
+   */
+  getColumnCount(): Promise<number>;
+  /**
+   * The header cell texts, in column order (empty when no header).
+   */
+  getHeaderTexts(): Promise<string[]>;
+  /**
+   * The text of the data cell at the given row/column, or `undefined` when either
+   * index is out of range.
+   */
+  getCellText(rowIndex: number, columnIndex: number): Promise<Optional<string>>;
+  /**
+   * The sort direction applied to the column at `columnIndex`, read from the header
+   * cell's `aria-sort`, or `undefined` when that column is not the sorted one.
+   */
+  getSortDirection(columnIndex: number): Promise<Optional<TableSortDirection>>;
+  /**
+   * Toggle/apply sorting on the column at `columnIndex` by clicking its
+   * `TableSortLabel`.
+   * @returns `false` when the column has no sort control.
+   */
+  sortByColumn(columnIndex: number): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/TablePaginationDriver.d.ts
+/**
+ * Driver for the Material UI v9 TablePagination component.
+ *
+ * TablePagination is a composite: a "rows per page" MUI Select (a portal-backed
+ * `role="combobox"`), an aria-labelled previous/next pair that disables at the
+ * bounds, and a `.MuiTablePagination-displayedRows` label ("1–5 of 13"). The
+ * rows-per-page control is delegated to {@link SelectDriver} rather than
+ * reimplemented — the driver's own root contains exactly one combobox/input, so
+ * SelectDriver scoped to that root resolves it unambiguously.
+ * @see https://mui.com/material-ui/react-pagination/#table-pagination
+ */
+declare class TablePaginationDriver extends ComponentDriver {
+  private get rowsPerPageSelect();
+  /**
+   * The current rows-per-page value (read from the select's hidden input), or
+   * `-1` when it cannot be parsed.
+   */
+  getRowsPerPage(): Promise<number>;
+  /**
+   * Choose a rows-per-page value by opening the select and picking the option.
+   * @returns `false` when no such option exists.
+   */
+  setRowsPerPage(rowsPerPage: number): Promise<boolean>;
+  /**
+   * The raw "displayed rows" label (e.g. "1–5 of 13"), or `undefined` when absent.
+   * Returned verbatim because its exact format (separator, "of") is locale-defined.
+   */
+  getDisplayedRowsText(): Promise<Optional<string>>;
+  /** Whether the previous-page control is disabled (i.e. on the first page). */
+  isPreviousDisabled(): Promise<boolean>;
+  /** Whether the next-page control is disabled (i.e. on the last page). */
+  isNextDisabled(): Promise<boolean>;
+  /**
+   * An absent control counts as disabled — both to stay consistent with
+   * {@link clickNavButton} (which reports a no-op for a missing control) and
+   * because Playwright's `isDisabled` throws on a zero-match locator rather than
+   * returning false the way jsdom does.
+   */
+  private isNavDisabled;
+  /**
+   * Advance to the next page unless the control is disabled (last page).
+   * @returns whether the click was performed.
+   */
+  nextPage(): Promise<boolean>;
+  /**
+   * Go back to the previous page unless the control is disabled (first page).
+   * @returns whether the click was performed.
+   */
+  previousPage(): Promise<boolean>;
+  private clickNavButton;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/TabDriver.d.ts
+/**
+ * Driver for a single Material UI v9 Tab.
+ *
+ * A `<Tab>` renders as a `<button role="tab">`; MUI marks the active one with
+ * `aria-selected="true"` and renders a real `disabled` button when disabled, so
+ * selection and disabled state are read straight off the accessible attributes
+ * (`isDisabled` is inherited from {@link HTMLButtonDriver}; `getText`/`click` from
+ * the base `ComponentDriver`).
+ *
+ * Unlike a toggle button this is intentionally not an `IToggleDriver`: a tab can
+ * be selected but not toggled off (selecting another tab deselects it), so only
+ * `isSelected`/`select` are exposed.
+ * @see https://mui.com/material-ui/react-tabs/
+ */
+declare class TabDriver extends HTMLButtonDriver {
+  /**
+   * Whether this tab is the selected one, i.e. MUI set `aria-selected="true"`.
+   */
+  isSelected(): Promise<boolean>;
+  /**
+   * Activate this tab by clicking it, unless it is already selected. A selected
+   * tab cannot be toggled off, so this is a no-op when already active.
+   */
+  select(): Promise<void>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/TabsDriver.d.ts
+/**
+ * Tabs are located by their accessible `role="tab"` children rather than by MUI
+ * class names, so the driver is resilient to MUI styling/version changes.
+ */
+declare const defaultTabsDriverOption: ListComponentDriverSpecificOption<TabDriver>;
+type TabsDriverOption<ItemT extends TabDriver> = ListComponentDriverSpecificOption<ItemT> & Partial<IComponentDriverOption<any>>;
+/**
+ * Driver for the Material UI v9 Tabs component.
+ *
+ * `<Tabs>` renders a `role="tablist"` whose `role="tab"` buttons carry the
+ * selected (`aria-selected`) and disabled state. This driver is a
+ * {@link ListComponentDriver} over those tabs, exposing both group-level helpers
+ * (selected index/label, select by index/label) and per-tab {@link TabDriver}
+ * instances via `getItems`/`getItemByIndex`/`getItemByLabel`.
+ * @see https://mui.com/material-ui/react-tabs/
+ */
+declare class TabsDriver<ItemT extends TabDriver = TabDriver> extends ListComponentDriver<ItemT> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<TabsDriverOption<ItemT>>);
+  /**
+   * The visible label of every tab, in DOM order.
+   */
+  getTabLabels(): Promise<string[]>;
+  /**
+   * The number of tabs in the group.
+   */
+  getTabCount(): Promise<number>;
+  /**
+   * Zero-based index of the selected tab, or `-1` when no tab is selected
+   * (e.g. `<Tabs value={false}>`).
+   */
+  getSelectedIndex(): Promise<number>;
+  /**
+   * Label of the selected tab, or `null` when no tab is selected. Returns `null`
+   * (not `undefined`) to match the sibling `SelectDriver.getSelectedLabel` contract.
+   */
+  getSelectedLabel(): Promise<Nullable<string>>;
+  /**
+   * Select the tab at the given zero-based index.
+   * @returns `false` when the index is out of range.
+   */
+  selectByIndex(index: number): Promise<boolean>;
+  /**
+   * Select the first tab whose visible label equals `label`.
+   * @returns `false` when no tab matches.
+   */
+  selectByLabel(label: string): Promise<boolean>;
+  /**
+   * Whether the tab at the given index is disabled.
+   * @returns `false` when the index is out of range.
+   */
+  isTabDisabled(index: number): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/TextFieldDriver.d.ts
+declare const parts: {
+  label: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+  helperText: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+  singlelineInput: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLTextInputDriver;
+  };
+  multilineInput: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLTextInputDriver;
+  };
+  selectInput: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof SelectDriver;
+  };
+  richSelectInputDetect: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+  nativeSelectInputDetect: {
+    locator: import("@atomic-testing/core").CssLocator;
+    driver: typeof HTMLElementDriver;
+  };
+};
+/**
+ * A driver for the Material UI v9 TextField component with single line or multiline text input.
+ */
+declare class TextFieldDriver extends ComponentDriver<typeof parts> implements IInputDriver<string | null> {
+  constructor(locator: PartLocator, interactor: Interactor, option?: Partial<IComponentDriverOption>);
+  private getInputType;
+  getValue(): Promise<string | null>;
+  setValue(value: string | null): Promise<boolean>;
+  getLabel(): Promise<Optional<string>>;
+  getHelperText(): Promise<Optional<string>>;
+  isDisabled(): Promise<boolean>;
+  isReadonly(): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/ToggleButtonDriver.d.ts
+declare class ToggleButtonDriver extends ButtonDriver implements IToggleDriver {
+  isSelected(): Promise<boolean>;
+  setSelected(targetState: boolean): Promise<void>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/ToggleButtonGroupDriver.d.ts
+declare class ToggleButtonGroupDriver extends ComponentDriver implements IInputDriver<readonly string[]> {
+  protected itemLocator: import("@atomic-testing/core").PartLocator;
+  /**
+   * Get all the selected toggle buttons' values.
+   * @returns
+   */
+  getValue(): Promise<readonly string[]>;
+  /**
+   * Toggle all the toggle buttons such that only those with value in the given array are selected.
+   * @param value Always true
+   * @returns
+   */
+  setValue(value: readonly string[]): Promise<boolean>;
+  get driverName(): string;
+}
+/**
+ * A toggle button group driver that only allows a single selection.
+ *
+ * INTENTIONAL @ts-ignore comments below: This class intentionally narrows the return type
+ * from `readonly string[]` to `string | null` for exclusive selection mode. TypeScript
+ * correctly flags this as a type incompatibility because the subclass changes the interface
+ * contract. However, this design is intentional as exclusive and multi-select toggle groups
+ * have fundamentally different value semantics, and we want the type system to reflect
+ * `string | null` for exclusive mode rather than forcing consumers to work with arrays.
+ */
+declare class ExclusiveToggleButtonGroupDriver extends ToggleButtonGroupDriver implements IInputDriver<string | null> {
+  getValue(): Promise<string | null>;
+  setValue(value: string | null): Promise<boolean>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/components/TooltipDriver.d.ts
+/**
+ * Driver for the Material UI v9 Tooltip component.
+ *
+ * The driver is rooted at the **trigger** element. MUI shows the tooltip on
+ * hover/focus and renders it into a portal (a `role="tooltip"` popper) outside the
+ * trigger's subtree, so the text is read from the document root via
+ * {@link tooltipLocator} after revealing it. The tooltip unmounts when not shown,
+ * so presence of that element doubles as the visible state.
+ *
+ * Note: hover reveal depends on the tooltip's `enterDelay`; with a non-zero delay
+ * the reveal is timer-bound. {@link getTitle} waits for the tooltip to appear.
+ * @see https://mui.com/material-ui/react-tooltip/
+ */
+declare class TooltipDriver extends ComponentDriver {
+  /**
+   * Reveal the tooltip by hovering its trigger, waiting until it is shown (or the
+   * timeout elapses, e.g. when the trigger has no tooltip).
+   */
+  show(timeoutMs?: number): Promise<void>;
+  /**
+   * Hide the tooltip by moving the pointer off its trigger, waiting until it is gone.
+   */
+  hide(timeoutMs?: number): Promise<void>;
+  /**
+   * Whether a tooltip is currently shown.
+   */
+  isVisible(): Promise<boolean>;
+  /**
+   * Reveal the tooltip, read its text, then restore the un-hovered state. Returns
+   * `undefined` when the trigger has no tooltip (none appears within the timeout).
+   *
+   * The hover is undone before returning so a subsequent read on a *different*
+   * trigger isn't shadowed by this still-open tooltip: MUI renders all tooltips into
+   * one portal and provides no per-trigger DOM link, and jsdom's synthetic hover does
+   * not fire `mouseout` on the previously-hovered sibling.
+   *
+   * @param timeoutMs How long to wait for the tooltip to appear after hovering.
+   */
+  getTitle(timeoutMs?: number): Promise<Optional<string>>;
+  get driverName(): string;
+}
+//#endregion
+//#region src/errors/MenuItemDisabledError.d.ts
+declare const MenuItemDisabledErrorId = "MenuItemDisabledError";
+declare class MenuItemDisabledError extends ErrorBase {
+  readonly label: string;
+  readonly driver: ComponentDriver<any>;
+  constructor(label: string, driver: ComponentDriver<any>);
+}
+//#endregion
+//#region src/errors/MenuItemNotFoundError.d.ts
+declare const MenuItemNotFoundErrorId = "MenuItemNotFoundError";
+declare class MenuItemNotFoundError extends ErrorBase {
+  readonly label: string;
+  readonly driver: ComponentDriver<any>;
+  constructor(label: string, driver: ComponentDriver<any>);
+}
+//#endregion
+export { AccordionDriver, AlertDriver, AutoCompleteDriver, type AutoCompleteDriverOption, type AutoCompleteDriverSpecificOption, type AutoCompleteMatchType, AvatarDriver, AvatarGroupDriver, BadgeDriver, BottomNavigationActionDriver, type BottomNavigationActionInfo, BottomNavigationDriver, ButtonDriver, CheckboxDriver, ChipDriver, DialogDriver, type DrawerAnchor, DrawerDriver, ExclusiveToggleButtonGroupDriver, FabDriver, InputDriver, ListDriver, ListItemDriver, MenuDriver, MenuItemDisabledError, MenuItemDisabledErrorId, MenuItemDriver, MenuItemNotFoundError, MenuItemNotFoundErrorId, OverlayDriver, PaginationDriver, ProgressDriver, RadioDriver, RadioGroupDriver, RatingDriver, SelectDriver, SliderDriver, SnackbarDriver, SpeedDialDriver, type StepInfo, StepperDriver, SwitchDriver, TabDriver, TableCellDriver, TableDriver, TablePaginationDriver, TableRowDriver, type TableSortDirection, TabsDriver, TextFieldDriver, ToggleButtonDriver, ToggleButtonGroupDriver, TooltipDriver, defaultAutoCompleteDriverOption, defaultAvatarGroupDriverOption, defaultRadioGroupDriverOption, defaultTableDriverOption, defaultTableRowDriverOption, defaultTabsDriverOption, drawerParts };
+//# sourceMappingURL=index.d.mts.map