@govbr-ds/webcomponents 2.5.0 → 2.6.0

package/dist/types/components/table/table.data.d.ts

@@ -0,0 +1,78 @@
+import type { TableData, TableSortState } from './table.types';
+import type { TableVirtualRange } from './table.virtual-list';
+export type TableVirtualColumn = {
+    element: HTMLBrTableHeaderCellElement;
+};
+export type TableVirtualCell = {
+    element: HTMLBrTableCellElement;
+};
+export type TableVirtualRow = {
+    element: HTMLBrTableRowElement;
+    cells: TableVirtualCell[];
+    originalIndex: number;
+};
+export type TableVirtualAction = {
+    element: HTMLBrTableActionElement;
+};
+export type TableVirtualData = {
+    headerRows: HTMLBrTableRowElement[];
+    columns: TableVirtualColumn[];
+    rows: TableVirtualRow[];
+    globalActions: TableVirtualAction[];
+    contextualActions: TableVirtualAction[];
+};
+/**
+ * Gerencia o modelo lógico e a materialização virtual da tabela.
+ *
+ * Responsabilidades principais:
+ * - Capturar marcação já presente no host (`capture`).
+ * - Substituir o conjunto lógico por dados programáticos (`replace`).
+ * - Materializar a janela virtual, preservando linhas já montadas (`mount`, `renderRange`).
+ *
+ * Observação sobre materialização de conteúdo:
+ * - Quando `TableDataContent` contém nós (`Node`), esses nós são
+ *   transferidos para as células usando `appendChild()` (re-anexação no DOM).
+ *   Não há clonagem automática; consumidores que precisam preservar o
+ *   nó original devem clonar antes de passá-lo à tabela.
+ */
+export declare class TableDataStore {
+    private data;
+    private body;
+    private rowElements;
+    private rowView?;
+    private renderedRows;
+    private itemGroups?;
+    private pageBoundaries?;
+    /** Invalida apenas as unidades derivadas quando uma chave de grupo muda. */
+    invalidateGroups(): void;
+    private getItemGroups;
+    capture(host: HTMLBrTableElement): void;
+    replace(data: TableData): void;
+    mount(host: HTMLBrTableElement): void;
+    /**
+     * Reordena o dataset lógico completo antes da materialização virtual.
+     * Critérios com menor `columnIndex` possuem maior prioridade no multi-sort.
+     */
+    sortRows(sorting: TableSortState[]): void;
+    /** Retorna as colunas lógicas, sem as colunas geradas de seleção/expansão. */
+    getColumns(): HTMLBrTableHeaderCellElement[];
+    private getSortValue;
+    private generatedColumnCount;
+    /** Itens lógicos de paginação: grupos contíguos ou linhas independentes. */
+    getItemCount(): number;
+    /** Limites físicos da página, sem dividir grupos. */
+    getPageRange(startItem: number, itemCount: number): {
+        start: number;
+        end: number;
+    };
+    private compareSortValues;
+    renderRange(range: TableVirtualRange, rows?: TableVirtualRow[], indexOffset?: number): void;
+    getRows(): HTMLBrTableRowElement[];
+    /** Visão interna somente leitura, estável até a ordem, os dados ou o recorte mudarem. */
+    getRowsView(start?: number, end?: number): readonly HTMLBrTableRowElement[];
+    private refreshRowElements;
+    getRow(index: number): HTMLBrTableRowElement | undefined;
+    getRowCount(): number;
+    getRenderedRows(): HTMLBrTableRowElement[];
+    private createSpacer;
+}

package/dist/types/components/table/table.expansion.d.ts

