@ni/nimble-components 19.4.0 → 19.4.1

package/dist/esm/src/table/components/cell/index.d.ts

@@ -0,0 +1,28 @@
+import { ViewTemplate } from '@microsoft/fast-element';
+import { FoundationElement } from '@microsoft/fast-foundation';
+import type { MenuButton } from '../../../menu-button';
+import type { MenuButtonToggleEventDetail } from '../../../menu-button/types';
+import type { TableColumn } from '../../../table-column/base';
+import type { TableCellRecord, TableCellState } from '../../../table-column/base/types';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-table-cell': TableCell;
+    }
+}
+/**
+ * A styled cell that is used within the nimble-table-row.
+ * @internal
+ */
+export declare class TableCell<TCellRecord extends TableCellRecord = TableCellRecord> extends FoundationElement {
+    cellState?: TableCellState<TCellRecord>;
+    column?: TableColumn;
+    hasActionMenu: boolean;
+    menuOpen: boolean;
+    actionMenuLabel?: string;
+    cellViewTemplate?: ViewTemplate<TableCell>;
+    nestingLevel: number;
+    readonly actionMenuButton?: MenuButton;
+    onActionMenuBeforeToggle(event: CustomEvent<MenuButtonToggleEventDetail>): void;
+    onActionMenuToggle(event: CustomEvent<MenuButtonToggleEventDetail>): void;
+}
+export declare const tableCellTag: string;

package/dist/esm/src/table/components/cell/styles.d.ts

@@ -0,0 +1 @@
+export declare const styles: import("@microsoft/fast-element").ElementStyles;

package/dist/esm/src/table/components/cell/template.d.ts

@@ -0,0 +1,2 @@
+import type { TableCell } from '.';
+export declare const template: import("@microsoft/fast-element").ViewTemplate<TableCell<import("../../../table-column/base/types").TableCellRecord>, any>;

package/dist/esm/src/table/components/group-row/index.d.ts

@@ -0,0 +1,42 @@
+import { Checkbox, FoundationElement } from '@microsoft/fast-foundation';
+import type { TableColumn } from '../../../table-column/base';
+import { TableRowSelectionState } from '../../types';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-table-group-row': TableGroupRow;
+    }
+}
+/**
+ * A styled cell that is used within the nimble-table-row.
+ * @internal
+ */
+export declare class TableGroupRow extends FoundationElement {
+    groupRowValue?: unknown;
+    nestingLevel: number;
+    leafItemCount?: number;
+    groupColumn?: TableColumn;
+    expanded: boolean;
+    selectable: boolean;
+    selectionState: TableRowSelectionState;
+    /**
+     * @internal
+     */
+    readonly expandIcon: HTMLElement;
+    /**
+     * @internal
+     */
+    readonly selectionCheckbox?: Checkbox;
+    /**
+     * @internal
+     */
+    animationClass: string;
+    private ignoreSelectionChangeEvents;
+    onGroupExpandToggle(): void;
+    /** @internal */
+    onSelectionChange(event: CustomEvent): void;
+    private selectionStateChanged;
+    private selectionCheckboxChanged;
+    private setSelectionCheckboxState;
+    private readonly removeAnimatingClass;
+}
+export declare const tableGroupRowTag: string;

package/dist/esm/src/table/components/group-row/styles.d.ts

@@ -0,0 +1 @@
+export declare const styles: import("@microsoft/fast-element").ElementStyles;

package/dist/esm/src/table/components/group-row/template.d.ts

@@ -0,0 +1,2 @@
+import type { TableGroupRow } from '.';
+export declare const template: import("@microsoft/fast-element").ViewTemplate<TableGroupRow, any>;

package/dist/esm/src/table/components/header/index.d.ts

@@ -0,0 +1,20 @@
+import { FoundationElement } from '@microsoft/fast-foundation';
+import { TableColumnSortDirection } from '../../types';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-table-header': TableHeader;
+    }
+}
+/**
+ * A styled header that is used within the nimble-table.
+ * @internal
+ */
+export declare class TableHeader extends FoundationElement {
+    sortDirection: TableColumnSortDirection;
+    firstSortedColumn: boolean;
+    isGrouped: boolean;
+    protected sortDirectionChanged(_prev: TableColumnSortDirection | undefined, _next: TableColumnSortDirection): void;
+    protected firstSortedColumnChanged(_prev: boolean | undefined, _next: boolean): void;
+    private updateAriaSort;
+}
+export declare const tableHeaderTag: string;

