@cerios/playwright-table 2.0.2 → 2.1.0

package/dist/index.d.ts

@@ -1,21 +1,21 @@
-import { Locator } from '@playwright/test';
-
+import { Expect, ExpectMatcherState, Locator, PlaywrightTestArgs, PlaywrightTestOptions, PlaywrightWorkerArgs, PlaywrightWorkerOptions, Selectors, TestType } from "@playwright/test";
 /**
  * Enum representing the possible types of content that can be extracted from a table cell.
  *
- * - `TextContent`: The raw text content of the cell, including hidden elements and extra whitespace.
- * - `InnerText`: The rendered text content of the cell, as seen by the user, with whitespace collapsed and hidden elements excluded.
+ * - `TextContent`: all text in the DOM of the cell, also the text of hidden elements.
+ * - `InnerText`: the text as it is shown, without hidden text and with CSS `text-transform`.
+ *
+ * `TableLocator` normalizes the text either way (whitespace collapsed, icon glyphs and `ignore`d elements
+ * left out), unless you ask for raw text. `PlaywrightTable` trims it.
  */
-declare enum CellContentType {
-    TextContent = "textContent",
-    InnerText = "innerText"
+export declare enum CellContentType {
+  TextContent = "textContent",
+  InnerText = "innerText"
 }
-
 type PollingOptions = {
-    timeout?: number;
-    interval?: number;
+  timeout?: number;
+  interval?: number;
 };
-
 /**
  * Represents a single cell value within a table row.
  *
@@ -23,7 +23,7 @@ type PollingOptions = {
  * A `Cell` is a string that holds the textual content of a table cell,
  * whether in the header or body of the table.
  */
-type Cell = string;
+export type Cell = string;
 /**
  * Represents a row in the table body, defined as an array of `Cell` objects.
  *
@@ -32,7 +32,7 @@ type Cell = string;
  *
  * @see Cell
  */
-type BodyRow = Cell[];
+export type BodyRow = Cell[];
 /**
  * Represents a row in the table header, defined as an array of `Cell` objects.
  *
@@ -41,8 +41,7 @@ type BodyRow = Cell[];
  *
  * @see Cell
  */
-type HeaderRow = Cell[];
-
+export type HeaderRow = Cell[];
 /**
  * Options for configuring a table header row.
  *
@@ -52,19 +51,20 @@ type HeaderRow = Cell[];
  * @property colspan - Configuration for column spanning in the header row.
  * @property colspan.enabled - If true, enables column spanning.
  * @property colspan.suffix - If true, appends a suffix to spanned columns.
+ * @property normalizeWhitespace - If true, collapses line breaks, tabs and runs of whitespace to one space.
+ * @property stripIconGlyphs - If true, removes icon-font glyphs (Unicode private use characters).
  */
 type HeaderRowOptions = {
-    cellContentType?: CellContentType;
-    emptyCellReplacement?: boolean;
-    duplicateSuffix?: boolean;
-    colspan?: {
-        enabled?: boolean;
-        suffix?: boolean;
-    };
-    normalizeWhitespace?: boolean;
-    stripIconGlyphs?: boolean;
+  cellContentType?: CellContentType;
+  emptyCellReplacement?: boolean;
+  duplicateSuffix?: boolean;
+  colspan?: {
+    enabled?: boolean;
+    suffix?: boolean;
+  };
+  normalizeWhitespace?: boolean;
+  stripIconGlyphs?: boolean;
 };
-
 /**
  * Options for loading table data, headers, and rows.
  *
@@ -80,407 +80,1903 @@ type HeaderRowOptions = {
  * };
  * await table.getBodyRows(options);
  */
-type TableOptions = {
-    /** See {@link HeaderRowOptions} for available options. */
-    headerRowOptions?: HeaderRowOptions;
-    /** Options for parsing body rows. */
-    bodyRowOptions?: {
-        cellContentType?: CellContentType;
-    };
-    /** @deprecated Use `bodyRowOptions.cellContentType` instead. */
+export type TableOptions = {
+  /** See {@link HeaderRowOptions} for available options. */
+  headerRowOptions?: HeaderRowOptions;
+  /** Options for parsing body rows. */
+  bodyRowOptions?: {
     cellContentType?: CellContentType;
+  };
+  /** @deprecated Use `bodyRowOptions.cellContentType` instead. */
+  cellContentType?: CellContentType;
 };
 /**
  * Represents a table in Playwright, providing methods to interact with its headers, rows, and cells.
  */
-declare class PlaywrightTable {
-    private readonly _tableLocator;
-    private readonly _options?;
-    private _bodyRowLocator;
-    private _bodyRowColumnSelector;
-    private _headerRowLocator;
-    private _headerColumnSelector;
-    /**
-     * Creates an instance of the table handler with customizable selectors for headers and rows.
-     *
-     * @param _tableLocator - The Playwright `Locator` pointing to the root table element.
-     * @param _options - Optional configuration for customizing header and row selectors.
-     * @param _options.header - Options for header row and columns.
-     * @param _options.header.setMainHeaderRow - (Optional) Index of the main header row if multiple header rows exist.
-     * @param _options.header.rowSelector - (Optional) CSS selector for locating header rows. Defaults to `"thead>tr"`.
-     * @param _options.header.columnSelector - (Optional) CSS selector for locating header columns. Defaults to `"th"`.
-     * @param _options.row - Options for body rows and columns.
-     * @param _options.row.rowSelector - (Optional) CSS selector for locating body rows. Defaults to `"tbody>tr"`.
-     * @param _options.row.columnSelector - (Optional) CSS selector for locating body columns. Defaults to `"td"`.
-     *
-     * @example
-     * const table = new PlaywrightTable(
-     *   page.locator('table.my-table'),
-     *   {
-     *     header: {
-     *       rowSelector: 'thead tr.header',
-     *       columnSelector: 'th.header-cell'
-     *     },
-     *     row: {
-     *       rowSelector: 'tbody tr.data-row',
-     *       columnSelector: 'td.data-cell'
-     *     }
-     *   }
-     * );
-     */
-    constructor(_tableLocator: Locator, _options?: {
-        header?: {
-            setMainHeaderRow?: number;
-            rowSelector?: string;
-            columnSelector?: string;
-        };
-        row?: {
-            rowSelector?: string;
-            columnSelector?: string;
-        };
-    } | undefined);
-    /**
-     * Retrieves all header rows of the table.
-     * @param options - Optional parameters for header row parsing configuration.
-     * @returns A promise that resolves to an array of header rows.
-     * @throws Error if no header rows found after table loads.
-     *
-     * @example
-     * // Get headers with colspan enabled
-     * const headers = await table.getHeaderRows({
-     *   colspan: { enabled: true, suffix: true },
-     *   duplicateSuffix: true
-     * });
-     *
-     * @see {@link getMainHeaderRow} for getting only the main header row
-     * @see {@link HeaderRowOptions} for all available configuration options
-     */
-    getHeaderRows(options?: HeaderRowOptions): Promise<HeaderRow[]>;
-    /**
-     * Retrieves the main header row of the table.
-     * By default, uses the last header row if multiple exist. Can be customized via constructor.
-     * @param options - Optional parameters for header row parsing configuration.
-     * @returns A promise that resolves to the main header row.
-     * @throws Error if no header rows available.
-     * @throws Error if setMainHeaderRow index is out of bounds (negative or >= header row count).
-     *
-     * @example
-     * // Get main header with custom index set in constructor
-     * const table = new PlaywrightTable(page.locator('table'), {
-     *   header: { setMainHeaderRow: 0 }  // Use first row as main header
-     * });
-     * const mainHeader = await table.getMainHeaderRow();
-     *
-     * @see {@link getHeaderRows} for getting all header rows
-     */
-    getMainHeaderRow(options?: HeaderRowOptions): Promise<HeaderRow>;
-    /**
-     * Retrieves all body rows of the table.
-     * @param options - Optional table or body-row configuration.
-     * @param options.cellContentType - Legacy shortcut for body row content extraction. See {@link CellContentType}.
-     * @param options.bodyRowOptions - Body row parsing options.
-     * @param options.headerRowOptions - Header parsing options used when resolving row/colspan layouts.
-     * @returns A promise that resolves to an array of body rows.
-     * @throws Error if no body rows found after table loads.
-     *
-     * @example
-     * // Get body rows with TextContent (includes hidden elements)
-     * const rows = await table.getBodyRows({
-     *   cellContentType: CellContentType.TextContent
-     * });
-     *
-     * @example
-     * // Get body rows with default InnerText
-     * const rows = await table.getBodyRows();
-     *
-     * @example
-     * // Use full table options (for example to sanitize noisy treegrid headers)
-     * const rows = await table.getBodyRows({
-     *   bodyRowOptions: { cellContentType: CellContentType.InnerText },
-     *   headerRowOptions: { normalizeWhitespace: true, stripIconGlyphs: true }
-     * });
-     */
-    getBodyRows(options?: TableOptions): Promise<BodyRow[]>;
-    /**
-     * Retrieves a specific cell locator in the body of the table by row and column index.
-     * @param rowNumber - The row number (0-based index).
-     * @param headerPosition - The column/header position (0-based index).
-     * @returns A Playwright Locator for the specified cell.
-     *
-     * @example
-     * // Get cell at row 1, column 2
-     * const cellLocator = table.getBodyCellLocator(1, 2);
-     * await expect(cellLocator).toHaveText('Expected Text');
-     *
-     * @example
-     * // Get first cell in first row
-     * const firstCell = table.getBodyCellLocator(0, 0);
-     * await firstCell.click();
-     *
-     * @see {@link getBodyCellLocatorByRowConditions} for finding cells by content matching
-     * @see {@link getAllBodyCellLocatorsByHeaderIndex} for getting all cells in a column
-     * @see {@link getAllBodyCellLocatorsByHeaderName} for getting all cells under a header
-     */
-    getBodyCellLocator(rowNumber: number, headerPosition: number): Locator;
-    /**
-     * Retrieves a cell locator in the body of the table based on row conditions and a target header.
-     * Finds the first row where all conditions match, then returns the cell in the target column.
-     * @param conditions - An object where keys are header names and values are expected cell contents, or a single [header, value] tuple.
-     * @param targetHeader - The header name of the column containing the cell to retrieve.
-     * @param options - Optional table loading options. See {@link TableOptions}.
-     * @returns A promise that resolves to a Playwright Locator for the matching cell.
-     * @throws Error if no row matches all specified conditions.
-     * @throws Error if any condition header or target header is not found in the table.
-     *
-     * @example
-     * // Find cell with multiple conditions
-     * const emailLocator = await table.getBodyCellLocatorByRowConditions(
-     *   { "First name": "John", "Status": "Active" },
-     *   "Email"
-     * );
-     * await expect(emailLocator).toContainText('@example.com');
-     *
-     * @example
-     * // Find cell with single condition using tuple syntax
-     * const actionCell = await table.getBodyCellLocatorByRowConditions(
-     *   ["Username", "john.doe"],
-     *   "Actions"
-     * );
-     * await actionCell.locator('button').click();
-     *
-     * @example
-     * // Find cell with single condition using object syntax
-     * const statusCell = await table.getBodyCellLocatorByRowConditions(
-     *   { "Username": "john.doe" },
-     *   "Status"
-     * );
-     *
-     * @see {@link getBodyCellLocator} for getting cells by direct index
-     * @see {@link getAllBodyCellLocatorsByHeaderName} for getting all cells in a column
-     */
-    getBodyCellLocatorByRowConditions(conditions: Record<string, string> | [string, string], targetHeader: string, options?: TableOptions): Promise<Locator>;
-    /**
-     * Retrieves all cell locators in the body of the table for a specific header name.
-     * Returns locators for every cell in the column identified by the header.
-     * @param header - The header name identifying the column.
-     * @param options - Optional table loading options. See {@link TableOptions}.
-     * @returns A promise that resolves to an array of Playwright Locators for all cells in the column.
-     * @throws Error if the header is not found in the table.
-     *
-     * @example
-     * // Get all cells in the "Status" column
-     * const statusCells = await table.getAllBodyCellLocatorsByHeaderName("Status");
-     * for (const cell of statusCells) {
-     *   await expect(cell).toHaveText(/Active|Inactive/);
-     * }
-     *
-     * @example
-     * // Get text from all cells in "Name" column
-     * const nameCells = await table.getAllBodyCellLocatorsByHeaderName("Name");
-     * const names = await Promise.all(nameCells.map(cell => cell.textContent()));
-     *
-     * @see {@link getAllBodyCellLocatorsByHeaderIndex} for getting cells by column index
-     * @see {@link getBodyCellLocatorByRowConditions} for finding specific cells by content
-     */
-    getAllBodyCellLocatorsByHeaderName(header: string, options?: TableOptions): Promise<Locator[]>;
-    /**
-     * Retrieves all cell locators in the body of the table for a specific header index.
-     * Returns locators for every cell in the column at the specified position.
-     * @param headerIndex - The header/column index (0-based).
-     * @param options - Optional table loading options. See {@link TableOptions}.
-     * @returns A promise that resolves to an array of Playwright Locators for all cells in the column.
-     * @throws Error if the header index is out of bounds (negative or >= column count).
-     *
-     * @example
-     * // Get all cells in the third column (index 2)
-     * const thirdColumnCells = await table.getAllBodyCellLocatorsByHeaderIndex(2);
-     * for (const cell of thirdColumnCells) {
-     *   await expect(cell).toBeVisible();
-     * }
-     *
-     * @example
-     * // Get all cells in first column
-     * const firstColumnCells = await table.getAllBodyCellLocatorsByHeaderIndex(0);
-     * const values = await Promise.all(firstColumnCells.map(c => c.textContent()));
-     *
-     * @see {@link getAllBodyCellLocatorsByHeaderName} for getting cells by header name
-     * @see {@link getBodyCellLocator} for getting a specific cell by row and column index
-     */
-    getAllBodyCellLocatorsByHeaderIndex(headerIndex: number, options?: TableOptions): Promise<Locator[]>;
-    /**
-     * Converts the table data into a JSON array where each object represents a row.
-     * Keys are header names, values are cell contents.
-     * @param options - Optional table loading options. See {@link TableOptions}.
-     * @returns A promise that resolves to an array of objects representing table rows.
-     * @throws Error if no header rows or body rows found.
-     *
-     * @example
-     * // Convert table to JSON with default options
-     * const data = await table.getJson();
-     * // Result: [{"Name": "John", "Age": "30"}, {"Name": "Jane", "Age": "25"}]
-     *
-     * @example
-     * // Convert with colspan enabled and duplicate suffix
-     * const data = await table.getJson({
-     *   headerRowOptions: {
-     *     colspan: { enabled: true, suffix: true },
-     *     duplicateSuffix: true,
-     *     emptyCellReplacement: true
-     *   }
-     * });
-     */
-    getJson(options?: TableOptions): Promise<Record<string, string>[]>;
-    /**
-     * Waits for the table body to be empty (no body rows).
-     * @param options - Polling options (timeout, interval, retries).
-     * @returns A promise that resolves when table body is empty.
-     * @throws Error if table is not empty within timeout period.
-     *
-     * @example
-     * // Wait for table to clear after delete operation
-     * await table.waitForEmpty({ timeout: 5000 });
-     *
-     * @see {@link waitForNonEmpty} for waiting until table has data
-     *
-     * @remarks
-     * **Alternative:** Consider using Playwright's `expect.poll` for more flexibility:
-     * ```ts
-     * await expect.poll(async () => (await table.getBodyRows()).length).toBe(0);
-     * ```
-     */
-    waitForEmpty(options?: PollingOptions): Promise<void>;
-    /**
-     * Waits for the table body to be non-empty (at least one body row with content).
-     * A row is considered valid if it has at least one cell containing text.
-     * @param options - Polling options (timeout, interval, retries).
-     * @returns A promise that resolves when table has at least one body row with content.
-     * @throws Error if table remains empty or has no rows with content within timeout period.
-     *
-     * @example
-     * // Wait for table to populate after search
-     * await table.waitForNonEmpty({ timeout: 5000 });
-     *
-     * @see {@link waitForEmpty} for waiting until table is cleared
-     *
-     * @remarks
-     * **Alternative:** Consider using Playwright's `expect.poll` for more flexibility:
-     * ```ts
-     * await expect.poll(async () => (await table.getBodyRows()).length).toBeGreaterThan(0);
-     * ```
-     */
-    waitForNonEmpty(options?: PollingOptions): Promise<void>;
-    /**
-     * Waits for the table body to have exactly N rows.
-     * @param count - The exact number of body rows expected.
-     * @param options - Polling options (timeout, interval, retries).
-     * @returns A promise that resolves when the table has exactly the specified number of rows.
-     * @throws Error if row count doesn't match within timeout period.
-     *
-     * @example
-     * // Wait for exactly 10 rows after pagination
-     * await table.waitForExactRowCount(10, { timeout: 5000 });
-     *
-     * @example
-     * // Verify table has exactly 0 rows (alternative to waitForEmpty)
-     * await table.waitForExactRowCount(0);
-     *
-     * @see {@link getRowCount} for getting current row counts
-     *
-     * @remarks
-     * **Alternative:** Consider using Playwright's `expect.poll` for more flexibility:
-     * ```ts
-     * await expect.poll(async () => (await table.getBodyRows()).length).toBe(10);
-     * ```
-     */
-    waitForExactRowCount(count: number, options?: PollingOptions): Promise<void>;
-    /**
-     * Gets the count of header and body rows in the table.
-     * Lightweight method that doesn't fetch cell data, only counts rows.
-     * @returns A promise that resolves to an object with header and body row counts.
-     *
-     * @example
-     * // Get current row counts
-     * const counts = await table.getRowCount();
-     * console.log(`Headers: ${counts.header}, Body: ${counts.body}`);
-     *
-     * @example
-     * // Assert specific row count
-     * const { body } = await table.getRowCount();
-     * expect(body).toBe(10);
-     */
-    getRowCount(): Promise<{
-        header: number;
-        body: number;
-    }>;
+export declare class PlaywrightTable {
+  private readonly _tableLocator;
+  private readonly _options?;
+  private _bodyRowLocator;
+  private _bodyRowColumnSelector;
+  private _headerRowLocator;
+  private _headerColumnSelector;
+  /**
+   * Creates an instance of the table handler with customizable selectors for headers and rows.
+   *
+   * @param _tableLocator - The Playwright `Locator` pointing to the root table element.
+   * @param _options - Optional configuration for customizing header and row selectors.
+   * @param _options.header - Options for header row and columns.
+   * @param _options.header.setMainHeaderRow - (Optional) Index of the main header row if multiple header rows exist.
+   * @param _options.header.rowSelector - (Optional) CSS selector for locating header rows. Defaults to `"thead>tr"`.
+   * @param _options.header.columnSelector - (Optional) CSS selector for locating header columns. Defaults to `"th"`.
+   * @param _options.row - Options for body rows and columns.
+   * @param _options.row.rowSelector - (Optional) CSS selector for locating body rows. Defaults to `"tbody>tr"`.
+   * @param _options.row.columnSelector - (Optional) CSS selector for locating body columns. Defaults to `"td"`.
+   *
+   * @example
+   * const table = new PlaywrightTable(
+   *   page.locator('table.my-table'),
+   *   {
+   *     header: {
+   *       rowSelector: 'thead tr.header',
+   *       columnSelector: 'th.header-cell'
+   *     },
+   *     row: {
+   *       rowSelector: 'tbody tr.data-row',
+   *       columnSelector: 'td.data-cell'
+   *     }
+   *   }
+   * );
+   */
+  constructor(_tableLocator: Locator, _options?: {
+    header?: {
+      setMainHeaderRow?: number;
+      rowSelector?: string;
+      columnSelector?: string;
+    };
+    row?: {
+      rowSelector?: string;
+      columnSelector?: string;
+    };
+  } | undefined);
+  /**
+   * Retrieves all header rows of the table.
+   * @param options - Optional parameters for header row parsing configuration.
+   * @returns A promise that resolves to an array of header rows.
+   * @throws Error if the table has no header rows or no body rows.
+   *
+   * @example
+   * // Get headers with colspan enabled
+   * const headers = await table.getHeaderRows({
+   *   colspan: { enabled: true, suffix: true },
+   *   duplicateSuffix: true
+   * });
+   *
+   * @see {@link getMainHeaderRow} for getting only the main header row
+   * @see {@link HeaderRowOptions} for all available configuration options
+   */
+  getHeaderRows(options?: HeaderRowOptions): Promise<HeaderRow[]>;
+  /**
+   * Retrieves the main header row of the table.
+   * By default, uses the last header row if multiple exist. Can be customized via constructor.
+   * @param options - Optional parameters for header row parsing configuration.
+   * @returns A promise that resolves to the main header row.
+   * @throws Error if the table has no header rows or no body rows.
+   * @throws Error if setMainHeaderRow index is out of bounds (negative or >= header row count).
+   *
+   * @example
+   * // Get main header with custom index set in constructor
+   * const table = new PlaywrightTable(page.locator('table'), {
+   *   header: { setMainHeaderRow: 0 }  // Use first row as main header
+   * });
+   * const mainHeader = await table.getMainHeaderRow();
+   *
+   * @see {@link getHeaderRows} for getting all header rows
+   */
+  getMainHeaderRow(options?: HeaderRowOptions): Promise<HeaderRow>;
+  /**
+   * Retrieves all body rows of the table.
+   * @param options - Optional table or body-row configuration.
+   * @param options.cellContentType - Legacy shortcut for body row content extraction. See {@link CellContentType}.
+   * @param options.bodyRowOptions - Body row parsing options.
+   * @param options.headerRowOptions - Header parsing options used when resolving row/colspan layouts.
+   * @returns A promise that resolves to an array of body rows.
+   * @throws Error if the table has no header rows or no body rows.
+   *
+   * @example
+   * // Get body rows with TextContent (includes hidden elements)
+   * const rows = await table.getBodyRows({
+   *   cellContentType: CellContentType.TextContent
+   * });
+   *
+   * @example
+   * // Get body rows with default InnerText
+   * const rows = await table.getBodyRows();
+   *
+   * @example
+   * // Use full table options (for example to sanitize noisy treegrid headers)
+   * const rows = await table.getBodyRows({
+   *   bodyRowOptions: { cellContentType: CellContentType.InnerText },
+   *   headerRowOptions: { normalizeWhitespace: true, stripIconGlyphs: true }
+   * });
+   */
+  getBodyRows(options?: TableOptions): Promise<BodyRow[]>;
+  /**
+   * Retrieves a specific cell locator in the body of the table by row and column index.
+   * Both are positions in the DOM: `headerPosition` is the index among the cells of the row, so with
+   * colspan or rowspan it can differ from the column. The methods that find cells by header name
+   * account for spans.
+   * @param rowNumber - The row number (0-based index).
+   * @param headerPosition - The cell position within the row (0-based index).
+   * @returns A Playwright Locator for the specified cell.
+   *
+   * @example
+   * // Get cell at row 1, column 2
+   * const cellLocator = table.getBodyCellLocator(1, 2);
+   * await expect(cellLocator).toHaveText('Expected Text');
+   *
+   * @example
+   * // Get first cell in first row
+   * const firstCell = table.getBodyCellLocator(0, 0);
+   * await firstCell.click();
+   *
+   * @see {@link getBodyCellLocatorByRowConditions} for finding cells by content matching
+   * @see {@link getAllBodyCellLocatorsByHeaderIndex} for getting all cells in a column
+   * @see {@link getAllBodyCellLocatorsByHeaderName} for getting all cells under a header
+   */
+  getBodyCellLocator(rowNumber: number, headerPosition: number): Locator;
+  /**
+   * Retrieves a cell locator in the body of the table based on row conditions and a target header.
+   * Finds the first row where all conditions match, then returns the cell in the target column.
+   * @param conditions - An object where keys are header names and values are expected cell contents, or a single [header, value] tuple.
+   * @param targetHeader - The header name of the column containing the cell to retrieve.
+   * @param options - Optional table loading options. See {@link TableOptions}.
+   * @returns A promise that resolves to a Playwright Locator for the matching cell.
+   * @throws Error if no row matches all specified conditions.
+   * @throws Error if any condition header or target header is not found in the table.
+   *
+   * @example
+   * // Find cell with multiple conditions
+   * const emailLocator = await table.getBodyCellLocatorByRowConditions(
+   *   { "First name": "John", "Status": "Active" },
+   *   "Email"
+   * );
+   * await expect(emailLocator).toContainText('@example.com');
+   *
+   * @example
+   * // Find cell with single condition using tuple syntax
+   * const actionCell = await table.getBodyCellLocatorByRowConditions(
+   *   ["Username", "john.doe"],
+   *   "Actions"
+   * );
+   * await actionCell.locator('button').click();
+   *
+   * @example
+   * // Find cell with single condition using object syntax
+   * const statusCell = await table.getBodyCellLocatorByRowConditions(
+   *   { "Username": "john.doe" },
+   *   "Status"
+   * );
+   *
+   * @see {@link getBodyCellLocator} for getting cells by direct index
+   * @see {@link getAllBodyCellLocatorsByHeaderName} for getting all cells in a column
+   */
+  getBodyCellLocatorByRowConditions(conditions: Record<string, string> | [string, string], targetHeader: string, options?: TableOptions): Promise<Locator>;
+  /**
+   * Retrieves all cell locators in the body of the table for a specific header name.
+   * Returns locators for every cell in the column identified by the header.
+   * @param header - The header name identifying the column.
+   * @param options - Optional table loading options. See {@link TableOptions}.
+   * @returns A promise that resolves to an array of Playwright Locators for all cells in the column.
+   * @throws Error if the header is not found, or if the table has no header rows or no body rows.
+   *
+   * @example
+   * // Get all cells in the "Status" column
+   * const statusCells = await table.getAllBodyCellLocatorsByHeaderName("Status");
+   * for (const cell of statusCells) {
+   *   await expect(cell).toHaveText(/Active|Inactive/);
+   * }
+   *
+   * @example
+   * // Get text from all cells in "Name" column
+   * const nameCells = await table.getAllBodyCellLocatorsByHeaderName("Name");
+   * const names = await Promise.all(nameCells.map(cell => cell.textContent()));
+   *
+   * @see {@link getAllBodyCellLocatorsByHeaderIndex} for getting cells by column index
+   * @see {@link getBodyCellLocatorByRowConditions} for finding specific cells by content
+   */
+  getAllBodyCellLocatorsByHeaderName(header: string, options?: TableOptions): Promise<Locator[]>;
+  /**
+   * Retrieves all cell locators in the body of the table for a specific header index.
+   * Returns locators for every cell in the column at the specified position.
+   * @param headerIndex - The header/column index (0-based).
+   * @param options - Optional table loading options. See {@link TableOptions}.
+   * @returns A promise that resolves to an array of Playwright Locators for all cells in the column.
+   * @throws Error if the header index is out of bounds (negative or >= the number of columns, counting colspans).
+   *
+   * @example
+   * // Get all cells in the third column (index 2)
+   * const thirdColumnCells = await table.getAllBodyCellLocatorsByHeaderIndex(2);
+   * for (const cell of thirdColumnCells) {
+   *   await expect(cell).toBeVisible();
+   * }
+   *
+   * @example
+   * // Get all cells in first column
+   * const firstColumnCells = await table.getAllBodyCellLocatorsByHeaderIndex(0);
+   * const values = await Promise.all(firstColumnCells.map(c => c.textContent()));
+   *
+   * @see {@link getAllBodyCellLocatorsByHeaderName} for getting cells by header name
+   * @see {@link getBodyCellLocator} for getting a specific cell by row and column index
+   */
+  getAllBodyCellLocatorsByHeaderIndex(headerIndex: number, options?: TableOptions): Promise<Locator[]>;
+  /**
+   * Converts the table data into a JSON array where each object represents a row.
+   * Keys are header names, values are cell contents.
+   * @param options - Optional table loading options. See {@link TableOptions}.
+   * @returns A promise that resolves to an array of objects representing table rows.
+   * @throws Error if no header rows or body rows found.
+   *
+   * @example
+   * // Convert table to JSON with default options
+   * const data = await table.getJson();
+   * // Result: [{"Name": "John", "Age": "30"}, {"Name": "Jane", "Age": "25"}]
+   *
+   * @example
+   * // Convert with colspan enabled and duplicate suffix
+   * const data = await table.getJson({
+   *   headerRowOptions: {
+   *     colspan: { enabled: true, suffix: true },
+   *     duplicateSuffix: true,
+   *     emptyCellReplacement: true
+   *   }
+   * });
+   */
+  getJson(options?: TableOptions): Promise<Record<string, string>[]>;
+  /**
+   * Waits for the table body to be empty (no body rows).
+   * @param options - Polling options (`timeout`, default 30000 ms; `interval`, default 100 ms).
+   * @returns A promise that resolves when table body is empty.
+   * @throws Error if table is not empty within timeout period.
+   *
+   * @example
+   * // Wait for table to clear after delete operation
+   * await table.waitForEmpty({ timeout: 5000 });
+   *
+   * @see {@link waitForNonEmpty} for waiting until table has data
+   *
+   * @remarks
+   * **Alternative:** Consider using Playwright's `expect.poll` for more flexibility. Count the rows with
+   * `getRowCount()`: the methods that read the table throw while the body is empty.
+   * ```ts
+   * await expect.poll(async () => (await table.getRowCount()).body).toBe(0);
+   * ```
+   */
+  waitForEmpty(options?: PollingOptions): Promise<void>;
+  /**
+   * Waits for the table body to be non-empty (at least one body row with content).
+   * A row is considered valid if it has at least one cell containing text.
+   * @param options - Polling options (`timeout`, default 30000 ms; `interval`, default 100 ms).
+   * @returns A promise that resolves when table has at least one body row with content.
+   * @throws Error if table remains empty or has no rows with content within timeout period.
+   *
+   * @example
+   * // Wait for table to populate after search
+   * await table.waitForNonEmpty({ timeout: 5000 });
+   *
+   * @see {@link waitForEmpty} for waiting until table is cleared
+   *
+   * @remarks
+   * **Alternative:** Consider using Playwright's `expect.poll` for more flexibility:
+   * ```ts
+   * await expect.poll(async () => (await table.getBodyRows()).length).toBeGreaterThan(0);
+   * ```
+   */
+  waitForNonEmpty(options?: PollingOptions): Promise<void>;
+  /**
+   * Waits for the table body to have exactly N rows.
+   * @param count - The exact number of body rows expected.
+   * @param options - Polling options (`timeout`, default 30000 ms; `interval`, default 100 ms).
+   * @returns A promise that resolves when the table has exactly the specified number of rows.
+   * @throws Error if row count doesn't match within timeout period.
+   *
+   * @example
+   * // Wait for exactly 10 rows after pagination
+   * await table.waitForExactRowCount(10, { timeout: 5000 });
+   *
+   * @example
+   * // Verify table has exactly 0 rows (alternative to waitForEmpty)
+   * await table.waitForExactRowCount(0);
+   *
+   * @see {@link getRowCount} for getting current row counts
+   *
+   * @remarks
+   * **Alternative:** Consider using Playwright's `expect.poll` for more flexibility:
+   * ```ts
+   * await expect.poll(async () => (await table.getBodyRows()).length).toBe(10);
+   * ```
+   */
+  waitForExactRowCount(count: number, options?: PollingOptions): Promise<void>;
+  /**
+   * Gets the count of header and body rows in the table.
+   * Lightweight method that doesn't fetch cell data, only counts rows.
+   * @returns A promise that resolves to an object with header and body row counts.
+   *
+   * @example
+   * // Get current row counts
+   * const counts = await table.getRowCount();
+   * console.log(`Headers: ${counts.header}, Body: ${counts.body}`);
+   *
+   * @example
+   * // Assert specific row count
+   * const { body } = await table.getRowCount();
+   * expect(body).toBe(10);
+   */
+  getRowCount(): Promise<{
+    header: number;
+    body: number;
+  }>;
+  /**
+   * Gets all distinct (unique) values from a specific column.
+   * Returns a sorted array of unique string values, excluding empty values.
+   * @param headerName - The header name of the column to extract distinct values from.
+   * @param options - Optional table loading options. See {@link TableOptions}.
+   * @returns A promise that resolves to a sorted array of distinct values.
+   * @throws Error if the header is not found, or if the table has no header rows or no body rows.
+   *
+   * @example
+   * // Get all unique status values
+   * const statuses = await table.getDistinctColumnValues("Status");
+   * // Result: ["Active", "Inactive", "Pending"]
+   *
+   * @example
+   * // Get distinct countries for filtering
+   * const countries = await table.getDistinctColumnValues("Country");
+   * console.log(`Available countries: ${countries.join(", ")}`);
+   *
+   * @example
+   * // Verify expected values exist
+   * const roles = await table.getDistinctColumnValues("Role");
+   * expect(roles).toContain("Admin");
+   * expect(roles).toHaveLength(3);
+   *
+   * @see {@link getAllBodyCellLocatorsByHeaderName} for getting all cell locators in a column
+   * @see {@link getJson} for getting full table data
+   */
+  getDistinctColumnValues(headerName: string, options?: TableOptions): Promise<string[]>;
+  /**
+   * Finds the index of the first body row matching the specified conditions.
+   * Returns -1 if no matching row is found.
+   * @param conditions - Record of header names and expected cell values to match.
+   * @param options - Optional table loading options. See {@link TableOptions}.
+   * @returns A promise that resolves to the 0-based index of the first matching row, or -1 if not found.
+   * @throws Error if specified headers don't exist, or if the table has no header rows or no body rows.
+   *
+   * @example
+   * // Find index of row where Status is "Active"
+   * const index = await table.findRowIndex({ Status: "Active" });
+   * if (index >= 0) {
+   *   console.log(`Found at row ${index}`);
+   * }
+   *
+   * @example
+   * // Find row and interact with it
+   * const rowIndex = await table.findRowIndex({ Username: "john.doe" });
+   * if (rowIndex >= 0) {
+   *   const cell = table.getBodyCellLocator(rowIndex, 0);
+   *   await cell.click();
+   * }
+   *
+   * @see {@link getBodyCellLocatorByRowConditions} for getting cell locators from matching rows
+   */
+  findRowIndex(conditions: Record<string, string>, options?: TableOptions): Promise<number>;
+  private getTable;
+  /**
+   * The locator of the DOM cell at a grid position, so colspan and rowspan don't shift it. A cell that
+   * spans rows is located in the row it starts in.
+   */
+  private gridCellLocator;
+  private normalizeGetBodyRowsOptions;
+  private resolveHeaderRowOptionsForJsonKeys;
+  private resolveTableOptionsForHeaderKeyMethods;
+  private resolveHeaderRowOptions;
+  private resolveColspanOptions;
+  private mainHeaderRow;
+  /**
+   * Gets the index of a header in the main header row, throwing an error if not found.
+   * @param header - The header name to find.
+   * @param mainHeader - The main header row to search in.
+   * @returns The 0-based index of the header.
+   * @throws Error if the header is not found.
+   */
+  private getHeaderIndex;
+}
+/**
+ * A header key accepted by {@link TableLocator}: a plain header name, a colspan continuation
+ * (`Name__C1`, `Name__C2`, ...) or a duplicate header (`Name__D1`, `Name__D2`, ...).
+ *
+ * These are the same keys that `PlaywrightTable.getJson()` produces.
+ *
+ * @example
+ * type Keys = HeaderKey<"Name" | "Status">;
+ * // "Name" | "Status" | `Name__C${number}` | `Status__C${number}` | `Name__D${number}` | `Status__D${number}`
+ */
+type HeaderKey<H extends string> = H | `${H}__C${number}` | `${H}__D${number}`;
+/**
+ * A column of a {@link TableLocator}: a {@link HeaderKey}, or a 0-based column index on the visual grid
+ * (rowspan and colspan aware). Column indexes also work for tables without header rows.
+ *
+ * @example
+ * table.rowAt(0).cell("Name");
+ * table.rowAt(0).cell(2);
+ */
+type ColumnKey<H extends string> = HeaderKey<H> | number;
+/**
+ * A declarative cell condition. Exactly one key per condition.
+ *
+ * Cell text is compared as the user sees it: each line whitespace-collapsed and trimmed, lines joined
+ * with one `\n`, without icon glyphs, invisible characters or visually hidden text. Expected values are
+ * normalized the same way, so `"Street 1\r\nAmsterdam"` matches a cell showing two lines.
+ *
+ * @example
+ * table.row({ Name: { contains: "john", ignoreCase: true } });
+ * table.row({ Status: { oneOf: ["Active", "Pending"] } });
+ * table.row({ Remarks: { empty: true } });
+ * // Runs in the browser, so it must not use variables from the test scope.
+ * table.row({ Age: { predicate: text => Number(text) >= 18 } });
+ * // The second argument is the raw cell text (`innerText` or `textContent`, unnormalized).
+ * table.row({ Name: { predicate: (text, raw) => raw.includes("\u00a0") } });
+ * // Combinators
+ * table.row({ Status: { not: "Deleted" } });
+ * table.row({ Email: { anyOf: [{ endsWith: "@example.com" }, /@test\./] } });
+ * table.row({ Name: { allOf: [{ startsWith: "J" }, { not: { contains: "Doe" } }] } });
+ * // Numeric comparisons on the number in the cell (see {@link NumberCondition})
+ * table.row({ Age: { gte: 18 } });
+ * table.row({ Price: { between: [10, 20], decimal: "," } });
+ */
+type CellCondition = ExclusiveCondition<{
+  equals: string;
+  ignoreCase?: boolean;
+}> | ExclusiveCondition<{
+  contains: string;
+  ignoreCase?: boolean;
+}> | ExclusiveCondition<{
+  startsWith: string;
+  ignoreCase?: boolean;
+}> | ExclusiveCondition<{
+  endsWith: string;
+  ignoreCase?: boolean;
+}> | ExclusiveCondition<{
+  oneOf: readonly string[];
+  ignoreCase?: boolean;
+}> | ExclusiveCondition<{
+  empty: boolean;
+}> | ExclusiveCondition<{
+  /**
+   * Serialized with `toString()` and executed in the page, like a `page.evaluate` function.
+   * It must be self-contained: it cannot use variables from the test scope.
+   *
+   * `text` is the normalized cell text that the other conditions compare; `raw` is the cell text
+   * exactly as the browser reads it (`innerText`, or `textContent`), without any normalization.
+   */
+  predicate: (text: string, raw: string) => boolean;
+}> | ExclusiveCondition<{
+  not: CellMatcher;
+}> | ExclusiveCondition<{
+  anyOf: readonly [CellMatcher, ...CellMatcher[]];
+}> | ExclusiveCondition<{
+  allOf: readonly [CellMatcher, ...CellMatcher[]];
+}> | NumberCondition;
+/**
+ * A numeric cell condition: the cell holds exactly one number, and it compares as asked. `between` is
+ * inclusive. A cell without a number, or with more than one, never matches.
+ *
+ * The number is read like {@link DecimalSeparator} describes: `"€ 1,200.50"` is 1200.5 and, with
+ * `decimal: ","`, `"1.234,5 kg"` is 1234.5.
+ *
+ * @example
+ * table.row({ Age: { gt: 65 } });
+ * table.row({ Total: { between: [100, 200] } });
+ */
+type NumberCondition = ExclusiveCondition<{
+  gt: number;
+  decimal?: DecimalSeparator;
+}> | ExclusiveCondition<{
+  gte: number;
+  decimal?: DecimalSeparator;
+}> | ExclusiveCondition<{
+  lt: number;
+  decimal?: DecimalSeparator;
+}> | ExclusiveCondition<{
+  lte: number;
+  decimal?: DecimalSeparator;
+}> | ExclusiveCondition<{
+  between: readonly [number, number];
+  decimal?: DecimalSeparator;
+}>;
+/**
+ * The decimal separator of the numbers in a table. Defaults to `"."`.
+ *
+ * A number is the one run of digits in the text, with an optional `-` or `−` in front (a currency symbol
+ * may come in between). Digits are grouped by the other separator, `'`, or a (non-breaking) space, in
+ * groups of three: with `"."`, `"1,234.5"`, `"1 234.5"` and `"1'234.5"` are all 1234.5. Other text, such
+ * as a currency or a unit, is ignored. Text with no number, or with more than one, is not a number.
+ */
+type DecimalSeparator = "." | ",";
+type CellConditionKey = "equals" | "contains" | "startsWith" | "endsWith" | "oneOf" | "empty" | "predicate" | "not" | "anyOf" | "allOf" | "gt" | "gte" | "lt" | "lte" | "between" | "ignoreCase" | "decimal";
+/** Forbids the keys of the other condition kinds, so a condition object has exactly one kind. */
+type ExclusiveCondition<T> = T & { [K in Exclude<CellConditionKey, keyof T>]?: never; };
+/**
+ * How a cell is matched: an exact string, a RegExp, or a {@link CellCondition}.
+ */
+type CellMatcher = string | RegExp | CellCondition;
+/**
+ * Row conditions keyed by header. Every condition must match for a row to be selected.
+ */
+type RowWhere<H extends string> = { [K in HeaderKey<H>]?: CellMatcher; };
+/**
+ * Compile-time guard for {@link RowWhere}: rejects an empty object and keys that are not a
+ * {@link HeaderKey} of `H`. Intersect it with the inferred conditions type `W`.
+ */
+type ValidRowWhere<H extends string, W> = ([keyof W] extends [never] ? "row() requires at least one condition" : unknown) & ([Exclude<keyof W, HeaderKey<H>>] extends [never] ? unknown : { [K in Exclude<keyof W, HeaderKey<H>>]: never; });
+/** An ARIA role, as Playwright's `getByRole` accepts it. */
+type AriaRole = Parameters<Locator["getByRole"]>[0];
+/**
+ * Which elements an option of {@link TableLocator} selects: a CSS selector, or a descriptor that combines a
+ * CSS selector, a role and the text of the element. Every field of a descriptor must match.
+ *
+ * These options are not Playwright `Locator`s, because the table is read in the browser on every retry of a
+ * locator or matcher, and only a CSS selector or a descriptor can be checked there.
+ *
+ * @example
+ * row: { rowSelector: "tbody>tr.data" }
+ * row: { rowSelector: { role: "row", hasNotText: "Loading" } }
+ * row: { columnSelector: { role: ["cell", "rowheader"] } }
+ * emptyRow: { hasText: "No data" }
+ * ignore: [...DEFAULT_IGNORE, { css: "span", hasText: /^sort/ }]
+ */
+type ElementSelector = string | ElementDescriptor;
+/** A descriptor of {@link ElementSelector}. It needs at least one field. */
+type ElementDescriptor = {
+  /** A CSS selector the element matches. */
+  css?: string;
+  /**
+   * The role of the element, or one of several roles: its `role` attribute (the first role in it), or
+   * else the role of a table element. `<table>` is a `table`, `<thead>`, `<tbody>` and `<tfoot>` are a
+   * `rowgroup`, and `<tr>` is a `row`. `<td>` is a `gridcell` in a table with the `grid` or `treegrid` role,
+   * and a `cell` otherwise. `<th>` is a `rowheader` with `scope="row"` or in a row that also has a `<td>`
+   * (outside a `<thead>`), and a `columnheader` otherwise.
+   */
+  role?: AriaRole | readonly [AriaRole, ...AriaRole[]];
+  /**
+   * Text inside the element, like `Locator.filter({ hasText })`: a string matches case-insensitively,
+   * anywhere in the text, with whitespace collapsed; a RegExp is tested on that text. The text is the
+   * `textContent` of the element, hidden text included.
+   */
+  hasText?: string | RegExp;
+  /** Text that is not inside the element, the opposite of `hasText`. */
+  hasNotText?: string | RegExp;
+};
+/**
+ * Options for {@link TableLocator}.
+ *
+ * @example
+ * const options: TableLocatorOptions<"Name" | "Status"> = {
+ *   headers: ["Name", "Status"],
+ *   header: { rowSelector: "thead>tr", columnSelector: "th" },
+ *   row: { rowSelector: "tbody>tr", columnSelector: "td" },
+ *   cellContentType: CellContentType.InnerText,
+ * };
+ */
+type TableLocatorOptions<H extends string> = {
+  /**
+   * The header names of the table. Used to infer typed header keys and by
+   * {@link TableLocator.validateHeaders}. Does not restrict anything at runtime by itself.
+   */
+  headers?: readonly H[];
+  /**
+   * Use ARIA roles instead of HTML table elements for the default selectors, for grids built from
+   * other elements (such as AG Grid or MUI Data Grid). Selectors you set yourself still win.
+   * Defaults to `false`.
+   *
+   * - Header rows: `[role=row]` with a `[role=columnheader]` inside; header cells: `[role=columnheader]`.
+   * - Body rows: the other `[role=row]`s; body cells: `[role=gridcell]`, `[role=cell]` and `[role=rowheader]`.
+   *
+   * `aria-colindex`, `aria-rowindex`, `aria-colspan` and `aria-rowspan` are used whenever they are
+   * present, with or without this option.
+   */
+  aria?: boolean;
+  header?: {
+    /** Index of the main header row. Defaults to the last header row. */
+    setMainHeaderRow?: number;
     /**
-     * Gets all distinct (unique) values from a specific column.
-     * Returns a sorted array of unique string values, excluding empty values.
-     * @param headerName - The header name of the column to extract distinct values from.
-     * @param options - Optional table loading options. See {@link TableOptions}.
-     * @returns A promise that resolves to a sorted array of distinct values.
-     * @throws Error if the specified header is not found in the table.
-     *
-     * @example
-     * // Get all unique status values
-     * const statuses = await table.getDistinctColumnValues("Status");
-     * // Result: ["Active", "Inactive", "Pending"]
-     *
-     * @example
-     * // Get distinct countries for filtering
-     * const countries = await table.getDistinctColumnValues("Country");
-     * console.log(`Available countries: ${countries.join(", ")}`);
-     *
-     * @example
-     * // Verify expected values exist
-     * const roles = await table.getDistinctColumnValues("Role");
-     * expect(roles).toContain("Admin");
-     * expect(roles).toHaveLength(3);
-     *
-     * @see {@link getAllBodyCellLocatorsByHeaderName} for getting all cell locators in a column
-     * @see {@link getJson} for getting full table data
+     * Header rows, see {@link ElementSelector}. Defaults to `"thead>tr"`, plus the leading rows of `<th>`
+     * cells (and no `<td>`) in the first `<tbody>` of a table without a `<thead>`.
      */
-    getDistinctColumnValues(headerName: string, options?: TableOptions): Promise<string[]>;
+    rowSelector?: ElementSelector;
+    /** Header cells, see {@link ElementSelector}. Defaults to `"th, td"`. */
+    columnSelector?: ElementSelector;
+  };
+  row?: {
     /**
-     * Finds the index of the first body row matching the specified conditions.
-     * Returns -1 if no matching row is found.
-     * @param conditions - Record of header names and expected cell values to match.
-     * @param options - Optional table loading options. See {@link TableOptions}.
-     * @returns A promise that resolves to the 0-based index of the first matching row, or -1 if not found.
-     * @throws Error if specified headers don't exist in the table.
-     *
-     * @example
-     * // Find index of row where Status is "Active"
-     * const index = await table.findRowIndex({ Status: "Active" });
-     * if (index >= 0) {
-     *   console.log(`Found at row ${index}`);
-     * }
-     *
-     * @example
-     * // Find row and interact with it
-     * const rowIndex = await table.findRowIndex({ Username: "john.doe" });
-     * if (rowIndex >= 0) {
-     *   const cell = table.getBodyCellLocator(rowIndex, 0);
-     *   await cell.click();
-     * }
-     *
-     * @see {@link getBodyCellLocatorByRowConditions} for getting cell locators from matching rows
-     * @see {@link waitForRowByConditions} for waiting until matching row appears
+     * Body rows, see {@link ElementSelector}. Defaults to `"tbody>tr"` (and `<tr>` right inside a
+     * `<table>` built without a `<tbody>`), without the header rows of a table without a `<thead>`.
      */
-    findRowIndex(conditions: Record<string, string>, options?: TableOptions): Promise<number>;
-    private getTable;
-    private normalizeGetBodyRowsOptions;
-    private resolveHeaderRowOptionsForJsonKeys;
-    private resolveTableOptionsForHeaderKeyMethods;
-    private resolveHeaderRowOptions;
-    private mainHeaderRow;
+    rowSelector?: ElementSelector;
+    /** Body cells, see {@link ElementSelector}. Defaults to `"td, th"`, so row header cells are columns too. */
+    columnSelector?: ElementSelector;
+  };
+  footer?: {
     /**
-     * Gets the index of a header in the main header row, throwing an error if not found.
-     * @param header - The header name to find.
-     * @param mainHeader - The main header row to search in.
-     * @returns The 0-based index of the header.
-     * @throws Error if the header is not found.
+     * Footer rows, such as a totals row, see {@link ElementSelector}. Their cells are found with
+     * `row.columnSelector`. Defaults to `"tfoot>tr"`, or no footer rows with `aria: true`. Footer rows are
+     * not body rows.
      */
-    private getHeaderIndex;
+    rowSelector?: ElementSelector;
+  };
+  /**
+   * How to go to the next page of a paginated table, so {@link TableLocator.findRow},
+   * `toJson({ allRows: true })` and {@link TableLocator.totalRowCount} see every page.
+   * See {@link PaginateOptions}.
+   */
+  paginate?: PaginateOptions;
+  /**
+   * How to scroll a virtualized grid (one that only renders the rows in view), so
+   * {@link TableLocator.findRow}, `toJson({ allRows: true })` and {@link TableLocator.totalRowCount}
+   * see every row. See {@link ScrollOptions}.
+   */
+  scroll?: ScrollOptions;
+  /**
+   * The loading indicator of the table, such as a spinner or an overlay. {@link TableLocator.waitForStable}
+   * and the page and scroll navigation wait until it is hidden.
+   */
+  loading?: LocatorRef;
+  /**
+   * Placeholder rows, such as a "No data" row, that are never body rows: `rows`, `row()`, `toJson()`,
+   * the matchers and the row counts leave them out, so an empty table has 0 body rows. See
+   * {@link ElementSelector}.
+   *
+   * @example
+   * emptyRow: ".no-data"
+   * emptyRow: { hasText: "No data" }
+   */
+  emptyRow?: ElementSelector;
+  /**
+   * Read the current value of text inputs and text areas in body cells as cell text, in row conditions,
+   * `toJson()`, `columnValues()` and the matchers, for editable grids and cells in edit mode. Text-like
+   * inputs only (`text`, `email`, `number`, `search`, `tel`, `url` and the date and time types):
+   * checkboxes, buttons, files and passwords stay out, and a `<select>` always reads as its selected option.
+   * Header cells never read their inputs, so filter fields don't end up in the header keys. Raw text
+   * (`raw: true`, a predicate's `raw`) is not affected. Defaults to `false`, like Playwright's `toHaveText`.
+   *
+   * @example
+   * const people = defineTable(page.locator("#people"), { readInputValues: true });
+   * await expect(people).toHaveRow({ Email: "john@example.org" }); // <td><input value="john@example.org"></td>
+   */
+  readInputValues?: boolean;
+  /**
+   * The control that selects a row, from the row locator, for {@link TableRow.select},
+   * {@link TableRow.deselect} and {@link TableRow.isSelected}. Defaults to the checkbox in a selection
+   * column: a column without header text (such as one with only a "select all" checkbox). A checkbox in a
+   * column with header text, such as "Active", is data and never selects the row.
+   *
+   * @example
+   * select: row => row.getByRole("checkbox", { name: "Select row" })
+   */
+  select?: (row: Locator) => Locator;
+  /**
+   * How cell text is read, for both header and body cells. Defaults to `InnerText`: the text as it is
+   * shown, without hidden text and with CSS `text-transform`. `TextContent` reads all text in the DOM,
+   * hidden text included. Either way, the text is normalized (see {@link CellCondition}).
+   */
+  cellContentType?: CellContentType;
+  /**
+   * Elements inside header and body cells whose text is left out, such as screen reader only text and
+   * icons, see {@link ElementSelector}. Defaults to {@link DEFAULT_IGNORE}: `.sr-only`, `.visually-hidden`,
+   * the Material Icons and Material Symbols classes, and `[aria-hidden=true]`.
+   *
+   * Setting it replaces the defaults. Spread them to add your own (`[...DEFAULT_IGNORE, ".sort-icon"]`),
+   * or pass `[]` to read all text. Raw values (`toJson({ raw: true })`, a predicate's `raw`) are never
+   * filtered.
+   */
+  ignore?: readonly ElementSelector[];
+};
+/**
+ * A Playwright `Locator`, or a function that finds it from the table root. A function lets an option point
+ * inside the table before the root is known, as the grid presets do.
+ *
+ * @example
+ * const next: LocatorRef = root => root.getByRole("button", { name: "Next page" });
+ */
+type LocatorRef = Locator | ((root: Locator) => Locator);
+/**
+ * Options for the `paginate` option of {@link TableLocator}.
+ *
+ * @example
+ * defineTable(page.locator("#users"), {
+ *   paginate: { next: page.getByRole("button", { name: "Next" }), first: page.getByRole("button", { name: "First" }) },
+ * });
+ */
+type PaginateOptions = {
+  /** The control that goes to the next page. */
+  next: LocatorRef;
+  /**
+   * The control that goes to the first page. When set, navigation starts by clicking it (unless the table
+   * shows the first page), so it always covers every page. Without it, navigation starts at the current
+   * page.
+   *
+   * After the click, navigation waits for the table to change. A control that stays enabled on the first
+   * page doesn't change the table, so that wait ends after 2 seconds, or after 0.5 seconds for a table with
+   * a `loading` indicator that doesn't show. Set `isFirstPage` to skip the wait altogether.
+   */
+  first?: LocatorRef;
+  /**
+   * Whether the table shows the first page, for a `first` control that stays enabled there. When it says
+   * so, `first` is not clicked; after a click, navigation waits until it says so. Defaults to: `first` is
+   * missing, hidden or disabled (see `isLastPage`), and after a click, the table changed.
+   *
+   * @example
+   * isFirstPage: async () => (await page.getByRole("button", { name: "1", exact: true }).getAttribute("aria-current")) === "page"
+   */
+  isFirstPage?: (first: Locator) => Promise<boolean>;
+  /**
+   * Whether the table shows the last page. Defaults to: `next` is missing, hidden or disabled (with the
+   * `disabled` attribute, `aria-disabled="true"` or the `disabled` class, on `next` or an element around
+   * it, such as a Bootstrap `<li class="disabled">`). When `next` matches several elements (a pager above
+   * and below the table), the first one is used.
+   */
+  isLastPage?: (next: Locator) => Promise<boolean>;
+  /**
+   * The most pages to visit, a positive integer: `3` reads the first 3 pages, also when the table has
+   * more. Defaults to every page. A table that never reaches its last page is stopped by the `timeout`.
+   */
+  maxPages?: number;
+};
+/**
+ * Options for the `scroll` option of {@link TableLocator}.
+ *
+ * Navigation scrolls the container from the top to the bottom, one step at a time, and reads the rows in
+ * view after each step. Rows are told apart by their key, so a row seen twice is read once.
+ *
+ * @example
+ * defineTable(page.getByRole("grid"), { aria: true, scroll: { container: root => root.locator(".viewport") } });
+ */
+type ScrollOptions = {
+  /**
+   * The element that scrolls. Defaults to the table root. A container that can never scroll
+   * (`overflow-y: visible`) is an error that names the element around or inside it that does.
+   */
+  container?: LocatorRef;
+  /** How far to scroll per step, in pixels. Defaults to 90% of the container height. */
+  step?: number;
+  /**
+   * The attribute of a row element that identifies the row, such as `"data-id"`. Defaults to the first
+   * of `aria-rowindex`, `row-index`, `data-rowindex`, `data-index` and `data-id` that the row has, or
+   * else the text of its cells. Rows with the same text are told apart by their order within one view,
+   * so a repeated row is not lost, but the overlap between two scroll steps can't tell which of two
+   * identical rows it shows: give such rows a key.
+   *
+   * The position attributes (all of these but `data-id`) also order the rows. Other keys only identify
+   * a row, and rows are kept in the order they were shown.
+   */
+  rowKey?: string;
+  /**
+   * How long the table must stay the same after a scroll before it is read, in
+   * milliseconds. Defaults to 50; `0` reads the rows two animation frames after the scroll. The `loading`
+   * indicator, if set, is always waited for.
+   */
+  settle?: number;
+  /**
+   * The most scroll steps per page, a positive integer. Defaults to scrolling to the bottom. A grid that
+   * keeps growing is stopped by the `timeout`.
+   */
+  maxSteps?: number;
+};
+/**
+ * Options for {@link TableLocator.findRow} and {@link TableLocator.totalRowCount}.
+ */
+type NavigationOptions = {
+  /** The time for the whole search, in milliseconds. Defaults to 30000. */
+  timeout?: number;
+};
+/**
+ * How {@link TableLocator.toJson} converts the text of a column:
+ * - `"number"`: a number, read as {@link DecimalSeparator} describes; an empty cell is `null`.
+ * - `"date"`: a `Date`, parsed with `Date.parse`; an empty cell is `null`.
+ * - A function: called in Node with the cell text, so it can use test variables. Its result is the value.
+ *
+ * A cell that `"number"` or `"date"` cannot parse, or a function that throws, fails `toJson()` with the
+ * row, the column and the text.
+ */
+type ColumnParser = "number" | "date" | ((text: string) => unknown);
+/**
+ * `T`, but not a place to infer `T` from: like `NoInfer`, which needs TypeScript 5.4.
+ * @internal
+ */
+type NotInferred<T> = [T][T extends unknown ? 0 : never];
+/** The {@link ColumnParser}s of {@link TableJsonOptions.parse}, by header key. */
+type ColumnParsers<C extends string> = { readonly [K in C]?: ColumnParser; };
+/** The value a {@link ColumnParser} produces. */
+type ParsedValue<P> = P extends "number" ? number | null : P extends "date" ? Date | null : P extends ((text: string) => infer R) ? R : string;
+/**
+ * One row of {@link TableLocator.toJson}: the text of every column in `C`, or the parsed value for the
+ * columns in `P`.
+ */
+type TableJsonRow<C extends string, P = {}> = { [K in C]: K extends keyof P ? ParsedValue<P[K]> : string; };
+/**
+ * Options for {@link TableLocator.waitForStable}.
+ *
+ * @example
+ * await users.waitForStable({ quiet: 300, loading: page.getByRole("progressbar") });
+ */
+type StableOptions = {
+  /**
+   * How long the header keys and body cell texts must stay the same, in milliseconds. Defaults to 500.
+   */
+  quiet?: number;
+  /** The time to wait in milliseconds. Defaults to 5000. */
+  timeout?: number;
+  /**
+   * A loading indicator, such as a spinner or an overlay. The table is only stable while it is hidden
+   * (not attached, or not visible), so a table that is about to refresh isn't read too early.
+   */
+  loading?: LocatorRef;
+};
+/**
+ * Options for {@link TableLocator.toJson}.
+ *
+ * @example
+ * await users.toJson({ minRows: 1, timeout: 10_000 });
+ *
+ * @example
+ * // Some columns, with typed values
+ * await orders.toJson({ columns: ["Id", "Total"], parse: { Total: "number" }, decimal: "," });
+ */
+type TableJsonOptions<C extends string = string, P = {}> = {
+  /**
+   * Only these columns, in this order. Defaults to every column of the main header row. A key that is not
+   * a header key of the table fails `toJson()` with the available headers.
+   */
+  columns?: readonly C[];
+  /** Converts the text of some columns to typed values, see {@link ColumnParser}. */
+  parse?: P & ColumnParsers<NotInferred<C>>;
+  /** The decimal separator of the `"number"` columns of `parse`. Defaults to `"."`. */
+  decimal?: DecimalSeparator;
+  /**
+   * Wait until the table stops changing before reading it, see {@link TableLocator.waitForStable}.
+   * `true` uses the default options. The `timeout` of the stable options defaults to (and can't exceed)
+   * the time left of `timeout`.
+   */
+  stable?: boolean | StableOptions;
+  /**
+   * Read every row: on every page with the `paginate` option, and from top to bottom with the `scroll`
+   * option of the table. `minRows` and `stable` apply to the first view. Defaults to `false`: the rows the
+   * table shows now.
+   *
+   * It leaves the table on its last page, scrolled down; without `paginate.first`, the next read starts
+   * there. It reads up to `paginate.maxPages` and `scroll.maxSteps`, if set. Reaching the `timeout` before that
+   * is an error that says how many rows were read, so part of the rows is never returned as all of them.
+   */
+  allRows?: boolean;
+  /**
+   * Wait for a header row and at least this many body rows with content (a row where at least one cell
+   * has text) before reading. Defaults to `0`: read once, without waiting.
+   */
+  minRows?: number;
+  /**
+   * With `minRows` or `stable`, the time for the whole read, waits included, in milliseconds (default
+   * 5000). With `allRows`, the time for the whole read, pages and scrolling included (default 30000).
+   * Without any of them, the time to wait for the table element to be attached.
+   */
+  timeout?: number;
+  /**
+   * Return every body cell as the browser reads it (`innerText`, or `textContent`), without any
+   * normalization: line breaks, tabs, non-breaking spaces, icon glyphs and visually hidden text stay.
+   * Header keys are normalized either way. Defaults to `false`.
+   */
+  raw?: boolean;
+};
+/** Filter options accepted by `Locator.filter()`. */
+export type RowFilterOptions = Parameters<Locator["filter"]>[0];
+/**
+ * One or more body rows of a {@link TableLocator}, with typed access to their cells.
+ *
+ * Instances are created by {@link TableLocator.row}, {@link TableLocator.rowAt} and {@link TableLocator.rows}.
+ * Their locators read like your code in error messages and traces, such as
+ * `locator('#users').row({ "Name": "John" }).cell("Status")` (Playwright 1.53 and later).
+ *
+ * @example
+ * const row = table.row({ Name: "John" });
+ * await expect(row.locator).toBeVisible();
+ * await expect(row.cell("Status")).toHaveText("Active");
+ */
+export declare class TableRow<H extends string = string> {
+  readonly table: TableLocator<H>;
+  readonly locator: Locator;
+  /**
+   * @param table - The table this row belongs to.
+   * @param locator - The Playwright `Locator` for the row element(s). Its `toString()` is used to describe
+   *   the locators built from this row.
+   */
+  constructor(table: TableLocator<H>, locator: Locator);
+  /**
+   * Returns the cell of this row under `column`.
+   * If this row locator matches several rows, the cell locator matches one cell per row.
+   *
+   * @param column - The header key of the column, or its 0-based index (also works without header rows).
+   * @returns A Playwright Locator for the cell.
+   *
+   * @example
+   * await table.row({ Name: "John" }).cell("Email").click();
+   *
+   * @example
+   * // By column index, for example in a table without header rows
+   * await expect(table.rowAt(0).cell(2)).toHaveText("john@example.com");
+   */
+  cell(column: ColumnKey<H>): Locator;
+  /**
+   * The first of these rows, with typed cell access. Use it when several rows may match and any is fine.
+   *
+   * @example
+   * await table.row({ Status: "Active" }).first().cell("Edit").click();
+   */
+  first(): TableRow<H>;
+  /**
+   * The last of these rows, with typed cell access.
+   *
+   * @example
+   * await expect(table.rows.last().cell("Name")).toHaveText("Jane");
+   */
+  last(): TableRow<H>;
+  /**
+   * The row at `index` among these rows, with typed cell access. Negative indexes count from the end,
+   * like `Locator.nth()`.
+   *
+   * @param index - The 0-based index among these rows.
+   * @returns A {@link TableRow} for the row.
+   * @throws Error if index is not an integer.
+   *
+   * @example
+   * await expect(table.row({ Status: "Active" }).nth(1).cell("Name")).toHaveText("Joe");
+   */
+  nth(index: number): TableRow<H>;
+  /**
+   * Narrows these rows with `Locator.filter()` and keeps typed cell access.
+   *
+   * @param options - The same options as `Locator.filter()`.
+   * @returns A new {@link TableRow} for the filtered rows.
+   *
+   * @example
+   * await expect(table.rows.filter({ hasText: "Jane" }).cell("Status")).toHaveText("Active");
+   */
+  filter(options?: RowFilterOptions): TableRow<H>;
+  /**
+   * Fills the controls in the cells of this row, one column after the other. A boolean checks or unchecks
+   * a checkbox or switch; a string selects an option of a `<select>`, or fills an input, a text area or
+   * an editable element.
+   *
+   * A cell without a control is edited in place, as data grids do: it is double-clicked, the editor that
+   * appears in the cell is filled, and `commit` is pressed. Editors that open outside the cell (a popup)
+   * are not found.
+   *
+   * Columns are filled in the order of `values`. When the row is found by the value of a column you fill,
+   * fill that column last: after it changes, the row no longer matches.
+   *
+   * @param values - The value per column.
+   * @param options - Optional settings.
+   * @param options.commit - (Optional) The key that ends in-place editing. Defaults to `"Enter"`; `false` presses nothing.
+   * @param options.timeout - (Optional) The time per action, in milliseconds. Defaults to 5000.
+   * @throws Error if a cell has no control, also not after a double-click.
+   *
+   * @example
+   * await users.row({ Name: "John" }).fill({ Email: "john@example.org", Active: false, Role: "Admin" });
+   */
+  fill(values: { [K in HeaderKey<H>]?: string | boolean; }, options?: {
+    commit?: string | false;
+    timeout?: number;
+  }): Promise<void>;
+  /**
+   * Selects this row: checks its selection checkbox (see the `select` option of {@link TableLocator}), or
+   * clicks the row if it has none, and waits until the row is selected (see {@link isSelected}). A
+   * selected row is left as it is.
+   *
+   * @param options - Optional timeout, in milliseconds. Defaults to 5000.
+   * @throws Error if the row is not selected within the timeout.
+   *
+   * @example
+   * await users.row({ Name: "John" }).select();
+   * await expect(users.row({ Name: "John" })).toBeSelected();
+   */
+  select(options?: {
+    timeout?: number;
+  }): Promise<void>;
+  /**
+   * Deselects this row: unchecks its selection checkbox, or clicks the row if it has none, and waits
+   * until the row is not selected. A row that is not selected is left as it is.
+   *
+   * @param options - Optional timeout, in milliseconds. Defaults to 5000.
+   * @throws Error if the row is still selected after the timeout.
+   */
+  deselect(options?: {
+    timeout?: number;
+  }): Promise<void>;
+  /**
+   * Whether this row is selected. A row with `aria-selected` is selected when it is `"true"`. Otherwise,
+   * the row is selected when its selection checkbox is checked (see the `select` option of
+   * {@link TableLocator}). Reads the row once; for a retrying check, use `expect(row).toBeSelected()`.
+   *
+   * @param options - Optional timeout for finding the row, in milliseconds.
+   * @returns A promise that resolves to whether the row is selected.
+   */
+  isSelected(options?: {
+    timeout?: number;
+  }): Promise<boolean>;
+  /**
+   * Expands this row of a tree grid, and waits until it is expanded. An expanded row is left as it is.
+   * It clicks `toggle`, or else the element in the row with `aria-expanded` (not a menu button, which has
+   * `aria-haspopup`), or else, when the row itself has `aria-expanded`, the button in its first cell.
+   * Without any of them, it focuses the row and presses `ArrowRight`, as tree grids do.
+   *
+   * @param options - Optional settings.
+   * @param options.toggle - (Optional) The control that expands and collapses the row, from the row locator.
+   * @param options.timeout - (Optional) The time to wait, in milliseconds. Defaults to 5000.
+   * @throws Error if the row has no `aria-expanded` (on the row or an element in it), or doesn't expand.
+   *
+   * @example
+   * await files.row({ Name: "src" }).expand();
+   * await expect(files.row({ Name: "index.ts" }).locator).toBeVisible();
+   */
+  expand(options?: {
+    toggle?: (row: Locator) => Locator;
+    timeout?: number;
+  }): Promise<void>;
+  /**
+   * Collapses this row of a tree grid, like {@link expand} does, but with `ArrowLeft` as the fallback.
+   *
+   * @param options - Optional settings, the same as for {@link expand}.
+   * @throws Error if the row has no `aria-expanded` (on the row or an element in it), or doesn't collapse.
+   */
+  collapse(options?: {
+    toggle?: (row: Locator) => Locator;
+    timeout?: number;
+  }): Promise<void>;
+  /**
+   * Whether this row is expanded: the `aria-expanded` of the row, or else of the first element in it that
+   * has one and is not a menu button (with `aria-haspopup`). `null` if there is none, for a row that
+   * cannot expand.
+   *
+   * @param options - Optional settings.
+   * @param options.timeout - (Optional) The time to wait for the row, in milliseconds.
+   * @returns A promise that resolves to `true`, `false` or `null`.
+   */
+  isExpanded(options?: {
+    timeout?: number;
+  }): Promise<boolean | null>;
+  /**
+   * The `aria-level` of this row in a tree grid (1 for the top level), or `null` if it has none.
+   *
+   * @param options - Optional settings.
+   * @param options.timeout - (Optional) The time to wait for the row, in milliseconds.
+   * @example
+   * expect(await files.row({ Name: "index.ts" }).level()).toBe(2);
+   */
+  level(options?: {
+    timeout?: number;
+  }): Promise<number | null>;
+  /**
+   * The control that selects this row: the `select` option of the table, or else the checkbox in the
+   * first column without header text (in a table without header rows, the first column) that has one.
+   * `undefined` if there is none.
+   */
+  private selectionControl;
+  /**
+   * The control that expands and collapses this row: `toggle` (waited for, as you passed it), or else the
+   * element in the row with `aria-expanded` that is not a menu button, or else, when the row itself has
+   * `aria-expanded`, the button in its first cell. `undefined` if there is none.
+   * @throws Error if `toggle` doesn't show up.
+   */
+  private expandToggle;
+  private setSelected;
+  private setExpanded;
+}
+/**
+ * A type-safe table API that only returns Playwright `Locator`s.
+ *
+ * Header names are resolved to columns inside the browser by the `pw-table-v1` selector engine on every
+ * evaluation, so every locator auto-waits for late headers and rows, and keeps working when columns are
+ * reordered at runtime. Building locators is synchronous.
+ *
+ * Text is read as the user sees it. Header text is one line: `First<br>name` is the header `"First name"`.
+ * Body cells keep their line breaks as one `\n`. Icon glyphs, invisible characters and the text of the elements
+ * matching the `ignore` option (screen reader only text and icons by default) are left out. Header names
+ * you pass are normalized the same way.
+ *
+ * The `pw-table-v1` selector engine must be registered first: import `test` from this package, or call
+ * {@link registerTableSelectors} before the page is created.
+ *
+ * @example
+ * import { test, expect, TableLocator } from "@cerios/playwright-table";
+ *
+ * test("user is active", async ({ page }) => {
+ *   const users = new TableLocator(page.locator("table"), { headers: ["Name", "Status", "Email"] });
+ *   await expect(users.row({ Name: "John" }).cell("Status")).toHaveText("Active");
+ * });
+ */
+export declare class TableLocator<const H extends string = string> {
+  /** The Playwright `Locator` pointing to the root table element. */
+  readonly root: Locator;
+  private readonly _config;
+  private readonly _headers;
+  private readonly _loading;
+  private readonly _navigator;
+  private readonly _rowKey;
+  private readonly _select;
+  /**
+   * Creates a table with customizable selectors for headers and rows.
+   *
+   * Rows and cells inside a cell (such as a nested table) never belong to this table, and both `<th>`
+   * and `<td>` count as cells in header and body rows. `PlaywrightTable` only takes `<th>` in header rows
+   * and `<td>` in body rows.
+   *
+   * @param root - The Playwright `Locator` pointing to the root table element.
+   * @param options - Optional configuration. See {@link TableLocatorOptions}.
+   * @param options.headers - (Optional) Header names, used for typed header keys and {@link validateHeaders}.
+   * @param options.aria - (Optional) Use ARIA roles for the default selectors. Defaults to `false`.
+   * @param options.header.setMainHeaderRow - (Optional) Index of the main header row. Defaults to the last header row.
+   * @param options.header.rowSelector - (Optional) Header rows: a CSS selector or an {@link ElementSelector} descriptor. Defaults to `"thead>tr"`, plus the leading `<th>`-only rows of a table without `<thead>`.
+   * @param options.header.columnSelector - (Optional) Header cells, see {@link ElementSelector}. Defaults to `"th, td"`.
+   * @param options.row.rowSelector - (Optional) Body rows, see {@link ElementSelector}. Defaults to `"tbody>tr"`, without those header rows.
+   * @param options.row.columnSelector - (Optional) Body cells, see {@link ElementSelector}. Defaults to `"td, th"`.
+   * @param options.cellContentType - (Optional) How cell text is read. Defaults to `InnerText`.
+   * @param options.ignore - (Optional) Elements inside cells whose text is left out, see {@link ElementSelector}. Defaults to {@link DEFAULT_IGNORE}.
+   * @param options.footer.rowSelector - (Optional) Footer rows, see {@link ElementSelector}. Defaults to `"tfoot>tr"`, or none with `aria`.
+   * @param options.paginate - (Optional) How to go to the next page, see {@link PaginateOptions}.
+   * @param options.scroll - (Optional) How to scroll a virtualized grid, see {@link ScrollOptions}.
+   * @param options.loading - (Optional) The loading indicator of the table.
+   * @param options.emptyRow - (Optional) Placeholder rows, such as a "No data" row, that are never body rows, see {@link ElementSelector}.
+   * @param options.readInputValues - (Optional) Read the value of text inputs in body cells as cell text. Defaults to `false`.
+   * @param options.select - (Optional) The control that selects a row, from the row locator. Defaults to the checkbox in a selection column.
+   *
+   * @example
+   * // Typed headers: header arguments are checked at compile time
+   * const users = new TableLocator(page.locator("table"), { headers: ["Name", "Status"] });
+   *
+   * @example
+   * // Div based table with custom selectors
+   * const table = new TableLocator(page.locator(".divTable"), {
+   *   header: { rowSelector: ".divTableHeading > .divTableRow", columnSelector: ".divTableHead" },
+   *   row: { rowSelector: ".divTableBody > .divTableRow", columnSelector: ".divTableCell" },
+   * });
+   *
+   * @example
+   * // ARIA grid, such as AG Grid or MUI Data Grid
+   * const grid = new TableLocator(page.getByRole("grid"), { aria: true });
+   *
+   * @example
+   * // Rows by role and text instead of CSS
+   * const orders = new TableLocator(page.locator("#orders"), {
+   *   row: { rowSelector: { role: "row", hasNotText: "Loading" } },
+   *   emptyRow: { hasText: "No data" },
+   * });
+   */
+  constructor(root: Locator, options?: TableLocatorOptions<H>);
+  /**
+   * The footer rows of the table, such as a totals row, with typed cell access. Footer rows are not body
+   * rows: `rows`, `row()`, `toJson()` and the matchers leave them out.
+   *
+   * @example
+   * await expect(orders.footer.cell("Total")).toHaveText("€ 1,295.75");
+   */
+  get footer(): TableRow<H>;
+  /**
+   * All body rows of the table.
+   *
+   * @example
+   * await expect(table.rows.locator).toHaveCount(3);
+   *
+   * @example
+   * // Compose with Locator.filter and keep typed cell access
+   * await expect(table.rows.filter({ hasText: "Jane" }).cell("Status")).toHaveText("Active");
+   */
+  get rows(): TableRow<H>;
+  /**
+   * Body rows where every condition matches. Conditions are keyed by header; values are an exact
+   * string, a RegExp, or a {@link CellCondition}. Cell text is compared as the user sees it (see
+   * {@link CellCondition}), and header names are normalized like header text.
+   *
+   * The returned locator follows Playwright's strict mode: acting on it when several rows match throws.
+   *
+   * @param where - At least one condition. Unknown headers are compile-time errors.
+   * @returns A {@link TableRow} for the matching rows.
+   * @throws Error if no condition has a value.
+   *
+   * @example
+   * await expect(table.row({ Name: "John", Status: /active/i }).cell("Email")).toHaveText("john@example.com");
+   *
+   * @example
+   * // Declarative conditions
+   * await table.row({ Name: { startsWith: "Jo" }, Remarks: { empty: true } }).cell("Actions").click();
+   */
+  row<W extends RowWhere<H>>(where: W & ValidRowWhere<H, W>): TableRow<H>;
+  /** {@link row}, without the compile-time checks of the conditions. */
+  private matchingRows;
+  /**
+   * The body row at `index`.
+   *
+   * @param index - The row number (0-based).
+   * @returns A {@link TableRow} for the row.
+   * @throws Error if index is not a non-negative integer.
+   *
+   * @example
+   * await expect(table.rowAt(0).cell("Name")).toHaveText("John");
+   */
+  rowAt(index: number): TableRow<H>;
+  /**
+   * The cell under `column` for any row locator, for example one built with `filter()` or `nth()`.
+   *
+   * @param row - A locator for one or more body rows of this table.
+   * @param column - The header key of the column, or its 0-based index (also works without header rows).
+   * @returns A Playwright Locator for the cell.
+   * @throws Error if column is a number that is not a non-negative integer.
+   *
+   * @example
+   * const lastRow = table.rows.locator.last();
+   * await expect(table.cell(lastRow, "Name")).toHaveText("Jane");
+   */
+  cell(row: Locator, column: ColumnKey<H>): Locator;
+  /**
+   * All body cells under `column`. A cell spanning several rows is included once.
+   *
+   * @param column - The header key of the column, or its 0-based index (also works without header rows).
+   * @returns A Playwright Locator for the cells.
+   * @throws Error if column is a number that is not a non-negative integer.
+   *
+   * @example
+   * await expect(table.column("Status")).toHaveText(["Active", "Inactive", "Active"]);
+   * await expect(table.column(1)).toHaveText(["Active", "Inactive", "Active"]);
+   */
+  column(column: ColumnKey<H>): Locator;
+  /**
+   * The header cell element for `column` in the main header row.
+   *
+   * @param column - The header key of the column, or its 0-based index.
+   * @returns A Playwright Locator for the header cell.
+   * @throws Error if column is a number that is not a non-negative integer.
+   *
+   * @example
+   * await table.header("Name").click(); // sort by name
+   */
+  header(column: ColumnKey<H>): Locator;
+  /**
+   * Reads the current header keys of the main header row, exactly as the engine resolves them
+   * (including `__C`/`__D` suffixes and `{{Empty}}`). This is a snapshot, not a locator.
+   *
+   * @param options - Optional timeout for waiting until the table element is attached.
+   * @returns A promise that resolves to the header keys, or an empty array if there are no header rows.
+   *
+   * @example
+   * expect(await table.headerKeys()).toEqual(["Name", "Status", "Email"]);
+   */
+  headerKeys(options?: {
+    timeout?: number;
+  }): Promise<string[]>;
+  /**
+   * Reads every body row as an object keyed by header key, like `PlaywrightTable.getJson()`. Cells that
+   * span rows or columns are repeated in every position they cover; positions without a cell are `""`.
+   * Cell text is normalized as in row conditions: line breaks stay as one `\n` between trimmed lines.
+   * With `raw: true`, cells are returned exactly as the browser reads them.
+   *
+   * This is a snapshot, not a locator: without `minRows` or `stable` it reads the table once and does not
+   * wait for rows. With `minRows`, it first waits for a header row and at least that many body rows with
+   * content (a row where at least one cell has text), so empty placeholder rows don't count. With
+   * `stable`, it then waits until the table stops changing (see {@link waitForStable}). To wait for
+   * specific content, assert first (for example with `toHaveRow` or `toHaveRows`).
+   *
+   * @param options - Optional settings. See {@link TableJsonOptions}.
+   * @param options.columns - (Optional) Only these columns, in this order. Defaults to every column.
+   * @param options.parse - (Optional) Typed values for some columns: `"number"`, `"date"` or a function.
+   * @param options.decimal - (Optional) The decimal separator of `"number"` columns. Defaults to `"."`.
+   * @param options.minRows - (Optional) Wait for at least this many body rows with content. Defaults to `0` (no waiting).
+   * @param options.stable - (Optional) Wait until the table stops changing before reading it. Defaults to `false`.
+   * @param options.timeout - (Optional) With `minRows` or `stable`, the time to wait in milliseconds (default 5000).
+   *   Without them, the time to wait for the table element to be attached.
+   * @param options.raw - (Optional) Return the cell texts without normalization. Defaults to `false`.
+   * @returns A promise that resolves to one object per body row, or an empty array if there are no body rows.
+   * @throws Error if the table has no header row (without `minRows`).
+   * @throws Error if a key of `columns` or `parse` is not a header key of the table, with the available headers.
+   * @throws Error if a cell of a `parse` column cannot be parsed, with the row, the column and the text.
+   * @throws Error if `minRows` is not reached, or the table doesn't become stable, within the timeout.
+   * @throws Error if `minRows` is not a non-negative integer.
+   *
+   * @example
+   * expect(await users.toJson()).toEqual([
+   *   { Name: "John", Status: "Active" },
+   *   { Name: "Jane", Status: "Inactive" },
+   * ]);
+   *
+   * @example
+   * // Wait until at least one row is loaded
+   * const data = await users.toJson({ minRows: 1 });
+   *
+   * @example
+   * // Some columns, with typed values: { Id: string; Total: number | null }[]
+   * const totals = await orders.toJson({ columns: ["Id", "Total"], parse: { Total: "number" } });
+   */
+  toJson<const C extends HeaderKey<H> = HeaderKey<H>, const P extends ColumnParsers<C> = Record<never, never>>(options?: TableJsonOptions<C, P>): Promise<TableJsonRow<C, P>[]>;
+  /**
+   * Reads the text of every body cell under `column`, one per body row. A cell that spans rows is
+   * repeated in every row it covers; a row without a cell there reads as `""`. Text is normalized as in
+   * row conditions.
+   *
+   * This is a snapshot, not a locator: it reads the table once. To wait for content, assert first, or
+   * use `toHaveColumnValues`.
+   *
+   * @param column - The header key of the column, or its 0-based index (also works without header rows).
+   * @param options - Optional timeout for waiting until the table element is attached.
+   * @returns A promise that resolves to the cell texts, or an empty array if there are no body rows.
+   * @throws Error if the table has no such column, with the available headers.
+   *
+   * @example
+   * expect(await users.columnValues("Status")).toEqual(["Active", "Inactive", "Active"]);
+   *
+   * @example
+   * // The distinct values of a column
+   * const statuses = new Set(await users.columnValues("Status"));
+   */
+  columnValues(column: ColumnKey<H>, options?: {
+    timeout?: number;
+  }): Promise<string[]>;
+  /**
+   * Waits until the table stops changing: the header keys and the text of every body cell stay the same
+   * for `quiet` milliseconds, and the `loading` indicator (if any) is hidden. Use it after an action that
+   * refreshes the table (searching, filtering, paging, sorting) before you read it with a snapshot method
+   * such as {@link toJson}.
+   *
+   * Locators and the table matchers retry by themselves and don't need it. A table that has not started
+   * to refresh yet looks stable, so pass `loading` when the table shows an indicator while it loads.
+   *
+   * @param options - Optional settings. See {@link StableOptions}.
+   * @param options.quiet - (Optional) How long nothing may change, in milliseconds. Defaults to 500.
+   * @param options.timeout - (Optional) The time to wait in milliseconds. Defaults to 5000.
+   * @param options.loading - (Optional) A loading indicator that must be hidden. Defaults to the `loading` option of the table.
+   * @returns A promise that resolves once the table is stable.
+   * @throws Error if the table is not stable within the timeout: it kept changing, the loading indicator
+   *   stayed visible, or the table could not be read.
+   *
+   * @example
+   * await page.getByLabel("Search").fill("Jo");
+   * await users.waitForStable({ loading: page.locator(".spinner") });
+   * const rows = await users.toJson();
+   */
+  waitForStable(options?: StableOptions): Promise<void>;
+  /**
+   * Finds a body row on any page or scroll position: it searches the rows in view, then (with the
+   * `paginate` and `scroll` options) goes through the pages from the first one (with `paginate.first`)
+   * and scrolls each page from the top, until a row matches. The table is left showing that row, and the
+   * returned row locator resolves to it.
+   *
+   * Without `paginate` and `scroll`, it waits until a row in view matches, like a locator.
+   *
+   * @param where - At least one condition, as for {@link row}.
+   * @param options - Optional timeout for the whole search, in milliseconds. Defaults to 30000.
+   * @returns A promise that resolves to the {@link TableRow} for `row(where)`.
+   * @throws Error if no row matches on any page (or within `paginate.maxPages` and `scroll.maxSteps`), with
+   * the number of pages and scroll steps searched, and whether the search stopped early at the timeout.
+   *
+   * @example
+   * const orders = defineTable(page.getByRole("grid"), {
+   *   aria: true,
+   *   paginate: { next: page.getByRole("button", { name: "Next page" }) },
+   * });
+   * const row = await orders.findRow({ Id: "1042" });
+   * await row.cell("Status").click();
+   */
+  findRow<W extends RowWhere<H>>(where: W & ValidRowWhere<H, W>, options?: NavigationOptions): Promise<TableRow<H>>;
+  /**
+   * The number of body rows in the whole table, also the rows that are not rendered or are on other pages.
+   *
+   * - A grid with `aria-rowcount` (on the root, inside it or around it) declares it: `aria-rowcount` minus
+   *   the rows it counts that are not body rows, such as header rows.
+   * - Otherwise, with the `paginate` or `scroll` option, every row is read, as `toJson({ allRows: true })` does.
+   *   That leaves the table on its last page, scrolled down.
+   * - Otherwise, the number of body rows.
+   *
+   * @param options - Optional timeout, in milliseconds. Defaults to 30000.
+   * @returns A promise that resolves to the number of body rows.
+   * @throws Error if it reads every row and the timeout passes before the end of the table.
+   *
+   * @example
+   * expect(await grid.totalRowCount()).toBe(200);
+   */
+  totalRowCount(options?: NavigationOptions): Promise<number>;
+  /**
+   * The body rows in view as an aligned text table, with the row index in front, for logs and debugging.
+   * Cells longer than 30 characters are cut off, and line breaks show as `↵`.
+   *
+   * @param options - Optional settings.
+   * @param options.columns - (Optional) Only these columns. Unknown columns are skipped; if none is known,
+   * every column is shown. Defaults to every column.
+   * @param options.maxRows - (Optional) The most rows to show. Defaults to 50.
+   * @param options.timeout - (Optional) The time to wait for the table, in milliseconds.
+   * @returns A promise that resolves to the table as text.
+   *
+   * @example
+   * console.log(await users.format());
+   * //   # | Name | Status
+   * //   0 | John | Active
+   * //   1 | Jane | Inactive
+   */
+  format(options?: {
+    columns?: readonly ColumnKey<H>[];
+    maxRows?: number;
+    timeout?: number;
+  }): Promise<string>;
+  /**
+   * Waits until every expected header exists, and fails fast with the available headers if they don't.
+   *
+   * @param expected - The headers to check. Defaults to the `headers` option of this table.
+   * @param options - Optional timeout in milliseconds. Defaults to 5000.
+   * @returns A promise that resolves once all headers exist.
+   * @throws Error listing the missing and available headers when the timeout is reached.
+   * @throws Error if there are no headers to check.
+   *
+   * @example
+   * const users = new TableLocator(page.locator("table"), { headers: ["Name", "Status"] });
+   * await users.validateHeaders();
+   * // Error: Missing headers: [Status]
+   * //        Available headers: [Name, State]
+   */
+  validateHeaders(expected?: readonly HeaderKey<H>[], options?: {
+    timeout?: number;
+  }): Promise<void>;
+  /** The texts for `toJson()`: read once, or after waiting for `minRows` and `stable`. */
+  private readJsonTexts;
+  /**
+   * The waits of `toJson()`: for `minRows` (with the texts it read), then until the table is `stable`,
+   * each within the time `left`.
+   */
+  private waitForJson;
+  /** @throws Error if the table has no header row, which `toJson()` needs for its keys. */
+  private checkJsonHeader;
+  /**
+   * Checks the `columns` and `parse` options of `toJson()` against the header keys of the table.
+   * @throws Error with the available headers if a key is not a header key, or a `parse` key is not in `columns`.
+   */
+  private checkJsonColumns;
+  /** The loading indicator for `loading`, or else the `loading` option of the table. */
+  private resolveLoading;
+  /** A fingerprint of the header keys and body cell texts, and the number of body rows. */
+  private fingerprint;
+  /**
+   * Reads every row on every page and scroll position. Rows are told apart by their key per page, and
+   * ordered by their index when every row has one. Header keys are merged across positions, so a grid
+   * that renders only some columns at a time still gets every column it showed.
+   *
+   * @throws Error if the deadline passes before every row is read (up to `paginate.maxPages` and
+   * `scroll.maxSteps`), so part of the rows is never returned as all of them.
+   */
+  private readAllTexts;
+  private readTexts;
+  /** Reads the table once it has a header row and at least `minRows` body rows with content. */
+  private readTextsWithRows;
+  private selector;
 }
-
-export { type BodyRow, type Cell, CellContentType, type HeaderRow, type HeaderRowOptions, PlaywrightTable, type PollingOptions, type TableOptions };
+/**
+ * Creates a {@link TableLocator}. Header names passed in `options.headers` are inferred as literal
+ * types, so header arguments are checked and autocompleted.
+ *
+ * @param root - The Playwright `Locator` pointing to the root table element.
+ * @param options - Optional configuration. See {@link TableLocatorOptions}.
+ * @returns A new {@link TableLocator}.
+ *
+ * @example
+ * const users = defineTable(page.locator("#users"), { headers: ["Name", "Status", "Email"] });
+ * await expect(users.row({ Name: "John" }).cell("Email")).toHaveText("john@example.com");
+ * // @ts-expect-error "Nme" is not a header of this table
+ * users.row({ Nme: "John" });
+ */
+export declare function defineTable<const H extends string = string>(root: Locator, options?: TableLocatorOptions<H>): TableLocator<H>;
+/**
+ * {@link TableLocatorOptions} without `headers`, so a preset can be spread into options with your own
+ * typed headers.
+ */
+type TablePreset = Omit<TableLocatorOptions<string>, "headers">;
+/**
+ * Options for AG Grid (tested with AG Grid Community 36): ARIA roles, the header rows without the
+ * floating filter row, the pinned top and bottom rows (such as totals) as footer rows, the body viewport to scroll, the
+ * pagination panel, and the loading overlay. The table root is the element you created the grid in, or
+ * any element inside it that holds the whole grid.
+ *
+ * AG Grid also renders only the columns in view (column virtualization). Rows are read with every
+ * column AG Grid has rendered; to read columns outside the view, turn it off with
+ * `suppressColumnVirtualisation: true`, or make the grid wide enough in your tests.
+ *
+ * @example
+ * const cars = defineTable(page.locator("#myGrid"), { ...presets.agGrid(), headers: ["Make", "Model", "Price"] });
+ * const row = await cars.findRow({ Model: "Model 150" });
+ * await expect(cars).toHaveTotalRowCount(200);
+ */
+declare function agGrid(): TablePreset;
+/**
+ * Options for MUI X Data Grid (based on the markup of version 7 and 8): ARIA roles, the row and cell
+ * classes (without filler and skeleton cells), the virtual scroller, the pagination buttons, and the
+ * loading indicator. The table root is the `.MuiDataGrid-root` element, such as `page.getByRole("grid")`.
+ *
+ * @example
+ * const users = defineTable(page.getByRole("grid"), presets.muiDataGrid());
+ * await expect(users).toHaveTotalRowCount(100);
+ */
+declare function muiDataGrid(): TablePreset;
+/**
+ * Options for an Angular Material table (`mat-table`, as a native `<table>` or with the `<mat-table>`
+ * elements), in both the MDC (`mat-mdc-*`) and the legacy class names. The "no data" row is not a body
+ * row, and footer rows are footer rows. With `paginator`, the `mat-paginator` that pages the table: a
+ * `Locator`, or a function that finds it from the table root.
+ *
+ * @example
+ * const orders = defineTable(page.locator("table[mat-table]"), presets.angularMaterial({ paginator: page.locator("mat-paginator") }));
+ * const row = await orders.findRow({ Id: "42" });
+ */
+declare function angularMaterial(options?: {
+  paginator?: LocatorRef;
+}): TablePreset;
+/**
+ * Options for a table virtualized with TanStack Virtual (`@tanstack/react-virtual` and friends), which
+ * renders only the rows in view and marks each with `data-index`. TanStack Table itself renders plain
+ * HTML tables, which work without a preset.
+ *
+ * @param options.container - The element that scrolls, usually a `div` around the table.
+ *
+ * @example
+ * const rows = defineTable(page.locator("table"), presets.tanstackVirtual({ container: page.locator(".scroll-container") }));
+ * const all = await rows.toJson({ allRows: true });
+ */
+declare function tanstackVirtual(options: {
+  container: Locator;
+}): TablePreset;
+/**
+ * Ready-made {@link TableLocatorOptions} for popular data grids. Spread a preset into your own options to
+ * add typed headers or change a setting.
+ *
+ * @example
+ * const grid = defineTable(page.locator("#grid"), { ...presets.agGrid(), headers: ["Id", "Name"] });
+ */
+export declare const presets: {
+  agGrid: typeof agGrid;
+  muiDataGrid: typeof muiDataGrid;
+  angularMaterial: typeof angularMaterial;
+  tanstackVirtual: typeof tanstackVirtual;
+};
+/**
+ * Registers the `pw-table-v1` selector engine used by {@link TableLocator}.
+ *
+ * Safe to call more than once: later calls reuse the first registration, and an
+ * "already registered" error (for example from another copy of this package) is ignored.
+ *
+ * Registration must happen **before the page is created**. You don't need this function if you
+ * import `test` from this package, which registers the engine with a worker-scoped auto fixture.
+ *
+ * @param target - The Playwright `selectors` object to register on. Defaults to `selectors` from `@playwright/test`.
+ * @returns A promise that resolves once the engine is registered.
+ *
+ * @example
+ * // With your own test fixtures
+ * import { test as base } from "@playwright/test";
+ * import { registerTableSelectors } from "@cerios/playwright-table";
+ *
+ * export const test = base.extend<{}, { tableSelectors: void }>({
+ *   tableSelectors: [async ({ playwright }, use) => {
+ *     await registerTableSelectors(playwright.selectors);
+ *     await use();
+ *   }, { scope: "worker", auto: true }],
+ * });
+ *
+ * @example
+ * // Without fixtures
+ * test.beforeAll(async () => {
+ *   await registerTableSelectors();
+ * });
+ */
+export declare function registerTableSelectors(target?: Selectors): Promise<void>;
+/**
+ * Playwright `test` with the `pw-table-v1` selector engine registered for every worker, so
+ * {@link TableLocator} works without any setup. Use it instead of `test` from `@playwright/test`.
+ *
+ * The engine is registered by a worker-scoped auto fixture, so it is always registered before
+ * any page is created.
+ *
+ * @example
+ * import { test, expect, defineTable } from "@cerios/playwright-table";
+ *
+ * test("shows the user", async ({ page }) => {
+ *   const users = defineTable(page.locator("table"), { headers: ["Name", "Status"] });
+ *   await expect(users.row({ Name: "John" }).cell("Status")).toHaveText("Active");
+ * });
+ */
+export declare const test: TestType<PlaywrightTestArgs & PlaywrightTestOptions, PlaywrightWorkerArgs & PlaywrightWorkerOptions & {
+  _pwTableSelectors: void;
+}>;
+/**
+ * The default `ignore` option of {@link TableLocator}: CSS selectors of the elements inside a cell whose
+ * text is left out. They cover screen reader only text (`.sr-only`, `.visually-hidden`), ligature icons
+ * (Material Icons and Material Symbols, whose text such as `arrow_upward` is drawn as an icon) and
+ * decorative content (`[aria-hidden=true]`).
+ *
+ * Spread it to add your own selectors: `ignore: [...DEFAULT_IGNORE, ".sort-icon"]`.
+ */
+export declare const DEFAULT_IGNORE: readonly string[];
+/**
+ * What a matcher returns to `expect.extend`. Declared here instead of importing `MatcherReturnType`,
+ * which older versions of `@playwright/test` within the peer range don't export.
+ */
+type MatcherResult = {
+  name: string;
+  pass: boolean;
+  message: () => string;
+  expected?: unknown;
+  actual?: unknown;
+  timeout?: number;
+};
+/** Options shared by the table matchers. */
+type TableMatcherOptions = {
+  /** Time to retry the assertion for, in milliseconds. Defaults to the `expect` timeout. */
+  timeout?: number;
+};
+/** Options for the `toBeSortedBy` matcher. */
+type TableSortOptions = TableMatcherOptions & {
+  /** The expected order. Defaults to `"asc"`. */
+  order?: "asc" | "desc";
+  /**
+   * How cell texts are compared. Defaults to `"text"`.
+   * - `"text"`: case- and accent-insensitive, with digit runs compared as numbers (`"item 9"` before
+   *   `"item 10"`).
+   * - `"number"`: the one number in the text, read with the `decimal` separator (`"€ 1,200"` is 1200).
+   *   See {@link DecimalSeparator} for the rules.
+   * - `"date"`: parsed with `Date.parse`.
+   */
+  type?: "text" | "number" | "date";
+  /** The decimal separator for `type: "number"`. Defaults to `"."`. */
+  decimal?: DecimalSeparator;
+  /**
+   * Custom comparison of two cell texts, like `Array.sort`. Runs in Node, so it can use test variables.
+   * Overrides `type`.
+   */
+  compare?: (a: string, b: string) => number;
+  /** Also require `aria-sort="ascending"` or `"descending"` on the header cell. Defaults to `false`. */
+  ariaSort?: boolean;
+};
+/** Options for the `toHaveRows` and `toHaveColumnValues` matchers. */
+type TableRowsOptions = TableMatcherOptions & {
+  /**
+   * Accept the rows (or values) in any order: each expected entry must match a different body row.
+   * Defaults to `false`: body row `i` must match entry `i`.
+   */
+  anyOrder?: boolean;
+};
+/**
+ * Asserts that the table has at least one body row matching every condition (or none, with `.not`).
+ * Retries until the timeout. On failure, unknown headers are reported with the available headers.
+ *
+ * Conditions are checked against header names at runtime. With the `expect` of this package, they are
+ * also checked at compile time against the `headers` of the table.
+ */
+declare function toHaveRow(this: ExpectMatcherState, table: TableLocator, where: RowWhere<string>, options?: TableMatcherOptions): Promise<MatcherResult>;
+/**
+ * Asserts that the table has exactly `count` body rows. Retries until the timeout.
+ */
+declare function toHaveRowCount(this: ExpectMatcherState, table: TableLocator, count: number, options?: TableMatcherOptions): Promise<MatcherResult>;
+/**
+ * Asserts that the main header row contains every given header key, or with `exact: true`, that it
+ * equals the given keys in order. Retries until the timeout.
+ */
+declare function toHaveHeaders(this: ExpectMatcherState, table: TableLocator, headers: readonly string[], options?: TableMatcherOptions & {
+  /** Require exactly these header keys, in this order. Defaults to `false`. */
+  exact?: boolean;
+}): Promise<MatcherResult>;
+/**
+ * Asserts that a {@link TableRow} resolves to exactly one row whose cells match every condition.
+ * With `.not`, the row must exist and not match. Retries until the timeout.
+ *
+ * @example
+ * await expect(users.row({ Name: "John" })).toHaveCells({ Status: "Active", Email: /@example\.com$/ });
+ * await expect(users.rowAt(0)).not.toHaveCells({ Status: "Deleted" });
+ */
+declare function toHaveCells(this: ExpectMatcherState, row: TableRow, cells: RowWhere<string>, options?: TableMatcherOptions): Promise<MatcherResult>;
+/**
+ * Asserts that the table has exactly as many body rows as `rows`, and that body row `i` matches every
+ * condition of `rows[i]`. Headers that a row does not mention are not checked, so `{}` matches any row.
+ * With `anyOrder: true`, the rows may come in any order: each entry must match a different body row.
+ * With `.not`, the table must not match. Retries until the timeout.
+ *
+ * @example
+ * await expect(users).toHaveRows([
+ *   { Name: "John", Status: "Active" },
+ *   { Name: "Jane", Status: /inactive/i },
+ * ]);
+ */
+declare function toHaveRows(this: ExpectMatcherState, table: TableLocator, rows: readonly RowWhere<string>[], options?: TableRowsOptions): Promise<MatcherResult>;
+/**
+ * Asserts that every entry of `rows` matches a different body row, in any order; other body rows are
+ * allowed. With `.not`, at least one entry has no body row of its own. Retries until the timeout.
+ *
+ * @example
+ * await expect(users).toContainRows([
+ *   { Name: "Joe", Status: "Active" },
+ *   { Name: "John" },
+ * ]);
+ */
+declare function toContainRows(this: ExpectMatcherState, table: TableLocator, rows: readonly RowWhere<string>[], options?: TableMatcherOptions): Promise<MatcherResult>;
+/**
+ * Asserts that the table has body rows and that every one of them matches `where`, for example after
+ * filtering. With `.not`, at least one body row doesn't match. A table without body rows fails both,
+ * so a filter that leaves nothing never passes. Retries until the timeout.
+ *
+ * @example
+ * await page.getByLabel("Status").selectOption("Active");
+ * await expect(users).toHaveEveryRow({ Status: "Active" });
+ */
+declare function toHaveEveryRow(this: ExpectMatcherState, table: TableLocator, where: RowWhere<string>, options?: TableMatcherOptions): Promise<MatcherResult>;
+/**
+ * Asserts that `column` has exactly these cell values, one per body row: body row `i` matches `values[i]`,
+ * or with `anyOrder: true`, each value matches a different body row. Values are an exact string, a RegExp
+ * or a {@link CellCondition}, compared as in row conditions. With `.not`, the column must not match.
+ * Retries until the timeout.
+ *
+ * @example
+ * await expect(users).toHaveColumnValues("Status", ["Active", "Inactive", "Active"]);
+ * await expect(orders).toHaveColumnValues("Total", [{ gt: 0 }, { gt: 0 }], { anyOrder: true });
+ */
+declare function toHaveColumnValues(this: ExpectMatcherState, table: TableLocator, column: string | number, values: readonly CellMatcher[], options?: TableRowsOptions): Promise<MatcherResult>;
+/**
+ * Asserts that the body rows are sorted by `column`. Values are compared in Node, so `compare` can use
+ * variables from the test. An empty body, an unknown column or a value that cannot be parsed fails the
+ * assertion, also with `.not`. Retries until the timeout.
+ *
+ * @example
+ * await users.header("Age").click();
+ * await expect(users).toBeSortedBy("Age", { type: "number" });
+ * await expect(users).toBeSortedBy("Name", { order: "desc", ariaSort: true });
+ */
+declare function toBeSortedBy(this: ExpectMatcherState, table: TableLocator, column: string | number, options?: TableSortOptions): Promise<MatcherResult>;
+/**
+ * Asserts the number of body rows in the whole table, also the rows that are not rendered or are on
+ * other pages (see {@link TableLocator.totalRowCount}). Retries until the timeout.
+ *
+ * @example
+ * await expect(grid).toHaveTotalRowCount(200);
+ */
+declare function toHaveTotalRowCount(this: ExpectMatcherState, table: TableLocator, count: number, options?: TableMatcherOptions): Promise<MatcherResult>;
+/**
+ * Asserts that a {@link TableRow} is selected: it has `aria-selected="true"`, or the first checkbox in it
+ * is checked. Retries until the timeout.
+ *
+ * @example
+ * await users.row({ Name: "John" }).select();
+ * await expect(users.row({ Name: "John" })).toBeSelected();
+ */
+declare function toBeSelected(this: ExpectMatcherState, row: TableRow, options?: TableMatcherOptions): Promise<MatcherResult>;
+/**
+ * Asserts that a {@link TableRow} of a tree grid is expanded (see {@link TableRow.isExpanded}). A row that
+ * cannot expand fails both the assertion and its negation. Retries until the timeout.
+ *
+ * @example
+ * await expect(files.row({ Name: "src" })).not.toBeExpanded();
+ */
+declare function toBeExpanded(this: ExpectMatcherState, row: TableRow, options?: TableMatcherOptions): Promise<MatcherResult>;
+/**
+ * Custom `expect` matchers for {@link TableLocator} and {@link TableRow}. Use them to extend your own `expect`.
+ *
+ * - `toHaveRow(where, options?)`: at least one body row matches every condition.
+ * - `toHaveRowCount(count, options?)`: exactly `count` body rows.
+ * - `toHaveRows(rows, options?)`: exactly these body rows, in order (or `anyOrder`), each matching its conditions.
+ * - `toContainRows(rows, options?)`: each entry matches a different body row, in any order; other rows are allowed.
+ * - `toHaveEveryRow(where, options?)`: there are body rows, and every one matches the conditions.
+ * - `toHaveColumnValues(column, values, options?)`: one value per body row, in order (or `anyOrder`).
+ * - `toHaveHeaders(headers, options?)`: the main header row contains these header keys (`exact` for an ordered match).
+ * - `toBeSortedBy(column, options?)`: the body rows are sorted by a column (see {@link TableSortOptions}).
+ * - `toHaveTotalRowCount(count, options?)`: the number of body rows in the whole table, on every page.
+ * - `toHaveCells(cells, options?)` on a {@link TableRow}: exactly one row, whose cells match every condition.
+ * - `toBeSelected(options?)` on a {@link TableRow}: the row is selected.
+ * - `toBeExpanded(options?)` on a {@link TableRow}: the row of a tree grid is expanded.
+ *
+ * When a table matcher fails inside a test, the body rows are attached to the test report as a Markdown
+ * table, once per test and table.
+ *
+ * @example
+ * // Combine with your own matchers
+ * import { expect as base } from "@playwright/test";
+ * import { tableMatchers } from "@cerios/playwright-table";
+ *
+ * export const expect = base.extend({
+ *   ...tableMatchers,
+ *   async toHaveEmailFor(table: TableLocator, name: string) { ... },
+ * });
+ *
+ * @example
+ * // Or merge with another extended expect
+ * import { mergeExpects } from "@playwright/test";
+ * import { expect as tableExpect } from "@cerios/playwright-table";
+ *
+ * export const expect = mergeExpects(tableExpect, myExpect);
+ */
+export declare const tableMatchers: {
+  toHaveRow: typeof toHaveRow;
+  toHaveRowCount: typeof toHaveRowCount;
+  toHaveRows: typeof toHaveRows;
+  toContainRows: typeof toContainRows;
+  toHaveEveryRow: typeof toHaveEveryRow;
+  toHaveColumnValues: typeof toHaveColumnValues;
+  toHaveHeaders: typeof toHaveHeaders;
+  toHaveCells: typeof toHaveCells;
+  toBeSortedBy: typeof toBeSortedBy;
+  toHaveTotalRowCount: typeof toHaveTotalRowCount;
+  toBeSelected: typeof toBeSelected;
+  toBeExpanded: typeof toBeExpanded;
+};
+/**
+ * Playwright `expect` extended with {@link tableMatchers}.
+ *
+ * @example
+ * import { test, expect, defineTable } from "@cerios/playwright-table";
+ *
+ * test("users", async ({ page }) => {
+ *   const users = defineTable(page.locator("table"), { headers: ["Name", "Status"] });
+ *   await expect(users).toHaveHeaders(["Name", "Status"]);
+ *   await expect(users).toHaveRow({ Name: "John", Status: /active/i });
+ *   await expect(users).not.toHaveRow({ Name: "Ghost" });
+ *   await expect(users).toHaveRowCount(3);
+ *   await expect(users).toHaveRows([{ Name: "John" }, { Name: "Jane" }, { Name: "Joe" }]);
+ *   await expect(users).toContainRows([{ Name: "Joe" }, { Name: "John" }]);
+ *   await expect(users).toHaveColumnValues("Status", ["Active", "Inactive", "Active"]);
+ *   await users.header("Name").click();
+ *   await expect(users).toBeSortedBy("Name");
+ *   await expect(users.row({ Name: "John" })).toHaveCells({ Status: "Active" });
+ * });
+ */
+declare const tableExpect: Expect<typeof tableMatchers>;
+/** The matchers Playwright's `expect` (extended with {@link tableMatchers}) has for a value of type `T`. */
+type BaseAssertions<T> = ReturnType<typeof tableExpect<T>>;
+/** `Base` with the matchers of `Typed` replaced by their typed versions, also after `.not`. */
+type WithTyped<Base, Typed> = Omit<Base, keyof Typed | "not"> & Typed & {
+  not: Omit<Base, keyof Typed | "not"> & Typed;
+};
+/**
+ * The table matchers of {@link expect} on a {@link TableLocator} with typed headers: header keys in
+ * conditions and columns are checked at compile time, like in {@link TableLocator.row}.
+ */
+interface TableAssertions<H extends string> {
+  toHaveRow<W extends RowWhere<H>>(where: W & ValidRowWhere<H, W>, options?: TableMatcherOptions): Promise<void>;
+  toHaveRowCount(count: number, options?: TableMatcherOptions): Promise<void>;
+  toHaveRows(rows: readonly RowWhere<H>[], options?: TableRowsOptions): Promise<void>;
+  toContainRows(rows: readonly RowWhere<H>[], options?: TableMatcherOptions): Promise<void>;
+  toHaveEveryRow<W extends RowWhere<H>>(where: W & ValidRowWhere<H, W>, options?: TableMatcherOptions): Promise<void>;
+  toHaveColumnValues(column: ColumnKey<H>, values: readonly CellMatcher[], options?: TableRowsOptions): Promise<void>;
+  /** Header keys are not checked: a header that the table doesn't declare may be asserted absent. */
+  toHaveHeaders(headers: readonly string[], options?: TableMatcherOptions & {
+    exact?: boolean;
+  }): Promise<void>;
+  toBeSortedBy(column: ColumnKey<H>, options?: TableSortOptions): Promise<void>;
+  toHaveTotalRowCount(count: number, options?: TableMatcherOptions): Promise<void>;
+}
+/** The row matchers of {@link expect} on a {@link TableRow} with typed headers. */
+interface RowAssertions<H extends string> {
+  toHaveCells<W extends RowWhere<H>>(cells: W & ValidRowWhere<H, W>, options?: TableMatcherOptions): Promise<void>;
+  toBeSelected(options?: TableMatcherOptions): Promise<void>;
+  toBeExpanded(options?: TableMatcherOptions): Promise<void>;
+}
+/**
+ * The type of {@link expect}: Playwright's `expect` extended with {@link tableMatchers}, whose table and
+ * row matchers check header keys at compile time (also with `expect.soft`).
+ */
+type TableExpect = {
+  <H extends string>(actual: TableLocator<H>, messageOrOptions?: string | {
+    message?: string;
+  }): WithTyped<BaseAssertions<TableLocator<H>>, TableAssertions<H>>;
+  <H extends string>(actual: TableRow<H>, messageOrOptions?: string | {
+    message?: string;
+  }): WithTyped<BaseAssertions<TableRow<H>>, RowAssertions<H>>;
+  soft: TableExpect;
+} & Expect<typeof tableMatchers>;
+export declare const expect: TableExpect;
+export type { CellCondition, CellMatcher, ColumnKey, ColumnParser, ColumnParsers, DecimalSeparator, ElementDescriptor, ElementSelector, HeaderKey, HeaderRowOptions, LocatorRef, NavigationOptions, NumberCondition, PaginateOptions, ParsedValue, PollingOptions, RowAssertions, RowWhere, ScrollOptions, StableOptions, TableAssertions, TableExpect, TableJsonOptions, TableJsonRow, TableLocatorOptions, TableMatcherOptions, TablePreset, TableRowsOptions, TableSortOptions, ValidRowWhere };
+//# sourceMappingURL=index.d.ts.map