@@ -0,0 +1,65 @@
+import type { TableRowExpansionChangeDetail, TableRowExpansionChangeSource } from './table.types';
+/**
+ * Dependências necessárias ao controller de expansão.
+ */
+export type TableExpansionControllerOptions = {
+    host: HTMLBrTableElement;
+    getRows?: () => HTMLBrTableRowElement[];
+    onChange: (detail: TableRowExpansionChangeDetail) => void;
+};
+/**
+ * Coordena a coluna, as ações e o estado de expansão das linhas.
+ *
+ * @remarks A coluna permanece estruturalmente alinhada mesmo em linhas desabilitadas.
+ */
+export declare class TableExpansionController {
+    private readonly options;
+    constructor(options: TableExpansionControllerOptions);
+    /**
+     * Sincroniza a estrutura segundo a configuração global e os overrides das linhas.
+     *
+     * @param tableEnabled Indica se a expansão está habilitada na tabela.
+     */
+    sync(tableEnabled: boolean): void;
+    /**
+     * Consome cliques originados pelas ações internas de expansão.
+     *
+     * @param event Evento emitido por `br-table-action`.
+     * @returns `true` quando o evento foi tratado como expansão.
+     */
+    handleActionClick(event: CustomEvent): boolean;
+    /**
+     * Define o estado de expansão de uma linha elegível.
+     *
+     * @param row Linha que receberá a mudança.
+     * @param expanded Novo estado de expansão.
+     * @param source Origem utilizada no evento público.
+     */
+    setExpanded(row: HTMLBrTableRowElement, expanded: boolean, source?: TableRowExpansionChangeSource): void;
+    /**
+     * Recolhe todas as linhas atualmente expandidas.
+     */
+    collapseAll(): void;
+    private getBodyRows;
+    /**
+     * Resolve o override declarado diretamente na linha.
+     */
+    private getRowOverride;
+    private isRowEnabled;
+    /**
+     * Garante que a coluna de expansão permaneça na primeira posição.
+     */
+    private ensureHeaderCell;
+    /**
+     * Sincroniza ação, célula estrutural e atributos de uma linha.
+     */
+    private syncRow;
+    /**
+     * Atualiza ícone e rótulos da ação pertencente à linha.
+     */
+    private syncRowAction;
+    /**
+     * Remove somente os elementos e atributos gerados pela expansão.
+     */
+    private removeColumn;
+}

package/dist/types/components/table/table.expansion.elements.d.ts

@@ -0,0 +1,30 @@
+import type { CreateExpansionActionOptions } from './table.types';
+/**
+ * Sincroniza ícone, rótulos e estado acessível da ação de expansão.
+ *
+ * @param action Componente de ação que será atualizado.
+ * @param expanded Estado atual da linha.
+ * @param rowIndex Índice da linha no corpo, começando em zero.
+ */
+export declare function syncExpansionAction(action: HTMLBrTableActionElement, expanded: boolean, rowIndex: number): void;
+/**
+ * Cria uma ação de expansão reutilizando `br-table-action`.
+ *
+ * @param options Estado inicial e índice da linha.
+ * @returns Ação identificada para consumo interno do controller.
+ */
+export declare function createExpansionAction({ expanded, rowIndex }: CreateExpansionActionOptions): HTMLBrTableActionElement;
+/**
+ * Cria a célula estrutural da coluna de expansão.
+ *
+ * @param action Ação opcional; linhas desabilitadas utilizam célula vazia.
+ * @returns Célula marcada como gerada pelo controller de expansão.
+ */
+export declare function createExpansionCell(action?: HTMLBrTableActionElement): HTMLBrTableCellElement;
+/**
+ * Cria o cabeçalho vazio que define a coluna de expansão no grid.
+ *
+ * @param slotName Slot utilizado pelos demais cabeçalhos.
+ * @returns Cabeçalho com largura e alinhamentos apropriados ao chevron.
+ */
+export declare function createExpansionHeaderCell(slotName?: string): HTMLBrTableHeaderCellElement;

package/dist/types/components/table/table.grouping.d.ts

