@ni/nimble-components 24.0.0 → 24.1.0

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

@@ -0,0 +1,186 @@
+import type { TableColumn } from '../table-column/base';
+import type { ValidityObject } from '../utilities/models/validator';
+/**
+ * TableFieldName describes the type associated with keys within
+ * a table's records.
+ */
+export type TableFieldName = string;
+/**
+ * TableFieldValue describes the type associated with values within
+ * a table's records.
+ */
+export type TableFieldValue = string | number | boolean | null | undefined;
+/**
+ * TableStringFieldValue describes the type associated with values within
+ * a table's string records.
+ */
+export type TableStringFieldValue = string | null | undefined;
+/**
+ * TableBooleanFieldValue describes the type associated with values within
+ * a table's boolean records.
+ */
+export type TableBooleanFieldValue = boolean | null | undefined;
+/**
+ * TableNumberFieldValue describes the type associated with values within
+ * a table's number records.
+ */
+export type TableNumberFieldValue = number | null | undefined;
+/**
+ * TableRecord describes the data structure that backs a single row in a table.
+ * It is made up of fields, which are key/value pairs that have a key of type
+ * TableFieldName and a value of type TableFieldValue.
+ */
+export interface TableRecord {
+    [key: TableFieldName]: TableFieldValue;
+}
+/**
+ * @internal
+ *
+ * Describes a hierarchical data structure that is used for
+ * the internal representation of the data, and allows us to represent data with
+ * parent-child relationships within Tanstack.
+ */
+export interface TableNode<TRecord extends TableRecord = TableRecord> {
+    subRows?: TableNode<TRecord>[];
+    originalIndex: number;
+    clientRecord: TRecord;
+}
+export type TableStringField<FieldName extends TableFieldName> = {
+    [name in FieldName]: TableStringFieldValue;
+};
+export type TableBooleanField<FieldName extends TableFieldName> = {
+    [name in FieldName]: TableBooleanFieldValue;
+};
+export type TableNumberField<FieldName extends TableFieldName> = {
+    [name in FieldName]: TableNumberFieldValue;
+};
+export interface TableValidity extends ValidityObject {
+    readonly duplicateRecordId: boolean;
+    readonly missingRecordId: boolean;
+    readonly invalidRecordId: boolean;
+    readonly duplicateColumnId: boolean;
+    readonly missingColumnId: boolean;
+    readonly duplicateSortIndex: boolean;
+    readonly duplicateGroupIndex: boolean;
+    readonly idFieldNameNotConfigured: boolean;
+    readonly invalidColumnConfiguration: boolean;
+    readonly invalidParentIdConfiguration: boolean;
+}
+/**
+ * The hierarachy options for a record in the table.
+ */
+export interface TableSetRecordHierarchyOptions {
+    recordId: string;
+    options: TableRecordHierarchyOptions;
+}
+/**
+ * Describes the hierarchy options that can be configured for a record in the table.
+ */
+export interface TableRecordHierarchyOptions {
+    delayedHierarchyState: TableRecordDelayedHierarchyState;
+}
+export declare const TableRecordDelayedHierarchyState: {
+    readonly none: undefined;
+    readonly canLoadChildren: "can-load-children";
+    readonly loadingChildren: "loading-children";
+};
+export type TableRecordDelayedHierarchyState = (typeof TableRecordDelayedHierarchyState)[keyof typeof TableRecordDelayedHierarchyState];
+export interface TableActionMenuToggleEventDetail {
+    newState: boolean;
+    oldState: boolean;
+    recordIds: string[];
+    columnId?: string;
+}
+/**
+ * The possible directions a table column can be sorted in.
+ */
+export declare const TableColumnSortDirection: {
+    readonly none: undefined;
+    readonly ascending: "ascending";
+    readonly descending: "descending";
+};
+export type TableColumnSortDirection = (typeof TableColumnSortDirection)[keyof typeof TableColumnSortDirection];
+/**
+ * The selection modes of rows in the table.
+ */
+export declare const TableRowSelectionMode: {
+    readonly none: undefined;
+    readonly single: "single";
+    readonly multiple: "multiple";
+};
+export type TableRowSelectionMode = (typeof TableRowSelectionMode)[keyof typeof TableRowSelectionMode];
+/**
+ * @internal
+ *
+ * The possible selection states that the table or a table row can be in.
+ */
+export declare const TableRowSelectionState: {
+    readonly notSelected: "not-selected";
+    readonly selected: "selected";
+    readonly partiallySelected: "partially-selected";
+};
+export type TableRowSelectionState = (typeof TableRowSelectionState)[keyof typeof TableRowSelectionState];
+/**
+ * @internal
+ *
+ * Internal event detail type for a row's selection state changing
+ */
+export interface TableRowSelectionToggleEventDetail {
+    oldState: boolean;
+    newState: boolean;
+}
+/**
+ * Event detail type for row selection events in the table.
+ */
+export interface TableRowSelectionEventDetail {
+    selectedRecordIds: string[];
+}
+/**
+ * Event detail type for row toggle events in the table.
+ */
+export interface TableRowExpansionToggleEventDetail {
+    oldState: boolean;
+    newState: boolean;
+    recordId: string;
+}
+/**
+ * Event detail type for interactive column configuration changes.
+ *
+ * The column-configuration-change event is emitted when a column's configuration
+ * is modified programmatically, such as by clicking on the column's header to sort
+ * the column. The items in the `columns` array are specified in the same order as
+ * the columns are listed in the DOM.
+ */
+export interface TableColumnConfigurationChangeEventDetail {
+    columns: TableColumnConfiguration[];
+}
+/**
+ * A representation of the current configuration of a column within the table.
+ */
+export interface TableColumnConfiguration {
+    columnId?: string;
+    sortIndex?: number;
+    sortDirection: TableColumnSortDirection;
+    groupIndex?: number;
+    hidden: boolean;
+    fractionalWidth: number;
+    pixelWidth?: number;
+}
+/**
+ * @internal
+ *
+ * Internal representation of a row in the table
+ */
+export interface TableRowState<TData extends TableRecord = TableRecord> {
+    record: TData;
+    id: string;
+    selectionState: TableRowSelectionState;
+    isGroupRow: boolean;
+    groupRowValue?: unknown;
+    isExpanded: boolean;
+    nestingLevel?: number;
+    immediateChildCount?: number;
+    groupColumn?: TableColumn;
+    isParentRow: boolean;
+    isLoadingChildren: boolean;
+}