package/dist/esm/src/table/components/header/styles.d.ts

@@ -0,0 +1 @@
+export declare const styles: import("@microsoft/fast-element").ElementStyles;

package/dist/esm/src/table/components/header/template.d.ts

@@ -0,0 +1,2 @@
+import type { TableHeader } from '.';
+export declare const template: import("@microsoft/fast-element").ViewTemplate<TableHeader, any>;

package/dist/esm/src/table/components/row/index.d.ts

@@ -0,0 +1,50 @@
+import { Checkbox, FoundationElement } from '@microsoft/fast-foundation';
+import type { TableCellState } from '../../../table-column/base/types';
+import type { TableRecord } from '../../types';
+import type { TableColumn } from '../../../table-column/base';
+import type { MenuButtonToggleEventDetail } from '../../../menu-button/types';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-table-row': TableRow;
+    }
+}
+export interface ColumnState {
+    column: TableColumn;
+    cellState: TableCellState;
+    cellIndentLevel: number;
+}
+/** Represents a single row (element) in the Table's data  */
+export interface TableDataRecord extends TableRecord {
+}
+/**
+ * A styled row that is used within the nimble-table.
+ * @internal
+ */
+export declare class TableRow<TDataRecord extends TableDataRecord = TableDataRecord> extends FoundationElement {
+    recordId?: string;
+    selectable: boolean;
+    selected: boolean;
+    hideSelection: boolean;
+    dataRecord?: TDataRecord;
+    columns: TableColumn[];
+    currentActionMenuColumn?: TableColumn;
+    nestingLevel: number;
+    menuOpen: boolean;
+    /** @internal */
+    readonly selectionCheckbox?: Checkbox;
+    /** @internal */
+    readonly cellContainer: HTMLSpanElement;
+    private ignoreSelectionChangeEvents;
+    get columnStates(): ColumnState[];
+    get ariaSelected(): 'true' | 'false' | null;
+    onSelectionChange(event: CustomEvent): void;
+    onCellActionMenuBeforeToggle(event: CustomEvent<MenuButtonToggleEventDetail>, column: TableColumn): void;
+    onCellActionMenuToggle(event: CustomEvent<MenuButtonToggleEventDetail>, column: TableColumn): void;
+    closeOpenActionMenus(): void;
+    private emitActionMenuToggleEvent;
+    private hasValidFieldNames;
+    private selectedChanged;
+    private selectionCheckboxChanged;
+    private setSelectionCheckboxState;
+}
+export declare const tableRowTag: string;

package/dist/esm/src/table/components/row/styles.d.ts

@@ -0,0 +1 @@
+export declare const styles: import("@microsoft/fast-element").ElementStyles;

package/dist/esm/src/table/components/row/template.d.ts

@@ -0,0 +1,2 @@
+import type { TableRow } from '.';
+export declare const template: import("@microsoft/fast-element").ViewTemplate<TableRow<import(".").TableDataRecord>, any>;

package/dist/esm/src/table/index.d.ts