@@ -0,0 +1,25 @@
+/** Geometria e limites compartilhados pelo modelo e pela janela virtual da tabela. */
+export type TableCellPlacement = {
+    cell: HTMLElement;
+    row: number;
+    column: number;
+    rowSpan: number;
+    colSpan: number;
+};
+/** Entradas inválidas seguem o comportamento de uma célula simples. */
+export declare function resolveTableSpan(value: string | null): number;
+/** Posiciona células omitidas por mesclas, sem depender da posição no array da linha. */
+export declare function getTablePlacements(rows: readonly HTMLElement[], selector: string): TableCellPlacement[];
+/** Colunas finais, incluindo folhas que atravessam níveis do cabeçalho. */
+export declare function getTableLeafHeaders(rows: readonly HTMLElement[]): HTMLBrTableHeaderCellElement[];
+/** Um grupo é uma sequência contígua com a mesma chave; linhas sem chave são unidades independentes. */
+export declare function getTableRowGroups<T extends HTMLElement>(rows: readonly T[]): T[][];
+/** Amplia uma faixa sem separar células mescladas ou linhas de um mesmo grupo. */
+export declare function expandTableGroupRange(rows: readonly HTMLElement[], start: number, end: number): {
+    start: number;
+    end: number;
+};
+/** Escreve apenas tokens internos e ARIA; não modifica props públicas do consumidor. */
+export declare function applyTablePlacements(placements: TableCellPlacement[]): void;
+/** Configura a grade multinível e estende as colunas geradas até o último nível. */
+export declare function applyTableHeaderLayout(header: HTMLElement | null): void;

package/dist/types/components/table/table.header-height.d.ts

@@ -0,0 +1,17 @@
+/** Protocolo interno de medição: a célula mantém a propriedade de sua superfície. */
+export type TableHeaderHeight = {
+    host: HTMLElement;
+    height: number;
+    refresh: () => void;
+};
+/** Publica a altura border-box fora do ciclo de scroll. */
+export declare class TableHeaderHeightObserver {
+    private readonly host;
+    private readonly surface;
+    private observer?;
+    constructor(host: HTMLElement, surface: HTMLElement);
+    connect(): void;
+    disconnect(): void;
+    private refresh;
+    private publish;
+}

package/dist/types/components/table/table.keyboard.d.ts

@@ -0,0 +1,53 @@
+/** Protocolo interno: cada célula administra sua própria superfície e controles. */
+export type TableCellFocus = {
+    host: HTMLElement;
+    surface: HTMLElement;
+    controls: () => HTMLElement[];
+    update: (active: boolean, hasGridControls: boolean) => void;
+};
+/** Coordena apenas o DOM pertencente à célula, sem acessar internals de controles. */
+export declare class TableCellKeyboard {
+    private readonly host;
+    private readonly surface;
+    private originalTabIndexes;
+    private observer?;
+    private active;
+    private hasGridControls;
+    constructor(host: HTMLElement, surface: HTMLElement);
+    connect(): void;
+    disconnect(): void;
+    private candidates;
+    private controls;
+    private sync;
+    private restoreTabIndex;
+    private notifyFocusRegistration;
+}
+/** Gerencia a célula ativa e os dois modos de teclado de uma instância da grade. */
+export declare class TableKeyboardController {
+    private readonly host;
+    private readonly getRows;
+    private readonly reveal;
+    private readonly pageSize;
+    private cells;
+    private active?;
+    private interacting;
+    private hasFocused;
+    private pendingFocus?;
+    private focusFrame?;
+    private transitionTabIndex?;
+    private scrollerTabIndexSet?;
+    constructor(host: HTMLElement, getRows: () => HTMLElement[][], reveal: (cell: HTMLElement) => void, pageSize: () => number);
+    register(cell: TableCellFocus): void;
+    sync(): void;
+    disconnect(): void;
+    focusIn(event: FocusEvent): void;
+    focusOut(event: FocusEvent): void;
+    keyDown(event: KeyboardEvent): void;
+    private handleInteraction;
+    private navigate;
+    private skipMergedCell;
+    private abandonPendingFocus;
+    private releaseTransitionFocus;
+    private focusPendingCell;
+    private cellFromEvent;
+}

package/dist/types/components/table/table.scroll-shadows.d.ts

