@react-aria/test-utils 1.0.0-alpha.3 → 1.0.0-alpha.4

package/dist/types.d.ts

@@ -1,163 +1,630 @@
 import { pointerKey } from "@testing-library/user-event/system/pointer/shared";
-interface ComboBoxOptions extends UserOpts, BaseTesterOpts {
+type Direction = 'ltr' | 'rtl';
+export interface UserOpts {
+    /**
+     * The interaction type (mouse, touch, keyboard) that the test util user will use when interacting with a component. This can be overridden
+     * at the aria pattern tester level if needed.
+     * @default mouse
+     */
+    interactionType?: 'mouse' | 'touch' | 'keyboard';
+    /**
+     * A function used by the test utils to advance timers during interactions. Required for certain aria patterns (e.g. table). This can be overridden
+     * at the aria pattern tester level if needed.
+     */
+    advanceTimer?: (time?: number) => void | Promise<unknown>;
+}
+interface BaseTesterOpts extends UserOpts {
+    /** @private */
     user?: any;
+    /** The base element for the given tester (e.g. the table, menu trigger button, etc). */
+    root: HTMLElement;
+}
+interface ComboBoxTesterOpts extends BaseTesterOpts {
+    /**
+     * The base element for the combobox. If provided the wrapping element around the target combobox (as is the the case with a ref provided to RSP ComboBox),
+     * will automatically search for the combobox element within.
+     */
+    root: HTMLElement;
+    /**
+     * The node of the combobox trigger button if any. If not provided, we will try to automatically use any button
+     * within the `root` provided or that the `root` serves as the trigger.
+     */
     trigger?: HTMLElement;
 }
+interface GridListTesterOpts extends BaseTesterOpts {
+}
+interface ListBoxTesterOpts extends BaseTesterOpts {
+    /**
+     * A function used by the test utils to advance timers during interactions.
+     */
+    advanceTimer?: UserOpts['advanceTimer'];
+}
+interface MenuTesterOpts extends BaseTesterOpts {
+    /**
+     * The trigger element for the menu.
+     */
+    root: HTMLElement;
+    /**
+     * Whether the current menu is a submenu.
+     */
+    isSubmenu?: boolean;
+}
+interface SelectTesterOpts extends BaseTesterOpts {
+    /**
+     * The trigger element for the select. If provided the wrapping element around the target select (as is the case with a ref provided to RSP Select),
+     * will automatically search for the select's trigger element within.
+     */
+    root: HTMLElement;
+}
+interface TableTesterOpts extends BaseTesterOpts {
+    /**
+     * A function used by the test utils to advance timers during interactions.
+     */
+    advanceTimer?: UserOpts['advanceTimer'];
+}
+interface TabsTesterOpts extends BaseTesterOpts {
+    /**
+     * The horizontal layout direction, typically affected by locale.
+     * @default 'ltr'
+     */
+    direction?: Direction;
+}
+interface TreeTesterOpts extends BaseTesterOpts {
+    /**
+     * A function used by the test utils to advance timers during interactions.
+     */
+    advanceTimer?: UserOpts['advanceTimer'];
+}
+interface BaseGridRowInteractionOpts {
+    /**
+     * The index, text, or node of the row to target.
+     */
+    row: number | string | HTMLElement;
+    /**
+     * What interaction type to use when interacting with the row. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+}
+interface ToggleGridRowOpts extends BaseGridRowInteractionOpts {
+    /**
+     * Whether the row needs to be long pressed to be selected. Depends on the components implementation.
+     */
+    needsLongPress?: boolean;
+    /**
+     * Whether the checkbox should be used to select the row. If false, will attempt to select the row via press.
+     * @default 'true'
+     */
+    checkboxSelection?: boolean;
+}
+interface GridRowActionOpts extends BaseGridRowInteractionOpts {
+    /**
+     * Whether or not the row needs a double click to trigger the row action. Depends on the components implementation.
+     */
+    needsDoubleClick?: boolean;
+}
+/**
+ * Simulates a "long press" event on a element.
+ * @param opts - Options for the long press.
+ * @param opts.element - Element to long press.
+ * @param opts.advanceTimer - Function that when called advances the timers in your test suite by a specific amount of time(ms).
+ * @param opts.pointeropts - Options to pass to the simulated event. Defaults to mouse. See https://testing-library.com/docs/dom-testing-library/api-events/#fireevent for more info.
+ */
+export function triggerLongPress(opts: {
+    element: HTMLElement;
+    advanceTimer: (time?: number) => void | Promise<unknown>;
+    pointerOpts?: {};
+}): Promise<void>;
+/**
+ * Enables reading pageX/pageY from fireEvent.mouse*(..., {pageX: ..., pageY: ...}).
+ */
+export function installMouseEvent(): void;
+export function installPointerEvent(): void;
+export let pointerMap: pointerKey[];
+interface ComboBoxOpenOpts {
+    /**
+     * Whether the combobox opens on focus or needs to be manually opened via user action.
+     * @default 'manual'
+     */
+    triggerBehavior?: 'focus' | 'manual';
+    /**
+     * What interaction type to use when opening the combobox. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+}
+interface ComboBoxSelectOpts extends ComboBoxOpenOpts {
+    /**
+     * The index, text, or node of the option to select. Option nodes can be sourced via `options()`.
+     */
+    option: number | string | HTMLElement;
+}
 declare class ComboBoxTester {
-    constructor(opts: ComboBoxOptions);
-    setInteractionType: (type: UserOpts["interactionType"]) => void;
-    open: (opts?: {
-        triggerBehavior?: "focus" | "manual";
-        interactionType?: UserOpts["interactionType"];
-    }) => Promise<void>;
-    selectOption: (opts?: {
-        option?: HTMLElement;
-        optionText?: string;
-        triggerBehavior?: "focus" | "manual";
-        interactionType?: UserOpts["interactionType"];
-    }) => Promise<void>;
-    close: () => Promise<void>;
+    constructor(opts: ComboBoxTesterOpts);
+    /**
+     * Set the interaction type used by the combobox tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Opens the combobox dropdown. Defaults to using the interaction type set on the combobox tester.
+     */
+    open(opts?: ComboBoxOpenOpts): Promise<void>;
+    /**
+     * Returns an option matching the specified index or text content.
+     */
+    findOption(opts: {
+        optionIndexOrText: number | string;
+    }): HTMLElement;
+    /**
+     * Selects the desired combobox option. Defaults to using the interaction type set on the combobox tester. If necessary, will open the combobox dropdown beforehand.
+     * The desired option can be targeted via the option's node, the option's text, or the option's index.
+     */
+    selectOption(opts: ComboBoxSelectOpts): Promise<void>;
+    /**
+     * Closes the combobox dropdown.
+     */
+    close(): Promise<void>;
+    /**
+     * Returns the combobox.
+     */
     get combobox(): HTMLElement;
-    get trigger(): HTMLElement | undefined;
-    get listbox(): HTMLElement | undefined;
-    options: (opts?: {
-        element?: HTMLElement;
-    }) => HTMLElement[] | never[];
+    /**
+     * Returns the combobox trigger button.
+     */
+    get trigger(): HTMLElement;
+    /**
+     * Returns the combobox's listbox if present.
+     */
+    get listbox(): HTMLElement | null;
+    /**
+     * Returns the combobox's sections if present.
+     */
     get sections(): HTMLElement[];
-    get focusedOption(): HTMLElement | null | undefined;
+    /**
+     * Returns the combobox's options if present. Can be filtered to a subsection of the listbox if provided via `element`.
+     */
+    options(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+    /**
+     * Returns the currently focused option in the combobox's dropdown if any.
+     */
+    get focusedOption(): HTMLElement | null;
 }
-interface GridListOptions extends UserOpts, BaseTesterOpts {
-    user?: any;
+interface GridListToggleRowOpts extends ToggleGridRowOpts {
+}
+interface GridListRowActionOpts extends GridRowActionOpts {
 }
 declare class GridListTester {
-    constructor(opts: GridListOptions);
-    setInteractionType: (type: UserOpts["interactionType"]) => void;
-    toggleRowSelection: (opts?: {
-        index?: number;
-        text?: string;
-        interactionType?: UserOpts["interactionType"];
-    }) => Promise<void>;
-    findRow: (opts: {
-        index?: number;
-        text?: string;
-    }) => any;
-    triggerRowAction: (opts: {
-        index?: number;
-        text?: string;
-        needsDoubleClick?: boolean;
-        interactionType?: UserOpts["interactionType"];
-    }) => Promise<void>;
+    constructor(opts: GridListTesterOpts);
+    /**
+     * Set the interaction type used by the gridlist tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Returns a row matching the specified index or text content.
+     */
+    findRow(opts: {
+        rowIndexOrText: number | string;
+    }): HTMLElement;
+    /**
+     * Toggles the selection for the specified gridlist row. Defaults to using the interaction type set on the gridlist tester.
+     */
+    toggleRowSelection(opts: GridListToggleRowOpts): Promise<void>;
+    /**
+     * Triggers the action for the specified gridlist row. Defaults to using the interaction type set on the gridlist tester.
+     */
+    triggerRowAction(opts: GridListRowActionOpts): Promise<void>;
+    /**
+     * Returns the gridlist.
+     */
     get gridlist(): HTMLElement;
+    /**
+     * Returns the gridlist's rows if any.
+     */
     get rows(): HTMLElement[];
+    /**
+     * Returns the gridlist's selected rows if any.
+     */
     get selectedRows(): HTMLElement[];
-    cells: (opts?: {
+    /**
+     * Returns the gridlist's cells if any. Can be filtered against a specific row if provided via `element`.
+     */
+    cells(opts?: {
         element?: HTMLElement;
-    }) => HTMLElement[];
+    }): HTMLElement[];
 }
-interface MenuOptions extends UserOpts, BaseTesterOpts {
-    user?: any;
-    isSubmenu?: boolean;
+interface ListBoxToggleOptionOpts {
+    /**
+     * What interaction type to use when toggling selection for an option. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+    /**
+     * The index, text, or node of the option to toggle selection for.
+     */
+    option: number | string | HTMLElement;
+    /**
+     * Whether the option should be triggered by Space or Enter in keyboard modality.
+     * @default 'Enter'
+     */
+    keyboardActivation?: 'Space' | 'Enter';
+    /**
+     * Whether the option needs to be long pressed to be selected. Depends on the listbox's implementation.
+     */
+    needsLongPress?: boolean;
+}
+interface ListBoxOptionActionOpts extends Omit<ListBoxToggleOptionOpts, 'keyboardActivation' | 'needsLongPress'> {
+    /**
+     * Whether or not the option needs a double click to trigger the option action. Depends on the listbox's implementation.
+     */
+    needsDoubleClick?: boolean;
+}
+declare class ListBoxTester {
+    constructor(opts: ListBoxTesterOpts);
+    /**
+     * Set the interaction type used by the listbox tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Returns a option matching the specified index or text content.
+     */
+    findOption(opts: {
+        optionIndexOrText: number | string;
+    }): HTMLElement;
+    /**
+     * Toggles the selection for the specified listbox option. Defaults to using the interaction type set on the listbox tester.
+     */
+    toggleOptionSelection(opts: ListBoxToggleOptionOpts): Promise<void>;
+    /**
+     * Triggers the action for the specified listbox option. Defaults to using the interaction type set on the listbox tester.
+     */
+    triggerOptionAction(opts: ListBoxOptionActionOpts): Promise<void>;
+    /**
+     * Returns the listbox.
+     */
+    get listbox(): HTMLElement;
+    /**
+     * Returns the listbox options. Can be filtered to a subsection of the listbox if provided via `element`.
+     */
+    options(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+    /**
+     * Returns the listbox's selected options if any.
+     */
+    get selectedOptions(): HTMLElement[];
+    /**
+     * Returns the listbox's sections if any.
+     */
+    get sections(): HTMLElement[];
+}
+interface MenuOpenOpts {
+    /**
+     * Whether the menu needs to be long pressed to open.
+     */
+    needsLongPress?: boolean;
+    /**
+     * What interaction type to use when opening the menu. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+    /**
+     * Whether to open the menu via ArrowUp or ArrowDown if in keyboard modality.
+     */
+    direction?: 'up' | 'down';
+}
+interface MenuSelectOpts extends MenuOpenOpts {
+    /**
+     * The index, text, or node of the option to select. Option nodes can be sourced via `options()`.
+     */
+    option: number | string | HTMLElement;
+    /**
+     * The menu's selection mode. Will affect whether or not the menu is expected to be closed upon option selection.
+     * @default 'single'
+     */
+    menuSelectionMode?: 'single' | 'multiple';
+    /**
+     * Whether or not the menu closes on select. Depends on menu implementation and configuration.
+     * @default true
+     */
+    closesOnSelect?: boolean;
+    /**
+     * Whether the option should be triggered by Space or Enter in keyboard modality.
+     * @default 'Enter'
+     */
+    keyboardActivation?: 'Space' | 'Enter';
+}
+interface MenuOpenSubmenuOpts extends MenuOpenOpts {
+    /**
+     * The text or node of the submenu trigger to open. Available submenu trigger nodes can be sourced via `submenuTriggers`.
+     */
+    submenuTrigger: string | HTMLElement;
 }
 declare class MenuTester {
-    constructor(opts: MenuOptions);
-    setInteractionType: (type: UserOpts["interactionType"]) => void;
-    open: (opts?: {
-        needsLongPress?: boolean;
-        interactionType?: UserOpts["interactionType"];
-        direction?: "up" | "down";
-    }) => Promise<void>;
-    selectOption: (opts: {
-        option?: HTMLElement;
-        optionText?: string;
-        menuSelectionMode?: "single" | "multiple";
-        needsLongPress?: boolean;
-        closesOnSelect?: boolean;
-        interactionType?: UserOpts["interactionType"];
-        keyboardActivation?: "Space" | "Enter";
-    }) => Promise<void>;
-    openSubmenu: (opts: {
-        submenuTrigger?: HTMLElement;
-        submenuTriggerText?: string;
-        needsLongPress?: boolean;
-        interactionType?: UserOpts["interactionType"];
-    }) => Promise<MenuTester | null>;
-    keyboardNavigateToOption: (opts: {
-        option: HTMLElement;
-    }) => Promise<void>;
-    close: () => Promise<void>;
+    constructor(opts: MenuTesterOpts);
+    /**
+     * Set the interaction type used by the menu tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Opens the menu. Defaults to using the interaction type set on the menu tester.
+     */
+    open(opts?: MenuOpenOpts): Promise<void>;
+    /**
+     * Returns a option matching the specified index or text content.
+     */
+    findOption(opts: {
+        optionIndexOrText: number | string;
+    }): HTMLElement;
+    /**
+     * Selects the desired menu option. Defaults to using the interaction type set on the menu tester. If necessary, will open the menu dropdown beforehand.
+     * The desired option can be targeted via the option's node, the option's text, or the option's index.
+     */
+    selectOption(opts: MenuSelectOpts): Promise<void>;
+    /**
+     * Opens the submenu. Defaults to using the interaction type set on the menu tester. The submenu trigger can be targeted via the trigger's node or the trigger's text.
+     */
+    openSubmenu(opts: MenuOpenSubmenuOpts): Promise<MenuTester | null>;
+    /**
+     * Closes the menu.
+     */
+    close(): Promise<void>;
+    /**
+     * Returns the menu's trigger.
+     */
     get trigger(): HTMLElement;
-    get menu(): HTMLElement | null | undefined;
-    get options(): HTMLElement[];
+    /**
+     * Returns the menu if present.
+     */
+    get menu(): HTMLElement | null;
+    /**
+     * Returns the menu's sections if any.
+     */
     get sections(): HTMLElement[];
+    /**
+     * Returns the menu's options if present. Can be filtered to a subsection of the menu if provided via `element`.
+     */
+    options(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+    /**
+     * Returns the menu's submenu triggers if any.
+     */
     get submenuTriggers(): HTMLElement[];
 }
-interface SelectOptions extends UserOpts, BaseTesterOpts {
-    user?: any;
+interface SelectOpenOpts {
+    /**
+     * What interaction type to use when opening the select. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+}
+interface SelectTriggerOptionOpts extends SelectOpenOpts {
+    /**
+     * The index, text, or node of the option to select. Option nodes can be sourced via `options()`.
+     */
+    option: number | string | HTMLElement;
 }
 declare class SelectTester {
-    constructor(opts: SelectOptions);
-    setInteractionType: (type: UserOpts["interactionType"]) => void;
-    open: (opts?: {
-        interactionType?: UserOpts["interactionType"];
-    }) => Promise<void>;
-    selectOption: (opts: {
-        optionText: string;
-        interactionType?: UserOpts["interactionType"];
-    }) => Promise<void>;
-    close: () => Promise<void>;
+    constructor(opts: SelectTesterOpts);
+    /**
+     * Set the interaction type used by the select tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Opens the select. Defaults to using the interaction type set on the select tester.
+     */
+    open(opts?: SelectOpenOpts): Promise<void>;
+    /**
+     * Closes the select.
+     */
+    close(): Promise<void>;
+    /**
+     * Returns a option matching the specified index or text content.
+     */
+    findOption(opts: {
+        optionIndexOrText: number | string;
+    }): HTMLElement;
+    /**
+     * Selects the desired select option. Defaults to using the interaction type set on the select tester. If necessary, will open the select dropdown beforehand.
+     * The desired option can be targeted via the option's node, the option's text, or the option's index.
+     */
+    selectOption(opts: SelectTriggerOptionOpts): Promise<void>;
+    /**
+     * Returns the select's options if present. Can be filtered to a subsection of the listbox if provided via `element`.
+     */
+    options(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+    /**
+     * Returns the select's trigger.
+     */
     get trigger(): HTMLElement;
-    get listbox(): HTMLElement | null | undefined;
-    get options(): HTMLElement[];
+    /**
+     * Returns the select's listbox if present.
+     */
+    get listbox(): HTMLElement | null;
+    /**
+     * Returns the select's sections if present.
+     */
     get sections(): HTMLElement[];
 }
-interface TableOptions extends UserOpts, BaseTesterOpts {
-    user?: any;
-    advanceTimer: UserOpts['advanceTimer'];
+interface TableToggleRowOpts extends ToggleGridRowOpts {
+}
+interface TableToggleSortOpts {
+    /**
+     * The index, text, or node of the column to toggle selection for.
+     */
+    column: number | string | HTMLElement;
+    /**
+     * What interaction type to use when sorting the column. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+}
+interface TableRowActionOpts extends GridRowActionOpts {
 }
 declare class TableTester {
-    constructor(opts: TableOptions);
-    setInteractionType: (type: UserOpts["interactionType"]) => void;
-    toggleRowSelection: (opts?: {
-        index?: number;
-        text?: string;
-        needsLongPress?: boolean;
-        interactionType?: UserOpts["interactionType"];
-    }) => Promise<void>;
-    toggleSort: (opts?: {
-        index?: number;
-        text?: string;
-        interactionType?: UserOpts["interactionType"];
-    }) => Promise<void>;
-    triggerRowAction: (opts?: {
-        index?: number;
-        text?: string;
-        needsDoubleClick?: boolean;
-        interactionType?: UserOpts["interactionType"];
-    }) => Promise<void>;
-    toggleSelectAll: (opts?: {
-        interactionType?: UserOpts["interactionType"];
-    }) => Promise<void>;
-    findRow: (opts?: {
-        index?: number;
-        text?: string;
-    }) => any;
-    findCell: (opts: {
+    constructor(opts: TableTesterOpts);
+    /**
+     * Set the interaction type used by the table tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Toggles the selection for the specified table row. Defaults to using the interaction type set on the table tester.
+     */
+    toggleRowSelection(opts: TableToggleRowOpts): Promise<void>;
+    /**
+     * Toggles the sort order for the specified table column. Defaults to using the interaction type set on the table tester.
+     */
+    toggleSort(opts: TableToggleSortOpts): Promise<void>;
+    /**
+     * Triggers the action for the specified table row. Defaults to using the interaction type set on the table tester.
+     */
+    triggerRowAction(opts: TableRowActionOpts): Promise<void>;
+    /**
+     * Toggle selection for all rows in the table. Defaults to using the interaction type set on the table tester.
+     */
+    toggleSelectAll(opts?: {
+        interactionType?: UserOpts['interactionType'];
+    }): Promise<void>;
+    /**
+     * Returns a row matching the specified index or text content.
+     */
+    findRow(opts: {
+        rowIndexOrText: number | string;
+    }): HTMLElement;
+    /**
+     * Returns a cell matching the specified text content.
+     */
+    findCell(opts: {
         text: string;
-    }) => HTMLElement;
+    }): HTMLElement;
+    /**
+     * Returns the table.
+     */
     get table(): HTMLElement;
+    /**
+     * Returns the row groups within the table.
+     */
     get rowGroups(): HTMLElement[];
+    /**
+     * Returns the columns within the table.
+     */
     get columns(): HTMLElement[];
+    /**
+     * Returns the rows within the table if any.
+     */
     get rows(): HTMLElement[];
+    /**
+     * Returns the currently selected rows within the table if any.
+     */
     get selectedRows(): HTMLElement[];
+    /**
+     * Returns the row headers within the table if any.
+     */
     get rowHeaders(): HTMLElement[];
-    get cells(): HTMLElement[];
+    /**
+     * Returns the cells within the table if any. Can be filtered against a specific row if provided via `element`.
+     */
+    cells(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
 }
-export interface UserOpts {
-    interactionType?: 'mouse' | 'touch' | 'keyboard';
-    advanceTimer?: (time?: number) => void | Promise<unknown>;
+interface TriggerTabOptions {
+    /**
+     * What interaction type to use when triggering a tab. Defaults to the interaction type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+    /**
+     * The index, text, or node of the tab to toggle selection for.
+     */
+    tab: number | string | HTMLElement;
+    /**
+     * Whether the tab needs to be activated manually rather than on focus.
+     */
+    manualActivation?: boolean;
 }
-interface BaseTesterOpts {
-    root: HTMLElement;
+declare class TabsTester {
+    constructor(opts: TabsTesterOpts);
+    /**
+     * Set the interaction type used by the tabs tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Returns a tab matching the specified index or text content.
+     */
+    findTab(opts: {
+        tabIndexOrText: number | string;
+    }): HTMLElement;
+    /**
+     * Triggers the specified tab. Defaults to using the interaction type set on the tabs tester.
+     */
+    triggerTab(opts: TriggerTabOptions): Promise<void>;
+    /**
+     * Returns the tablist.
+     */
+    get tablist(): HTMLElement;
+    /**
+     * Returns the tabpanels.
+     */
+    get tabpanels(): HTMLElement[];
+    /**
+     * Returns the tabs in the tablist.
+     */
+    get tabs(): HTMLElement[];
+    /**
+     * Returns the currently selected tab in the tablist if any.
+     */
+    get selectedTab(): HTMLElement | null;
+    /**
+     * Returns the currently active tabpanel if any.
+     */
+    get activeTabpanel(): HTMLElement | null;
+}
+interface TreeToggleExpansionOpts extends BaseGridRowInteractionOpts {
+}
+interface TreeToggleRowOpts extends ToggleGridRowOpts {
+}
+interface TreeRowActionOpts extends GridRowActionOpts {
+}
+declare class TreeTester {
+    constructor(opts: TreeTesterOpts);
+    /**
+     * Set the interaction type used by the tree tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Returns a row matching the specified index or text content.
+     */
+    findRow(opts: {
+        rowIndexOrText: number | string;
+    }): HTMLElement;
+    /**
+     * Toggles the selection for the specified tree row. Defaults to using the interaction type set on the tree tester.
+     */
+    toggleRowSelection(opts: TreeToggleRowOpts): Promise<void>;
+    /**
+     * Toggles the expansion for the specified tree row. Defaults to using the interaction type set on the tree tester.
+     */
+    toggleRowExpansion(opts: TreeToggleExpansionOpts): Promise<void>;
+    /**
+     * Triggers the action for the specified tree row. Defaults to using the interaction type set on the tree tester.
+     */
+    triggerRowAction(opts: TreeRowActionOpts): Promise<void>;
+    /**
+     * Returns the tree.
+     */
+    get tree(): HTMLElement;
+    /**
+     * Returns the tree's rows if any.
+     */
+    get rows(): HTMLElement[];
+    /**
+     * Returns the tree's selected rows if any.
+     */
+    get selectedRows(): HTMLElement[];
+    /**
+     * Returns the tree's cells if any. Can be filtered against a specific row if provided via `element`.
+     */
+    cells(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
 }
 declare let keyToUtil: {
     readonly Select: typeof SelectTester;
@@ -165,34 +632,29 @@ declare let keyToUtil: {
     readonly Menu: typeof MenuTester;
     readonly ComboBox: typeof ComboBoxTester;
     readonly GridList: typeof GridListTester;
+    readonly ListBox: typeof ListBoxTester;
+    readonly Tabs: typeof TabsTester;
+    readonly Tree: typeof TreeTester;
 };
 type PatternNames = keyof typeof keyToUtil;
-type ObjectType<T> = T extends 'Select' ? SelectTester : T extends 'Table' ? TableTester : T extends 'Menu' ? MenuTester : T extends 'ComboBox' ? ComboBoxTester : T extends 'GridList' ? GridListTester : never;
-type ObjectOptionsTypes<T> = T extends 'Select' ? SelectOptions : T extends 'Table' ? TableOptions : T extends 'Menu' ? MenuOptions : T extends 'ComboBox' ? ComboBoxOptions : T extends 'GridList' ? GridListOptions : never;
+type Tester<T> = T extends 'ComboBox' ? ComboBoxTester : T extends 'GridList' ? GridListTester : T extends 'ListBox' ? ListBoxTester : T extends 'Menu' ? MenuTester : T extends 'Select' ? SelectTester : T extends 'Table' ? TableTester : T extends 'Tabs' ? TabsTester : T extends 'Tree' ? TreeTester : never;
+type TesterOpts<T> = T extends 'ComboBox' ? ComboBoxTesterOpts : T extends 'GridList' ? GridListTesterOpts : T extends 'ListBox' ? ListBoxTesterOpts : T extends 'Menu' ? MenuTesterOpts : T extends 'Select' ? SelectTesterOpts : T extends 'Table' ? TableTesterOpts : T extends 'Tabs' ? TabsTesterOpts : T extends 'Tree' ? TreeTesterOpts : never;
 export class User {
-    user: any;
+    /**
+     * The interaction type (mouse, touch, keyboard) that the test util user will use when interacting with a component. This can be overridden
+     * at the aria pattern util level if needed.
+     * @default mouse
+     */
     interactionType: UserOpts['interactionType'];
+    /**
+     * A function used by the test utils to advance timers during interactions. Required for certain aria patterns (e.g. table).
+     */
     advanceTimer: UserOpts['advanceTimer'];
     constructor(opts?: UserOpts);
-    createTester<T extends PatternNames>(patternName: T, opts: ObjectOptionsTypes<T>): ObjectType<T>;
+    /**
+     * Creates an aria pattern tester, inheriting the options provided to the original user.
+     */
+    createTester<T extends PatternNames>(patternName: T, opts: TesterOpts<T>): Tester<T>;
 }
-/**
- * Simulates a "long press" event on a element.
- * @param opts - Options for the long press.
- * @param opts.element - Element to long press.
- * @param opts.advanceTimer - Function that when called advances the timers in your test suite by a specific amount of time(ms).
- * @param opts.pointeropts - Options to pass to the simulated event. Defaults to mouse. See https://testing-library.com/docs/dom-testing-library/api-events/#fireevent for more info.
- */
-export function triggerLongPress(opts: {
-    element: HTMLElement;
-    advanceTimer: (time?: number) => void | Promise<unknown>;
-    pointerOpts?: {};
-}): Promise<void>;
-/**
- * Enables reading pageX/pageY from fireEvent.mouse*(..., {pageX: ..., pageY: ...}).
- */
-export function installMouseEvent(): void;
-export function installPointerEvent(): void;
-export let pointerMap: pointerKey[];
 
 //# sourceMappingURL=types.d.ts.map