@ni/nimble-components 19.3.0 → 19.4.1

package/dist/esm/src/radio-group/styles.d.ts

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

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

@@ -0,0 +1,34 @@
+import { AnchoredRegion, Select as FoundationSelect } from '@microsoft/fast-foundation';
+import { DropdownAppearance } from '../patterns/dropdown/types';
+import type { ErrorPattern } from '../patterns/error/types';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-select': Select;
+    }
+}
+/**
+ * A nimble-styled HTML select
+ */
+export declare class Select extends FoundationSelect implements ErrorPattern {
+    appearance: DropdownAppearance;
+    /**
+     * A message explaining why the value is invalid.
+     *
+     * @public
+     * @remarks
+     * HTML Attribute: error-text
+     */
+    errorText: string | undefined;
+    errorVisible: boolean;
+    /**
+     * @internal
+     */
+    region?: AnchoredRegion;
+    setPositioning(): void;
+    slottedOptionsChanged(prev: Element[], next: Element[]): void;
+    private regionChanged;
+    private controlChanged;
+    private maxHeightChanged;
+    private updateListboxMaxHeightCssVariable;
+}
+export declare const selectTag: string;

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

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

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

@@ -0,0 +1,4 @@
+import { ViewTemplate } from '@microsoft/fast-element';
+import { FoundationElementTemplate, SelectOptions } from '@microsoft/fast-foundation';
+import type { Select } from '.';
+export declare const template: FoundationElementTemplate<ViewTemplate<Select>, SelectOptions>;

package/dist/esm/src/select/types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Types of dropdown appearance.
+ * @public
+ */
+export { DropdownAppearance } from '../patterns/dropdown/types';

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

@@ -0,0 +1,13 @@
+import { FoundationElement } from '@microsoft/fast-foundation';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-spinner': Spinner;
+    }
+}
+/**
+ * A Nimble-styled spinner component.
+ * A spinner is an animating indicator that can be placed in a particular region of a page to represent loading progress, or an ongoing operation, of an indeterminate / unknown duration.
+ */
+export declare class Spinner extends FoundationElement {
+}
+export declare const spinnerTag: string;

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { Switch as FoundationSwitch } from '@microsoft/fast-foundation';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-switch': Switch;
+    }
+}
+/**
+ * A nimble-styled switch control.
+ */
+export declare class Switch extends FoundationSwitch {
+}
+export declare const switchTag: string;

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { Tab as FoundationTab } from '@microsoft/fast-foundation';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-tab': Tab;
+    }
+}
+/**
+ * A nimble-styled HTML tab
+ */
+export declare class Tab extends FoundationTab {
+}
+export declare const tabTag: string;

package/dist/esm/src/tab-panel/index.d.ts

@@ -0,0 +1,12 @@
+import { TabPanel as FoundationTabPanel } from '@microsoft/fast-foundation';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-tab-panel': TabPanel;
+    }
+}
+/**
+ * A nimble-styled tab panel
+ */
+export declare class TabPanel extends FoundationTabPanel {
+}
+export declare const tabPanelTag: string;

package/dist/esm/src/tab-panel/styles.d.ts

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

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;
+}