package/dist/esm/src/table-column/anchor/cell-view/index.d.ts

@@ -0,0 +1,22 @@
+import type { TableColumnAnchorCellRecord, TableColumnAnchorColumnConfig } from '..';
+import type { Anchor } from '../../../anchor';
+import { TableCellView } from '../../base/cell-view';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-table-column-anchor-cell-view': TableColumnAnchorCellView;
+    }
+}
+/**
+ * A cell view for displaying links
+ */
+export declare class TableColumnAnchorCellView extends TableCellView<TableColumnAnchorCellRecord, TableColumnAnchorColumnConfig> {
+    /** @internal */
+    hasOverflow: boolean;
+    /** @internal */
+    isPlaceholder: boolean;
+    /** @internal */
+    anchor?: Anchor;
+    get text(): string;
+    focusedRecycleCallback(): void;
+}
+export declare const tableColumnAnchorCellViewTag = "nimble-table-column-anchor-cell-view";

package/dist/esm/src/table-column/anchor/cell-view/styles.d.ts

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

package/dist/esm/src/table-column/anchor/cell-view/template.d.ts

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

package/dist/esm/src/table-column/anchor/index.d.ts

@@ -0,0 +1,77 @@
+import { TableColumn } from '../base';
+import type { TableStringField } from '../../table/types';
+import type { AnchorAppearance } from '../../anchor/types';
+import type { ColumnInternalsOptions } from '../base/models/column-internals';
+export type TableColumnAnchorCellRecord = TableStringField<'label' | 'href'>;
+export interface TableColumnAnchorColumnConfig {
+    appearance: AnchorAppearance;
+    underlineHidden?: boolean;
+    hreflang?: string;
+    ping?: string;
+    referrerpolicy?: string;
+    rel?: string;
+    target?: string;
+    type?: string;
+    download?: string;
+    placeholder?: string;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-table-column-anchor': TableColumnAnchor;
+    }
+}
+declare const TableColumnAnchor_base: (abstract new (...args: any[]) => {
+    groupingDisabled: boolean;
+    groupIndex?: number | null | undefined;
+    groupingDisabledChanged(): void;
+    groupIndexChanged(): void;
+    readonly columnInternals: import("../base/models/column-internals").ColumnInternals<unknown>;
+}) & (abstract new (...args: any[]) => {
+    fractionalWidth?: number | null | undefined;
+    minPixelWidth?: number | null | undefined;
+    fractionalWidthChanged(): void;
+    minPixelWidthChanged(): void;
+    readonly columnInternals: import("../base/models/column-internals").ColumnInternals<unknown>;
+}) & (abstract new (...args: any[]) => {
+    placeholder?: string | undefined;
+    placeholderChanged(): void;
+}) & ((abstract new () => TableColumn<TableColumnAnchorColumnConfig>) & {
+    compose<T extends import("@microsoft/fast-foundation").FoundationElementDefinition = import("@microsoft/fast-foundation").FoundationElementDefinition, K extends import("@microsoft/fast-element").Constructable<import("@microsoft/fast-foundation").FoundationElement> = import("@microsoft/fast-element").Constructable<import("@microsoft/fast-foundation").FoundationElement>>(this: K, elementDefinition: T): (overrideDefinition?: import("@microsoft/fast-foundation").OverrideFoundationElementDefinition<T> | undefined) => import("@microsoft/fast-foundation").FoundationElementRegistry<T, K>;
+    from<TBase extends {
+        new (): HTMLElement;
+        prototype: HTMLElement;
+    }>(BaseType: TBase): new () => InstanceType<TBase> & import("@microsoft/fast-element").FASTElement;
+    define<TType extends Function>(type: TType, nameOrDef?: string | import("@microsoft/fast-element").PartialFASTElementDefinition | undefined): TType;
+});
+/**
+ * A table column for displaying links.
+ */
+export declare class TableColumnAnchor extends TableColumnAnchor_base {
+    labelFieldName?: string;
+    hrefFieldName?: string;
+    appearance?: AnchorAppearance;
+    underlineHidden: boolean;
+    hreflang?: string;
+    ping?: string;
+    referrerpolicy?: string;
+    rel?: string;
+    target?: string;
+    type?: string;
+    download?: string;
+    placeholderChanged(): void;
+    protected getColumnInternalsOptions(): ColumnInternalsOptions;
+    protected labelFieldNameChanged(): void;
+    protected hrefFieldNameChanged(): void;
+    protected appearanceChanged(): void;
+    protected underlineHiddenChanged(): void;
+    protected hreflangChanged(): void;
+    protected pingChanged(): void;
+    protected referrerpolicyChanged(): void;
+    protected relChanged(): void;
+    protected targetChanged(): void;
+    protected typeChanged(): void;
+    protected downloadChanged(): void;
+    private updateColumnConfig;
+}
+export declare const tableColumnAnchorTag = "nimble-table-column-anchor";
+export {};