@@ -0,0 +1,11 @@
+/** Mantém os indicadores de conteúdo oculto sincronizados com a área rolável. */
+export declare class TableScrollShadows {
+    private viewport;
+    private shell;
+    private observer?;
+    constructor(viewport: HTMLElement, content: HTMLElement, shell: HTMLElement);
+    /** Recalcula as bordas, tolerando arredondamento de pixels nas extremidades. */
+    update: () => void;
+    /** Remove listeners e observadores ao desmontar a superfície. */
+    disconnect(): void;
+}

package/dist/types/components/table/table.selection.d.ts

@@ -0,0 +1,84 @@
+import type { TableSelectionChangeDetail, TableSelectionChangeSource } from './table.types';
+/**
+ * Dependências necessárias ao controller de seleção.
+ */
+export type TableSelectionControllerOptions = {
+    host: HTMLBrTableElement;
+    idPrefix: string;
+    onChange: (detail: TableSelectionChangeDetail) => void;
+    getRows?: () => HTMLBrTableRowElement[];
+};
+/**
+ * Coordena a estrutura e o estado da seleção sem acoplar regras ao componente raiz.
+ *
+ * @remarks O controller mantém checkbox, atributos da linha, ARIA e cabeçalho sincronizados.
+ */
+export declare class TableSelectionController {
+    private readonly options;
+    private isSynchronizing;
+    private checkboxDisabledStates;
+    constructor(options: TableSelectionControllerOptions);
+    /**
+     * Sincroniza a coluna de seleção com a configuração atual da tabela.
+     *
+     * @param enabled Indica se a seleção está habilitada globalmente.
+     */
+    sync(enabled: boolean): void;
+    /**
+     * Processa eventos emitidos exclusivamente pelos checkboxes gerados.
+     *
+     * @param event Evento `checkedChange` recebido pela tabela.
+     * @returns `true` quando o evento pertencia ao subsistema de seleção.
+     */
+    handleCheckboxChange(event: CustomEvent<boolean>): boolean;
+    /**
+     * Retorna o estado de seleção derivado das linhas do corpo.
+     *
+     * @returns Linhas que possuem `selected` ou `data-selected`.
+     */
+    getSelectedRows(): HTMLBrTableRowElement[];
+    /**
+     * Aplica o mesmo estado a todas as linhas selecionáveis.
+     *
+     * @param selected Novo estado das linhas.
+     * @param source Origem utilizada no evento de mudança.
+     */
+    selectAll(selected: boolean, source?: TableSelectionChangeSource): void;
+    /**
+     * Limpa todas as linhas selecionáveis.
+     *
+     * @param source Origem utilizada no evento de mudança.
+     */
+    clear(source?: TableSelectionChangeSource): void;
+    private getCheckboxFromEvent;
+    private getBodyRows;
+    private getRowCheckbox;
+    private getSelectableEntries;
+    private getHeaderCheckbox;
+    /**
+     * Atualiza o estado visual e acessível de uma linha.
+     */
+    private applyRowState;
+    private syncRowsFromState;
+    private syncCheckboxDisabledState;
+    /**
+     * Sincroniza o checkbox global, incluindo o estado indeterminado.
+     */
+    private syncHeaderCheckbox;
+    /**
+     * Garante a existência do cabeçalho da coluna de seleção.
+     */
+    private ensureHeaderCell;
+    /**
+     * Garante uma célula de seleção para cada linha do corpo.
+     */
+    private ensureRowCells;
+    /**
+     * Remove somente os elementos e atributos gerados pela seleção.
+     */
+    private remove;
+    /**
+     * Publica um retrato consistente da seleção após uma mudança.
+     */
+    private notifyChange;
+}