@@ -0,0 +1,176 @@
+import { Checkbox, FoundationElement } from '@microsoft/fast-foundation';
+import { TableColumn } from '../table-column/base';
+import { TableActionMenuToggleEventDetail, TableRecord, TableRowSelectionMode, TableRowSelectionState, TableRowSelectionToggleEventDetail, TableRowState, TableValidity } from './types';
+import { Virtualizer } from './models/virtualizer';
+import type { TableRow } from './components/row';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-table': Table;
+    }
+}
+/**
+ * A nimble-styled table.
+ */
+export declare class Table<TData extends TableRecord = TableRecord> extends FoundationElement {
+    idFieldName?: string;
+    selectionMode: TableRowSelectionMode;
+    /**
+     * @internal
+     */
+    tableData: TableRowState<TData>[];
+    /**
+     * @internal
+     */
+    columns: TableColumn[];
+    /**
+     * @internal
+     */
+    readonly childItems: Element[];
+    /**
+     * @internal
+     */
+    readonly rowElements: TableRow[];
+    /**
+     * @internal
+     */
+    actionMenuSlots: string[];
+    /**
+     * @internal
+     */
+    openActionMenuRecordId?: string;
+    /**
+     * @internal
+     */
+    canRenderRows: boolean;
+    /**
+     * @internal
+     */
+    scrollX: number;
+    /**
+     * @internal
+     */
+    rowGridColumns?: string;
+    /**
+     * @internal
+     */
+    selectionState: TableRowSelectionState;
+    get validity(): TableValidity;
+    /**
+     * @internal
+     */
+    readonly viewport: HTMLElement;
+    /**
+     * @internal
+     */
+    readonly selectionCheckbox?: Checkbox;
+    /**
+     * @internal
+     */
+    showCollapseAll: boolean;
+    /**
+     * @internal
+     */
+    readonly rowContainer: HTMLElement;
+    /**
+     * @internal
+     */
+    readonly virtualizer: Virtualizer<TData>;
+    /**
+     * @internal
+     */
+    firstSortedColumn?: TableColumn;
+    /**
+     * @internal
+     */
+    documentShiftKeyDown: boolean;
+    private readonly table;
+    private options;
+    private readonly tableValidator;
+    private readonly tableUpdateTracker;
+    private readonly selectionManager;
+    private columnNotifiers;
+    private isInitialized;
+    private readonly collapsedRows;
+    private ignoreSelectionChangeEvents;
+    constructor();
+    setData(newData: readonly TData[]): Promise<void>;
+    getSelectedRecordIds(): Promise<string[]>;
+    setSelectedRecordIds(recordIds: string[]): Promise<void>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    checkValidity(): boolean;
+    /**
+     * @internal
+     *
+     * The event handler that is called when a notifier detects a change. Notifiers are added
+     * to each column, so `source` is expected to be an instance of `TableColumn`, and `args`
+     * is the string name of the property that changed on that column.
+     */
+    handleChange(source: unknown, args: unknown): void;
+    /** @internal */
+    onRowSelectionToggle(rowIndex: number, event: CustomEvent<TableRowSelectionToggleEventDetail>): void;
+    /** @internal */
+    onRowClick(rowIndex: number, event: MouseEvent): boolean;
+    /** @internal */
+    onAllRowsSelectionChange(event: CustomEvent): void;
+    /** @internal */
+    onRowActionMenuBeforeToggle(rowIndex: number, event: CustomEvent<TableActionMenuToggleEventDetail>): void;
+    /** @internal */
+    onRowActionMenuToggle(event: CustomEvent<TableActionMenuToggleEventDetail>): void;
+    /** @internal */
+    handleCollapseAllGroupRows(): void;
+    /** @internal */
+    handleGroupRowExpanded(rowIndex: number, event: Event): void;
+    /**
+     * @internal
+     */
+    toggleColumnSort(column: TableColumn, allowMultiSort: boolean): void;
+    /**
+     * @internal
+     */
+    update(): void;
+    get ariaMultiSelectable(): 'true' | 'false' | null;
+    protected selectionModeChanged(_prev: string | undefined, _next: string | undefined): void;
+    protected idFieldNameChanged(_prev: string | undefined, _next: string | undefined): void;
+    protected columnsChanged(_prev: TableColumn[] | undefined, _next: TableColumn[]): void;
+    private handleActionMenuBeforeToggleEvent;
+    private handleRowActionMenuToggleEvent;
+    private getActionMenuToggleEventDetail;
+    private readonly onViewPortScroll;
+    private readonly onKeyDown;
+    private readonly onKeyUp;
+    private removeColumnObservers;
+    private initialize;
+    private processPendingUpdates;
+    private observeColumns;
+    private getColumnsParticipatingInSorting;
+    private getColumnsParticipatingInGrouping;
+    private childItemsChanged;
+    private updateColumnsFromChildItems;
+    private updateTanStack;
+    private updateActionMenuSlots;
+    private updateRowGridColumns;
+    private validate;
+    private validateWithData;
+    private emitColumnConfigurationChangeEvent;
+    private emitSelectionChangeEvent;
+    private selectionStateChanged;
+    private selectionCheckboxChanged;
+    private setSelectionCheckboxState;
+    private refreshRows;
+    private getTableSelectionState;
+    private getRowSelectionState;
+    private getGroupedRowSelectionState;
+    private getGroupRowColumn;
+    private updateTableOptions;
+    private readonly getIsRowExpanded;
+    private readonly handleRowSelectionChange;
+    private readonly handleExpandedChange;
+    private toggleGroupExpanded;
+    private calculateTanStackSortState;
+    private calculateTanStackGroupingState;
+    private calculateTanStackRowIdFunction;
+    private calculateTanStackColumns;
+    private calculateTanStackSelectionState;
+}
+export declare const tableTag: string;