package/dist/esm/src/table-column/base/cell-view/index.d.ts

@@ -0,0 +1,22 @@
+import { FoundationElement } from '@microsoft/fast-foundation';
+import type { TableColumn } from '..';
+import type { TableCellRecord, TableCellState } from '../types';
+/**
+ * Base class for table cell views, which are used within the nimble-table-cell.
+ * Each TableColumn type has a corresponding TableCellView type (linked via TableColumn.cellViewTag).
+ */
+export declare abstract class TableCellView<TCellRecord extends TableCellRecord = TableCellRecord, TColumnConfig = unknown> extends FoundationElement implements TableCellState<TCellRecord, TColumnConfig> {
+    cellRecord?: TCellRecord;
+    columnConfig?: TColumnConfig;
+    column?: TableColumn<TColumnConfig>;
+    recordId?: string;
+    private delegatedEvents;
+    /**
+     * Called if an element inside this cell view has focus, and this row/cell is being recycled.
+     * Expected implementation is to commit changes as needed, and blur the focusable element (or close
+     * the menu/popup/etc).
+     */
+    focusedRecycleCallback(): void;
+    columnChanged(): void;
+    private delegatedEventHandler;
+}

package/dist/esm/src/table-column/base/cell-view/template.d.ts

@@ -0,0 +1,3 @@
+import { type ViewTemplate } from '@microsoft/fast-element';
+import type { TableCell } from '../../../table/components/cell';
+export declare const createCellViewTemplate: (cellViewTag: string) => ViewTemplate<TableCell>;