package/dist/types/components/table/table.selection.elements.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Categoria funcional de um checkbox de seleção.
+ *
+ * @remarks `all` controla o conjunto e `row` controla uma única linha.
+ */
+export type TableSelectionCheckboxKind = 'all' | 'row';
+/**
+ * Opções necessárias para criar um checkbox acessível de seleção.
+ */
+export type CreateSelectionCheckboxOptions = {
+    kind: TableSelectionCheckboxKind;
+    label: string;
+    name: string;
+};
+/**
+ * Opções necessárias para criar o cabeçalho da coluna de seleção.
+ */
+export type CreateSelectionHeaderCellOptions = {
+    checkbox: HTMLBrCheckboxElement;
+    slotName?: string;
+};
+/**
+ * Cria uma instância configurada do componente `br-checkbox`.
+ *
+ * @param options Categoria, rótulo acessível e nome do controle.
+ * @returns Checkbox pronto para ser anexado a uma célula.
+ */
+export declare function createSelectionCheckbox({ kind, label, name }: CreateSelectionCheckboxOptions): HTMLBrCheckboxElement;
+/**
+ * Cria a célula estrutural de seleção de uma linha.
+ *
+ * @param checkbox Controle associado à linha.
+ * @returns Célula marcada como gerada pelo controller de seleção.
+ */
+export declare function createSelectionCell(checkbox: HTMLBrCheckboxElement): HTMLBrTableCellElement;
+/**
+ * Cria o cabeçalho que define largura e alinhamentos da coluna de seleção.
+ *
+ * @param options Checkbox global e slot opcional do cabeçalho.
+ * @returns Cabeçalho configurado para participar do grid da tabela.
+ */
+export declare function createSelectionHeaderCell({ checkbox, slotName, }: CreateSelectionHeaderCellOptions): HTMLBrTableHeaderCellElement;

package/dist/types/components/table/table.tokens.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Custom properties utilizadas para comunicar valores calculados aos componentes.
+ *
+ * @module table-tokens
+ */
+/**
+ * Nomes canônicos dos tokens CSS internos da tabela.
+ *
+ * @remarks Centralizar os nomes evita divergências entre TypeScript e SCSS.
+ */
+export declare const TABLE_TOKENS: {
+    readonly COLUMN_WIDTHS: "--br-table-column-widths";
+    readonly DENSITY: "--br-table-density";
+    readonly BAR_PADDING: "--br-table-bar-padding";
+    readonly HORIZONTAL_ALIGNMENT: "--br-table-horizontal-alignment";
+    readonly VERTICAL_ALIGNMENT: "--br-table-vertical-alignment";
+    readonly DIVIDER_STYLE: "--br-table-divider-style";
+    readonly COLUMN_DIVIDER_FACTOR: "--br-table-column-divider-factor";
+    readonly ROW_DIVIDER_FACTOR: "--br-table-row-divider-factor";
+    readonly CELL_OVERFLOW: "--br-table-cell-overflow";
+    readonly CELL_TEXT_OVERFLOW: "--br-table-cell-text-overflow";
+    readonly CELL_WHITE_SPACE: "--br-table-cell-white-space";
+    readonly EXPANDED_CONTENT_HEIGHT: "--br-table-expanded-content-height";
+};