package/dist/esm/src/table/models/interactive-selection-manager.d.ts

@@ -0,0 +1,17 @@
+import type { Table as TanStackTable } from '@tanstack/table-core';
+import { TableRecord, TableRowState, TableRowSelectionMode } from '../types';
+/**
+ * Manages the behavior associated with interactive row selection for the table, including
+ * handling when the selection mode of the table is changed.
+ */
+export declare class InteractiveSelectionManager<TData extends TableRecord> {
+    private readonly tanStackTable;
+    private selectionManager;
+    constructor(tanStackTable: TanStackTable<TData>, selectionMode: TableRowSelectionMode);
+    handleRowSelectionToggle(rowState: TableRowState | undefined, isSelecting: boolean, shiftKey: boolean): boolean;
+    handleRowClick(rowState: TableRowState | undefined, shiftKey: boolean, ctrlKey: boolean): boolean;
+    handleActionMenuOpening(rowState: TableRowState | undefined): boolean;
+    handleSelectionModeChanged(selectionMode: TableRowSelectionMode): void;
+    handleSelectionReset(): void;
+    private createSelectionManager;
+}

package/dist/esm/src/table/models/selection-managers/disabled-selection-manager.d.ts

@@ -0,0 +1,11 @@
+import type { TableRecord, TableRowState } from '../../types';
+import { SelectionManagerBase } from './selection-manager-base';
+/**
+ * Selection manager for interactive selection when the selection mode of the table is
+ * `TableRowSelectionMode.none`.
+ */
+export declare class DisabledSelectionManager<TData extends TableRecord> extends SelectionManagerBase<TData> {
+    handleRowSelectionToggle(_rowState: TableRowState, _isSelecting: boolean, _shiftKey: boolean): boolean;
+    handleRowClick(_rowState: TableRowState, _shiftKey: boolean, _ctrlKey: boolean): boolean;
+    handleActionMenuOpening(_rowState: TableRowState): boolean;
+}

package/dist/esm/src/table/models/selection-managers/multi-selection-manager.d.ts

@@ -0,0 +1,20 @@
+import { TableRecord, TableRowState } from '../../types';
+import { SelectionManagerBase } from './selection-manager-base';
+/**
+ * Selection manager for interactive selection when the selection mode of the table is
+ * `TableRowSelectionMode.multiple`.
+ */
+export declare class MultiSelectionManager<TData extends TableRecord> extends SelectionManagerBase<TData> {
+    private shiftSelectStartRowId?;
+    private previousShiftSelectRowEndId?;
+    handleRowSelectionToggle(rowState: TableRowState, isSelecting: boolean, shiftKey: boolean): boolean;
+    handleRowClick(rowState: TableRowState, shiftKey: boolean, ctrlKey: boolean): boolean;
+    handleActionMenuOpening(rowState: TableRowState): boolean;
+    reset(): void;
+    private tryUpdateRangeSelection;
+    private removePreviousRangeSelection;
+    private addNewRangeSelection;
+    private updateSelectionStateForRange;
+    private updateSelectionStateForRow;
+    private getRowIndexForId;
+}