package/dist/esm/src/table-column/base/group-header-view/index.d.ts

@@ -0,0 +1,15 @@
+import { FoundationElement } from '@microsoft/fast-foundation';
+import type { TableFieldValue } from '../../../table/types';
+export interface TableGroupHeaderState<TGroupValue = TableFieldValue, TColumnConfig = unknown> {
+    groupHeaderValue?: TGroupValue;
+    columnConfig?: TColumnConfig;
+}
+/**
+ * The base class for group header views, which are displayed in a TableGroupRow.
+ * A TableColumn that uses the GroupableColumn mixin must provide a TableGroupHeaderView
+ * type (linked via TableColumn.groupHeaderViewTag).
+ */
+export declare abstract class TableGroupHeaderView<TGroupValue = TableFieldValue, TColumnConfig = unknown> extends FoundationElement implements TableGroupHeaderState<TGroupValue, TColumnConfig> {
+    groupHeaderValue?: TGroupValue;
+    columnConfig?: TColumnConfig;
+}

package/dist/esm/src/table-column/base/group-header-view/template.d.ts

@@ -0,0 +1,3 @@
+import { ViewTemplate } from '@microsoft/fast-element';
+import type { TableGroupRow } from '../../../table/components/group-row';
+export declare const createGroupHeaderViewTemplate: (groupHeaderViewTag: string) => ViewTemplate<TableGroupRow>;

package/dist/esm/src/table-column/base/index.d.ts

@@ -0,0 +1,35 @@
+import { FoundationElement } from '@microsoft/fast-foundation';
+import { TableColumnSortDirection } from '../../table/types';
+import { ColumnInternals, ColumnInternalsOptions } from './models/column-internals';
+import type { TableColumnValidity } from './types';
+/**
+ * The base class for table columns
+ */
+export declare abstract class TableColumn<TColumnConfig = unknown> extends FoundationElement {
+    /**
+     * @internal
+     *
+     * Column properties configurable by plugin authors
+     */
+    readonly columnInternals: ColumnInternals<TColumnConfig>;
+    columnId?: string;
+    actionMenuSlot?: string;
+    actionMenuLabel?: string;
+    columnHidden: boolean;
+    sortIndex?: number | null;
+    sortDirection: TableColumnSortDirection;
+    sortingDisabled: boolean;
+    /** @internal */
+    hasOverflow: boolean;
+    /** @internal */
+    contentSlot: HTMLSlotElement;
+    checkValidity(): boolean;
+    get validity(): TableColumnValidity;
+    /** @internal */
+    get headerTextContent(): string;
+    connectedCallback(): void;
+    protected abstract getColumnInternalsOptions(): ColumnInternalsOptions;
+    protected sortDirectionChanged(): void;
+    protected sortIndexChanged(): void;
+    protected sortingDisabledChanged(): void;
+}

package/dist/esm/src/table-column/base/models/column-internals.d.ts