package/dist/types/components/table/table.types.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Tipos públicos compartilhados pelos componentes da tabela.
+ *
+ * @module table-types
+ */
+import type { COLUMN_WIDTH_SEMANTICS, TABLE_ALIGNMENT, TABLE_CELL_OVERFLOW, TABLE_CELL_TEXT_OVERFLOW, TABLE_CELL_WHITE_SPACE, TABLE_DENSITY, TABLE_DIVIDER_STYLE, TABLE_OVERFLOW, TABLE_ROW_EXPANSION, TABLE_SORT_DIRECTION, TABLE_SORT_MODE, TABLE_SORT_STRATEGY, TABLE_TOOLTIP_MODE, TABLE_TOOLTIP_STATE } from './table.constants';
+type ValueOf<T> = T[keyof T];
+type CSSFixed = `${number}px`;
+type CSSFraction = `${number}fr`;
+/**
+ * Largura semântica, fixa ou fracionária aceita por uma coluna.
+ */
+export type ColumnWidth = ValueOf<typeof COLUMN_WIDTH_SEMANTICS> | CSSFixed | CSSFraction;
+/**
+ * Densidade visual suportada pela tabela.
+ */
+export type TableDensity = ValueOf<typeof TABLE_DENSITY>;
+/**
+ * Alinhamento semântico horizontal ou vertical.
+ */
+export type TableAlignment = ValueOf<typeof TABLE_ALIGNMENT>;
+export type TableDividerStyle = ValueOf<typeof TABLE_DIVIDER_STYLE>;
+export type TableCellOverflow = ValueOf<typeof TABLE_CELL_OVERFLOW>;
+export type TableCellTextOverflow = ValueOf<typeof TABLE_CELL_TEXT_OVERFLOW>;
+export type TableCellWhiteSpace = ValueOf<typeof TABLE_CELL_WHITE_SPACE>;
+/**
+ * Estratégia de tratamento do conteúdo excedente.
+ */
+export type TableOverflow = ValueOf<typeof TABLE_OVERFLOW>;
+export type TableTooltipState = ValueOf<typeof TABLE_TOOLTIP_STATE>;
+export type TableTooltipMode = ValueOf<typeof TABLE_TOOLTIP_MODE>;
+/** Modo de ordenação utilizado pela tabela. */
+export type TableSortMode = ValueOf<typeof TABLE_SORT_MODE>;
+/** Estratégia de aplicação da ordenação. */
+export type TableSortStrategy = ValueOf<typeof TABLE_SORT_STRATEGY>;
+/** Direção aplicada a uma coluna ordenada. */
+export type TableSortDirection = ValueOf<typeof TABLE_SORT_DIRECTION>;
+/** Critério de ordenação ativo. */
+export type TableSortState = {
+    columnIndex: number;
+    direction: TableSortDirection;
+};
+/** Detalhes publicados após uma mudança de ordenação. */
+export type TableSortChangeDetail = {
+    mode: TableSortMode;
+    sorting: TableSortState[];
+    rows: HTMLBrTableRowElement[];
+};
+/** Detalhes publicados antes de aplicar uma solicitação de ordenação. */
+export type TableSortRequestDetail = {
+    mode: TableSortMode;
+    columnIndex: number;
+    currentSorting: TableSortState[];
+    nextSorting: TableSortState[];
+};
+/**
+ * Origem de uma mudança no conjunto de linhas selecionadas.
+ */
+export type TableSelectionChangeSource = 'row' | 'all' | 'programmatic';
+/**
+ * Detalhes publicados após uma mudança de seleção.
+ *
+ * @property selectedRows Linhas atualmente selecionadas.
+ * @property selectedIndexes Índices das linhas selecionadas no corpo.
+ * @property selectedCount Quantidade total selecionada.
+ * @property rowIndex Índice da linha que originou a mudança quando `source='row'`.
+ * @property source Origem da mudança.
+ */
+export type TableSelectionChangeDetail = {
+    selectedRows: HTMLBrTableRowElement[];
+    selectedIndexes: number[];
+    selectedCount: number;
+    rowIndex?: number;
+    source: TableSelectionChangeSource;
+};
+/**
+ * Detalhes publicados quando uma ação é acionada.
+ *
+ * @property type Contexto no qual a ação foi declarada.
+ * @property label Rótulo que identifica a ação para o consumidor.
+ * @property rowIndex Índice da linha no corpo quando a ação pertence a uma linha.
+ */
+export type TableActionClickDetail = {
+    type: 'global' | 'contextual' | 'row';
+    label: string;
+    rowIndex?: number;
+};
+/** Termo enviado por Enter, pelo botão de busca ou vazio ao fechar a busca. */
+export type TableSearchDetail = {
+    term: string;
+};
+/** Detalhes publicados quando o consumidor solicita outra página pela paginação do rodapé. */
+export type TablePageChangeDetail = {
+    page: number;
+};
+/** Detalhes publicados quando o consumidor solicita outra quantidade de itens por página. */
+export type TablePageSizeChangeDetail = {
+    pageSize: number;
+};
+/**
+ * Configuração de expansão específica de uma linha.
+ */
+export type TableRowExpansion = ValueOf<typeof TABLE_ROW_EXPANSION>;
+/**
+ * Origem de uma mudança no estado de expansão.
+ */
+export type TableRowExpansionChangeSource = 'action' | 'programmatic';
+/**
+ * Detalhes publicados após expandir ou recolher uma linha.
+ *
+ * @property row Linha afetada pela mudança.
+ * @property rowIndex Índice da linha no corpo.
+ * @property expanded Novo estado de expansão.
+ * @property source Origem da mudança.
+ */
+export type TableRowExpansionChangeDetail = {
+    row: HTMLBrTableRowElement;
+    rowIndex: number;
+    expanded: boolean;
+    source: TableRowExpansionChangeSource;
+};
+/**
+ * Opções necessárias para criar a ação de expansão de uma linha.
+ */
+export type CreateExpansionActionOptions = {
+    expanded: boolean;
+    rowIndex: number;
+};
+/** Conteúdo aceito pela API de dados da tabela. */
+export type TableDataContent = string | number | Node | Array<string | number | Node> | null;
+/** Ação declarada pela API de dados. */
+export type TableActionData = {
+    label: string;
+    iconName?: string;
+    ariaLabel?: string;
+};
+/** Célula declarada pela API de dados. */
+export type TableCellData = {
+    /** Identifica a célula como cabeçalho de linha/grupo. */
+    rowHeader?: boolean;
+    /** Colunas ocupadas (1–1000); inválido usa 1. */
+    colSpan?: number;
+    /** Linhas ocupadas dentro do grupo contíguo; inválido usa 1. */
+    rowSpan?: number;
+    content?: TableDataContent;
+    actions?: TableActionData[];
+    horizontalAlignment?: TableAlignment;
+    verticalAlignment?: TableAlignment;
+    overflow?: TableOverflow;
+    tooltipState?: TableTooltipState;
+    tooltipMode?: TableTooltipMode;
+    cellActionsLimit?: number;
+    /** Valor opcional usado pela ordenação no lugar do texto renderizado. */
+    sortValue?: string | number;
+};
+/** Coluna declarada pela API de dados. */
+export type TableColumnData = {
+    /** Colunas agrupadas (1–1000). Cabeçalhos com mais de uma coluna não ordenam. */
+    colSpan?: number;
+    /** Níveis ocupados no cabeçalho. */
+    rowSpan?: number;
+    content?: TableDataContent;
+    columnWidth?: ColumnWidth;
+    horizontalAlignment?: TableAlignment;
+    verticalAlignment?: TableAlignment;
+    overflow?: TableOverflow;
+    tooltipState?: TableTooltipState;
+    tooltipMode?: TableTooltipMode;
+    /** Habilita o trigger de ordenação desta coluna. */
+    sortable?: boolean;
+};
+/** Linha declarada pela API de dados. */
+export type TableRowData = {
+    /** Chave do grupo contíguo; omitida mantém a linha independente. */
+    rowGroup?: string;
+    cells: TableCellData[];
+    selected?: boolean;
+    disabled?: boolean;
+    expanded?: boolean;
+    rowExpansion?: TableRowExpansion;
+    /** Altura visível da área expandida desta linha, em pixels. */
+    virtualExpandedContentHeight?: number;
+    expandedContent?: TableDataContent;
+    horizontalAlignment?: TableAlignment;
+    verticalAlignment?: TableAlignment;
+    overflow?: TableOverflow;
+    tooltipState?: TableTooltipState;
+    tooltipMode?: TableTooltipMode;
+};
+/** Estrutura pública utilizada para alimentar a tabela sem markup declarativo. */
+export type TableData = {
+    /** Cabeçalho multinível completo. Quando informado e não vazio, tem precedência sobre columns. */
+    headerRows?: TableColumnData[][];
+    columns: TableColumnData[];
+    rows: TableRowData[];
+    globalActions?: TableActionData[];
+    contextualActions?: TableActionData[];
+};
+export {};