package/dist/esm/src/table/models/selection-managers/selection-manager-base.d.ts

@@ -0,0 +1,19 @@
+import type { Table as TanStackTable, Row as TanStackRow } from '@tanstack/table-core';
+import { TableRecord, TableRowState } from '../../types';
+/**
+ * Abstract base class for handling behavior associated with interactive row selection of the table.
+ */
+export declare abstract class SelectionManagerBase<TData extends TableRecord> {
+    protected tanStackTable: TanStackTable<TData>;
+    constructor(tanStackTable: TanStackTable<TData>);
+    abstract handleRowSelectionToggle(rowState: TableRowState, isSelecting: boolean, shiftKey: boolean): boolean;
+    abstract handleRowClick(rowState: TableRowState, shiftKey: boolean, ctrlKey: boolean): boolean;
+    abstract handleActionMenuOpening(rowState: TableRowState): boolean;
+    reset(): void;
+    protected toggleIsRowSelected(rowState: TableRowState, isSelecting?: boolean): void;
+    protected selectSingleRow(rowState: TableRowState): boolean;
+    protected deselectAllLeafRows(rowId: string): void;
+    protected getAllLeafRowIds(id: string): string[];
+    protected getAllOrderedRows(): TanStackRow<TData>[];
+    private getOrderedRows;
+}

package/dist/esm/src/table/models/selection-managers/single-selection-manager.d.ts

@@ -0,0 +1,11 @@
+import type { TableRecord, TableRowState } from '../../types';
+import { SelectionManagerBase } from './selection-manager-base';
+/**
+ * Selection manager for interactive selection when the selection mode of the table is
+ * `TableRowSelectionMode.single`.
+ */
+export declare class SingleSelectionManager<TData extends TableRecord> extends SelectionManagerBase<TData> {
+    handleRowSelectionToggle(rowState: TableRowState, isSelecting: boolean, _shiftKey: boolean): boolean;
+    handleRowClick(rowState: TableRowState, _shiftKey: boolean, _ctrlKey: boolean): boolean;
+    handleActionMenuOpening(rowState: TableRowState): boolean;
+}

package/dist/esm/src/table/models/sort-operations.d.ts

@@ -0,0 +1,7 @@
+import { SortingFnOption as TanStackSortingFnOption } from '@tanstack/table-core';
+import { TableColumnSortOperation } from '../../table-column/base/types';
+/**
+ * Returns the sorting function for TanStack to use based on the specified
+ * TableColumnSortOperation
+ */
+export declare function getTanStackSortingFunction<TData>(sortOperation: TableColumnSortOperation): TanStackSortingFnOption<TData>;

package/dist/esm/src/table/models/table-layout-helper.d.ts

@@ -0,0 +1,8 @@
+import type { TableColumn } from '../../table-column/base';
+/**
+ * This class provides helper methods for managing the layout of cells within
+ * a Table.
+ */
+export declare class TableLayoutHelper {
+    static getGridTemplateColumns(columns: TableColumn[]): string;
+}

package/dist/esm/src/table/models/table-update-tracker.d.ts

@@ -0,0 +1,31 @@
+import type { Table } from '..';
+import type { TableRecord } from '../types';
+import { UpdateTracker } from '../../utilities/models/update-tracker';
+declare const trackedItems: readonly ["rowIds", "groupRows", "columnIds", "columnSort", "columnWidths", "columnDefinition", "actionMenuSlots", "selectionMode"];
+/**
+ * Helper class to track what updates are needed to the table based on configuration
+ * changes.
+ */
+export declare class TableUpdateTracker<TData extends TableRecord> extends UpdateTracker<typeof trackedItems> {
+    private readonly table;
+    private updateQueued;
+    constructor(table: Table<TData>);
+    get updateRowIds(): boolean;
+    get updateGroupRows(): boolean;
+    get updateColumnIds(): boolean;
+    get updateColumnSort(): boolean;
+    get updateColumnWidths(): boolean;
+    get updateColumnDefinition(): boolean;
+    get updateActionMenuSlots(): boolean;
+    get updateSelectionMode(): boolean;
+    get requiresTanStackUpdate(): boolean;
+    get requiresTanStackDataReset(): boolean;
+    trackAllStateChanged(): void;
+    get hasPendingUpdates(): boolean;
+    trackColumnPropertyChanged(changedColumnProperty: string): void;
+    trackColumnInstancesChanged(): void;
+    trackIdFieldNameChanged(): void;
+    trackSelectionModeChanged(): void;
+    protected queueUpdate(): void;
+}
+export {};