@@ -0,0 +1,124 @@
+import { ViewTemplate } from '@microsoft/fast-element';
+import { TableColumnSortDirection, TableFieldName } from '../../../table/types';
+import type { TableCell } from '../../../table/components/cell';
+import { TableColumnSortOperation } from '../types';
+import type { TableGroupRow } from '../../../table/components/group-row';
+export interface ColumnInternalsOptions {
+    /**
+     * The tag (element name) of the custom element that renders the cell content for the column.
+     * That element should derive from TableCellView<TCellRecord, TColumnConfig>.
+     */
+    readonly cellViewTag: string;
+    /**
+     * The names of the fields that should be present in TCellRecord.
+     * This array is parallel with the field names specified by `dataRecordFieldNames`.
+     */
+    readonly cellRecordFieldNames: readonly TableFieldName[];
+    /**
+     * The tag to use to render the group header content for a column.
+     * The element this tag refers to must derive from TableGroupHeaderView.
+     */
+    readonly groupHeaderViewTag: string;
+    /**
+     * The names of events that should be delegated from the cell view to the column.
+     */
+    readonly delegatedEvents: readonly string[];
+    /**
+     * The sort operation to use for the column (defaults to TableColumnSortOperation.basic)
+     */
+    readonly sortOperation?: TableColumnSortOperation;
+}
+/**
+ * Internal column state configured by plugin authors
+ * @internal
+ */
+export declare class ColumnInternals<TColumnConfig> {
+    /**
+     * @see ColumnInternalsOptions.cellRecordFieldNames
+     */
+    readonly cellRecordFieldNames: readonly TableFieldName[];
+    /**
+     * A unique id used internally in the table to identify specific column instances
+     */
+    readonly uniqueId: string;
+    /**
+     * Template for the cell view
+     */
+    readonly cellViewTemplate: ViewTemplate<TableCell>;
+    /**
+     * The names of events that should be delegated from the cell view to the column.
+     */
+    readonly delegatedEvents: readonly string[];
+    /**
+     * The relevant, static configuration a column requires its cell view to have access to.
+     */
+    columnConfig?: TColumnConfig;
+    /**
+     * Whether this column has a valid configuration.
+     */
+    validConfiguration: boolean;
+    /**
+     * The name of the data field that will be used for operations on the table, such as sorting and grouping.
+     */
+    operandDataRecordFieldName?: TableFieldName;
+    /**
+     * The operation to use when sorting the table by this column.
+     */
+    sortOperation: TableColumnSortOperation;
+    /**
+     * The names of the fields from the row's record that correlate to the data that will be in TCellRecord.
+     * This array is parallel with the field names specified by `cellRecordFieldNames`.
+     */
+    dataRecordFieldNames: readonly (TableFieldName | undefined)[];
+    /**
+     * Template for the group header view
+     */
+    readonly groupHeaderViewTemplate: ViewTemplate<TableGroupRow>;
+    /**
+     * Whether or not this column can be used to group rows by
+     */
+    groupingDisabled: boolean;
+    /**
+     * Specifies the grouping precedence of the column within the set of all columns participating in grouping.
+     * Columns are rendered in the grouping tree from lowest group-index as the tree root to highest
+     * group-index as tree leaves.
+     */
+    groupIndex?: number;
+    /**
+     * Used by column plugins to set a specific pixel width. Sets currentPixelWidth when changed.
+     */
+    pixelWidth?: number;
+    /**
+     * Used by column plugins to size a column proportionally to the available
+     * width of a row. Sets currentFractionalWidth when changed.
+     */
+    fractionalWidth: number;
+    /**
+     * The minimum size in pixels according to the design doc
+     */
+    minPixelWidth: number;
+    /**
+     * @internal Do not write to this value directly. It is used by the Table in order to store
+     * the resolved value of the fractionalWidth after updates programmatic or interactive updates.
+     */
+    currentFractionalWidth: number;
+    /**
+     * @internal Do not write to this value directly. It is used by the Table in order to store
+     * the resolved value of the pixelWidth after programmatic or interactive updates.
+     */
+    currentPixelWidth?: number;
+    /**
+     * @internal Do not write to this value directly. It is used by the Table in order to store
+     * the resolved value of the sortIndex after programmatic or interactive updates.
+     */
+    currentSortIndex?: number | null;
+    /**
+     * @internal Do not write to this value directly. It is used by the Table in order to store
+     * the resolved value of the sortDirection after programmatic or interactive updates.
+     */
+    currentSortDirection: TableColumnSortDirection;
+    constructor(options: ColumnInternalsOptions);
+    protected fractionalWidthChanged(): void;
+    protected pixelWidthChanged(): void;
+}
+export declare function isColumnInternalsProperty(changedProperty: string, ...args: (keyof ColumnInternals<unknown>)[]): boolean;

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