package/dist/esm/src/table/models/table-validator.d.ts

@@ -0,0 +1,29 @@
+import type { TableColumn } from '../../table-column/base';
+import { TableRecord, TableRowSelectionMode, TableValidity } from '../types';
+/**
+ * Helper class for the nimble-table to validate that the table's configuration
+ * is valid and report which aspects of the configuration are valid or invalid.
+ */
+export declare class TableValidator<TData extends TableRecord> {
+    private duplicateRecordId;
+    private missingRecordId;
+    private invalidRecordId;
+    private duplicateColumnId;
+    private missingColumnId;
+    private duplicateSortIndex;
+    private duplicateGroupIndex;
+    private idFieldNameNotConfigured;
+    private invalidColumnConfiguration;
+    private readonly recordIds;
+    getValidity(): TableValidity;
+    isValid(): boolean;
+    areRecordIdsValid(): boolean;
+    validateSelectionMode(selectionMode: TableRowSelectionMode, idFieldName: string | undefined): boolean;
+    validateRecordIds(data: TData[], idFieldName: string | undefined): boolean;
+    validateColumnIds(columnIds: (string | undefined)[]): boolean;
+    validateColumnSortIndices(sortIndices: number[]): boolean;
+    validateColumnGroupIndices(groupIndices: number[]): boolean;
+    validateColumnConfigurations(columns: TableColumn[]): boolean;
+    getPresentRecordIds(requestedRecordIds: string[]): string[];
+    private validateIndicesAreUnique;
+}

package/dist/esm/src/table/models/virtualizer.d.ts

@@ -0,0 +1,27 @@
+import type { Table as TanStackTable } from '@tanstack/table-core';
+import { VirtualItem } from '@tanstack/virtual-core';
+import type { Table } from '..';
+import type { TableRecord } from '../types';
+/**
+ * Helper class for the nimble-table for row virtualization.
+ *
+ * @internal
+ */
+export declare class Virtualizer<TData extends TableRecord = TableRecord> {
+    visibleItems: VirtualItem[];
+    allRowsHeight: number;
+    headerContainerMarginRight: number;
+    rowContainerYOffset: number;
+    private readonly table;
+    private readonly tanStackTable;
+    private readonly viewportResizeObserver;
+    private virtualizer?;
+    constructor(table: Table<TData>, tanStackTable: TanStackTable<TData>);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    dataChanged(): void;
+    private updateVirtualizer;
+    private createVirtualizerOptions;
+    private handleVirtualizerChange;
+    private notifyFocusedCellRecycling;
+}

package/dist/esm/src/table/styles.d.ts

@@ -0,0 +1 @@
+export declare const styles: import("@microsoft/fast-element").ElementStyles;

package/dist/esm/src/table/template.d.ts

@@ -0,0 +1,2 @@
+import type { Table } from '.';
+export declare const template: import("@microsoft/fast-element").ViewTemplate<Table<import("./types").TableRecord>, any>;

package/dist/esm/src/table/testing/table.pageobject.d.ts