@@ -0,0 +1,19 @@
+import { Validator } from '../../../utilities/models/validator';
+import type { TableColumnValidity } from '../types';
+import type { ColumnInternals } from './column-internals';
+/**
+ * Base column validator
+ */
+export declare class ColumnValidator<ValidityFlagNames extends readonly string[]> extends Validator<ValidityFlagNames> {
+    private readonly columnInternals;
+    constructor(columnInternals: ColumnInternals<unknown>, configValidityKeys: ValidityFlagNames);
+    /**
+     * @returns an object containing flags for various ways the configuation can be invalid
+     */
+    getValidity(): TableColumnValidity;
+    /**
+     * Sets a particular validity condition flag's value, e.g. "hasInvalidFooValue" = true
+     */
+    protected setConditionValue(name: ValidityFlagNames extends readonly (infer U)[] ? U : never, isInvalid: boolean): void;
+    private updateColumnInternalsFlag;
+}

package/dist/esm/src/table-column/base/styles.d.ts

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

package/dist/esm/src/table-column/base/template.d.ts

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

package/dist/esm/src/table-column/base/types.d.ts

@@ -0,0 +1,38 @@
+import type { TableRecord } from '../../table/types';
+import type { ValidityObject } from '../../utilities/models/validator';
+/**
+ * An object whose fields are defined by a particular TableColumn, which is used by the column's
+ * cellTemplate implementation.
+ */
+export interface TableCellRecord extends TableRecord {
+}
+export interface TableCellState<TCellRecord extends TableCellRecord = TableCellRecord, TColumnConfig = unknown> {
+    cellRecord?: TCellRecord;
+    columnConfig?: TColumnConfig;
+}
+/**
+ * The event details for the 'delegated-event' CustomEvent
+ */
+export interface DelegatedEventEventDetails {
+    originalEvent: Event;
+    recordId: string;
+}
+/**
+ * The possible operations to use when sorting a table column.
+ */
+export declare const TableColumnSortOperation: {
+    /**
+     * Performs a sort using `===`, `<`, and `>` operators
+     */
+    readonly basic: "basic";
+    /**
+     * Performs a locale-aware case-sensitive string sort on the columns.
+     * Only use this sort operation if the field is of type `string | undefined | null`.
+     */
+    readonly localeAwareCaseSensitive: "localeAwareCaseSensitive";
+};
+export type TableColumnSortOperation = (typeof TableColumnSortOperation)[keyof typeof TableColumnSortOperation];
+export interface TableColumnValidity extends ValidityObject {
+}
+export declare const defaultMinPixelWidth: number;
+export declare const defaultFractionalWidth = 1;

package/dist/esm/src/table-column/date-text/cell-view/index.d.ts

@@ -0,0 +1,14 @@
+import type { TableColumnDateTextCellRecord, TableColumnDateTextColumnConfig } from '..';
+import { TableColumnTextCellViewBase } from '../../text-base/cell-view';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-table-column-date-text-cell-view': TableColumnDateTextCellView;
+    }
+}
+/**
+ * A cell view for displaying date/time fields as text
+ */
+export declare class TableColumnDateTextCellView extends TableColumnTextCellViewBase<TableColumnDateTextCellRecord, TableColumnDateTextColumnConfig> {
+    protected updateText(): void;
+}
+export declare const tableColumnDateTextCellViewTag = "nimble-table-column-date-text-cell-view";

package/dist/esm/src/table-column/date-text/group-header-view/index.d.ts

@@ -0,0 +1,15 @@
+import type { TableNumberFieldValue } from '../../../table/types';
+import { TableColumnTextGroupHeaderViewBase } from '../../text-base/group-header-view';
+import type { TableColumnDateTextColumnConfig } from '..';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-table-column-date-text-group-header': TableColumnDateTextGroupHeaderView;
+    }
+}
+/**
+ * The group header view for displaying date/time fields as text.
+ */
+export declare class TableColumnDateTextGroupHeaderView extends TableColumnTextGroupHeaderViewBase<TableNumberFieldValue, TableColumnDateTextColumnConfig> {
+    protected updateText(): void;
+}
+export declare const tableColumnDateTextGroupHeaderViewTag = "nimble-table-column-date-text-group-header-view";