@@ -0,0 +1,84 @@
+import type { Table } from '..';
+import type { TableHeader } from '../components/header';
+import { TableColumnSortDirection, TableRecord, TableRowSelectionState } from '../types';
+import type { MenuButton } from '../../menu-button';
+import { TableCellView } from '../../table-column/base/cell-view';
+import { Anchor } from '../../anchor';
+/**
+ * Summary information about a column that is sorted in the table for use in the `TablePageObject`.
+ */
+export interface SortedColumn {
+    columnId?: string;
+    sortDirection: TableColumnSortDirection;
+}
+/**
+ * Page object for the `nimble-table` component to provide consistent ways
+ * of querying and interacting with the component during tests.
+ */
+export declare class TablePageObject<T extends TableRecord> {
+    private readonly tableElement;
+    constructor(tableElement: Table<T>);
+    getRenderedHeaderCount(): number;
+    getRenderedCellCountForRow(rowIndex: number): number;
+    getHeaderContent(columnIndex: number): Node | undefined;
+    getHeaderElement(columnIndex: number): TableHeader;
+    getHeaderTitle(columnIndex: number): string;
+    dispatchEventToHeader(columnIndex: number, event: Event): boolean | undefined;
+    getHeaderRenderedWidth(columnIndex: number): number;
+    clickColumnHeader(columnIndex: number, shiftKeyDown?: boolean): Promise<void>;
+    getRenderedRowCount(): number;
+    getRenderedGroupRowCount(): number;
+    getAllGroupRowsExpandedState(): boolean[];
+    getRenderedCellView(rowIndex: number, columnIndex: number): TableCellView;
+    getRenderedCellContent(rowIndex: number, columnIndex: number): string;
+    getRenderedCellAnchor(rowIndex: number, columnIndex: number): Anchor;
+    getRenderedGroupHeaderContent(groupRowIndex: number): string;
+    getAllRenderedGroupHeaderContent(): string[];
+    getCellTitle(rowIndex: number, columnIndex: number): string;
+    dispatchEventToCell(rowIndex: number, columnIndex: number, event: Event): boolean | undefined;
+    getGroupHeaderTitle(groupRowIndex: number): string;
+    dispatchEventToGroupHeader(groupRowIndex: number, event: Event): boolean | undefined;
+    getRecordId(rowIndex: number): string | undefined;
+    getRowWidth(): number;
+    sizeTableToGivenRowWidth(rowWidth: number, table: Table<T>): Promise<void>;
+    getCellRenderedWidth(columnIndex: number, rowIndex?: number): number;
+    getTotalCellRenderedWidth(): number;
+    scrollToLastRowAsync(): Promise<void>;
+    getCellActionMenu(rowIndex: number, columnIndex: number): MenuButton | null;
+    clickCellActionMenu(rowIndex: number, columnIndex: number): Promise<void>;
+    isCellActionMenuVisible(rowIndex: number, columnIndex: number): boolean;
+    setRowHoverState(rowIndex: number, hover: boolean): void;
+    clickGroupRow(groupRowIndex: number): Promise<void>;
+    clickRow(rowIndex: number, modifiers?: {
+        shiftKey?: boolean;
+        ctrlKey?: boolean;
+    }): Promise<void>;
+    getIsRowSelectable(rowIndex: number): boolean;
+    getIsRowSelected(rowIndex: number): boolean;
+    toggleGroupRowExpandedState(groupRowIndex: number): void;
+    clickCollapseAllButton(): void;
+    isCollapseAllButtonVisible(): boolean;
+    isTableSelectionCheckboxVisible(): boolean;
+    getTableSelectionState(): TableRowSelectionState;
+    clickTableSelectionCheckbox(): void;
+    isRowSelectionCheckboxVisible(rowIndex: number): boolean;
+    getRowSelectionState(rowIndex: number): TableRowSelectionState;
+    clickRowSelectionCheckbox(rowIndex: number, shiftKey?: boolean): void;
+    getGroupRowSelectionState(groupRowIndex: number): TableRowSelectionState;
+    clickGroupRowSelectionCheckbox(groupRowIndex: number, shiftKey?: boolean): void;
+    getSortedColumns(): SortedColumn[];
+    getGroupedColumns(): string[];
+    getChildRowCountForGroup(groupRowIndex: number): number;
+    private getRow;
+    private getCell;
+    private getCollapseAllButton;
+    private getSelectionCheckboxForRow;
+    private getSelectionCheckboxForGroupRow;
+    private getSelectionCheckboxForTable;
+    private isCheckboxVisible;
+    private getSelectionStateOfCheckbox;
+    private getGroupRow;
+    private getGroupRowHeaderView;
+    private getHeaderContentElement;
+    private readonly isSlotElement;
+}