@govbr-ds/webcomponents 2.4.0 → 2.6.0

package/dist/collection/components/table/table.js

@@ -2,753 +2,1980 @@
  * Construído por SERPRO
  * © https://serpro.gov.br/ - MIT License.
  */
-import { Host, h } from "@stencil/core";
-import { generateUniqueId } from "../../shared/utils/id";
+import { Fragment, forceUpdate, Host, h, } from "@stencil/core";
+import Helpers from "../../shared/utils/helpers";
 import { findComposedOwner } from "../../shared/utils/ownership";
-import { clearInvalidPropWarning, reportInvalidPropValue } from "../../shared/utils/prop-warning";
-import { resolveAllowedPropValue, resolveDensity } from "../../shared/utils/props";
-import { COLUMN_WIDTH_MAP, COLUMN_WIDTH_SEMANTICS, TABLE_ALIGNMENT, TABLE_ALIGNMENT_MAP, TABLE_DENSITY, TABLE_DENSITY_MAP, TABLE_DIVIDER_STYLE, TABLE_DIVIDER_STYLE_MAP, TABLE_OVERFLOW, TABLE_OVERFLOW_MAP, TABLE_TOOLTIP_MODE, TABLE_TOOLTIP_STATE, } from "./table-constants";
-import { TABLE_TOKENS } from "./table-tokens";
-import { positiveFrValidator, positivePxValidator, resolveTokenValue } from "./table-utils";
+import { COLUMN_WIDTH_MAP, COLUMN_WIDTH_SEMANTICS, TABLE_ALIGNMENT, TABLE_ALIGNMENT_MAP, TABLE_BAR_PADDING_MAP, TABLE_DENSITY, TABLE_DENSITY_MAP, TABLE_DIVIDER_STYLE, TABLE_DIVIDER_STYLE_MAP, TABLE_OVERFLOW, TABLE_OVERFLOW_MAP, TABLE_ROW_EXPANSION, TABLE_SORT_DIRECTION, TABLE_SORT_MODE, TABLE_SORT_STRATEGY, TABLE_TOOLTIP_STATE, } from "./table.constants";
+import { TableDataStore } from "./table.data";
+import { TableExpansionController } from "./table.expansion";
+import { applyTableHeaderLayout, getTableLeafHeaders, getTablePlacements, getTableRowGroups, resolveTableSpan, } from "./table.grouping";
+import { TableKeyboardController } from "./table.keyboard";
+import { TableScrollShadows } from "./table.scroll-shadows";
+import { TableSelectionController } from "./table.selection";
+import { TABLE_TOKENS } from "./table.tokens";
+import { isHydrationClassMutation, positiveFrValidator, positivePxValidator, resolveTableDensityFromElement, resolveTokenValue, } from "./table.utils";
+import { TableVirtualListController } from "./table.virtual-list";
+const MIN_VISIBLE_ROWS = 1;
+const MAX_VISIBLE_ROWS = 50;
+const DEFAULT_VISIBLE_ROWS = 10;
 /**
- * O componente `br-table` é o elemento oficial do GovBR-DS para exibição e gerenciamento de dados tabulares estruturados em linhas e colunas, desenvolvido com suporte a CSS Grid, responsividade e alta flexibilidade de composição.
+ * ## Design System
  *
- * ### Para que serve
+ * Para a documentação completa de design, incluindo diretrizes de uso, acessibilidade e exemplos visuais, consulte o [Design System do GovBR](https://www.gov.br/ds/components/table?tab=designer).
  *
- * - **Apresentação de conjuntos de dados relacionais:** Organiza registros com múltiplos atributos comparáveis (ex.: relatórios, tabelas de processos, listagens financeiras).
- * - **Recursos interativos avançados:** Suporta ordenação por coluna, seleção simples ou múltipla de linhas, densidades variadas (alta, média, baixa) e paginação integrada com `br-pagination`.
- * - **Acessibilidade WAI-ARIA:** Preserva a semântica de tabela acessível (`role="table"`, `role="columnheader"`, `role="row"`, `role="cell"`) mesmo em leiautes baseados em CSS Grid.
+ * Apresenta e permite interagir com dados tabulares; não deve ser usada para
+ * organizar layout ou conteúdo que não seja tabular. Recebe o cabeçalho e o corpo
+ * pelos slots `header` e `body`, compostos por `br-table-header` e
+ * `br-table-header-cell`, e por `br-table-body`, `br-table-row` e `br-table-cell`.
+ * Orquestra a grade, a acessibilidade, a ordenação, a seleção e a expansão das
+ * linhas. A barra de ações é gerenciada pela tabela; `br-table-footer` é
+ * renderizado quando a paginação está habilitada. As propriedades de célula
+ * seguem, quando aplicável, a precedência: célula, linha, coluna, tabela e valor
+ * padrão. Cabeçalhos multinível usam várias linhas em `br-table-header` com
+ * `colSpan`/`rowSpan`. Linhas contíguas com `rowGroup` formam unidades de ordenação,
+ * paginação e virtualização; a seleção permanece individual. Células com `rowSpan`
+ * não atravessam os limites do grupo. Prefira tabelas simples quando possível.
  *
- * ### Quando utilizar
- *
- * - **Utilize quando:**
- *   - As informações compartilharem campos e atributos fixos que justifiquem a comparação lado a lado em colunas.
- *   - A pessoa usuária precisar ordenar, filtrar ou selecionar múltiplos registros da lista.
- * - **Evite e prefira outro componente quando:**
- *   - Os itens forem heterogêneos com estruturas visuais distintas (prefira `br-card`).
- *   - Houver apenas um texto linear simples por item (prefira `br-list`).
- *
- * ### Composição e Subcomponentes
- *
- * O ecossistema da Tabela segue a hierarquia semântica modular:
- *
- * | Subcomponente | Papel | Regra de uso |
- * | --- | --- | --- |
- * | `br-table` | **Orquestrador principal.** Gerencia o grid de colunas, ordenação, seleção de linhas e densidade. | Contêiner raiz da tabela. |
- * | `br-table-header` | **Seção de cabeçalho.** Agrupa as linhas de títulos das colunas. | Declarado no slot `header` da tabela. |
- * | `br-table-body` | **Corpo de dados.** Agrupa as linhas de registros de conteúdo. | Declarado no slot `body` (ou padrão) da tabela. |
- * | `br-table-row` | **Linha.** Representa uma linha de cabeçalho ou de registro de dados. | Declarado dentro de `br-table-header` ou `br-table-body`. |
- * | `br-table-header-cell` | **Célula de título.** Célula de cabeçalho com suporte a botão de ordenação. | Declarado dentro de `br-table-row` no cabeçalho. |
- * | `br-table-cell` | **Célula de dados.** Célula de conteúdo individual de uma coluna. | Declarado dentro de `br-table-row` no corpo de dados. |
- *
- * ### Como os subcomponentes se relacionam
- *
- * A arquitetura de `br-table` reflete a semântica nativa de tabelas HTML de forma modular:
- * `br-table` → `br-table-header` / `br-table-body` → `br-table-row` → `br-table-header-cell` / `br-table-cell`.
- * O componente pai orquestra o alinhamento das colunas via tokens de Grid, distribuindo automaticamente os estados de seleção e foco para as linhas filhas.
- *
- * Para a documentação completa de design, incluindo diretrizes de acessibilidade e especificações visuais, consulte o [Design System do GovBR](https://www.gov.br/ds/components/table?tab=designer).
- *
-
- * @category Dados, Conteúdo
- * @status stable
- * @Slot header: Área para inclusão do subcomponente br-table-header
- * @Slot body: Área para inclusão do subcomponente br-table-body
+ * @slot header - Componente `br-table-header` que define as colunas.
+ * @slot body - Componente `br-table-body` que contém as linhas de dados.
+ * @slot global-actions - Ações aplicadas ao conjunto completo de dados.
+ * @slot contextual-actions - Ações aplicadas às linhas selecionadas.
  * @slot loading - Indicador exibido enquanto as linhas são atualizadas.
- *
- * @part container - Wrapper principal da tabela.
- * @part content - Área de conteúdo que contém header e body.
- * @part loading - Área do indicador de carregamento.
+ * @part container - Contêiner visual principal.
+ * @part scroll-container - Área com rolagem que contém apenas os dados da tabela.
+ * @part content - Grid que contém cabeçalho e corpo.
+ * @part footer - Contêiner do rodapé, exibido abaixo do corpo da tabela.
+ * @part loading - Scrim local e área do painel de carregamento sobre a tabela inteira.
+ * @cssprop --br-table-loading-opacity - Opacidade do conteúdo durante o carregamento. Padrão: 0.5.
+ * @fires brTableActionClick - Quando uma ação pública é acionada.
+ * @fires brTableSelectionChange - Quando o conjunto selecionado muda.
+ * @fires brTableRowExpansionChange - Quando uma linha expande ou recolhe.
+ * @fires brTableSortRequest - Antes de aplicar uma solicitação de ordenação.
+ * @fires brTableSortChange - Quando os critérios de ordenação mudam.
+ * @fires brTablePageChange - Quando o consumidor solicita outra página pela paginação do rodapé.
+ * @fires brTablePageSizeChange - Quando o consumidor solicita outra quantidade de itens por página.
+ * @fires brTableSearch - Quando a busca é enviada ou fechada.
  */
 export class Table {
     constructor() {
         /**
-         * Ativa divisores verticais entre colunas.
+         * Habilita divisores entre colunas quando `columnDivider` não é informado.
          *
+         * @deprecated Use `columnDivider` instead.
          * @default false
-         * @deprecated Use `columnDivider`.
          */
         this.hasColumnDivider = false;
         /**
-         * Ativa divisores horizontais entre linhas.
+         * Habilita divisores entre linhas quando `rowDivider` não é informado.
          *
+         * @deprecated Use `rowDivider` instead.
          * @default false
-         * @deprecated Use `rowDivider`.
          */
         this.hasRowDivider = false;
         /**
-         * Define o comportamento de overflow para as células.
+         * Habilita o realce visual das linhas ao passar o ponteiro.
+         *
+         * @default false
+         */
+        this.hasRowHover = false;
+        /**
+         * Indica que as linhas estão sendo atualizadas pelo consumidor.
+         *
+         * @remarks Mantém os dados anteriores, reduz sua opacidade e exibe o slot
+         * `loading` em um painel central com scrim sobre toda a tabela, incluindo
+         * barra de ações e paginação. O scrim fica limitado ao componente.
+         * Reflete o atributo `loading` e pode ser alterada diretamente ou pelos métodos
+         * `startLoading()` e `stopLoading()`. Não bloqueia o teclado nem gerencia
+         * requisições, erros ou substituição dos dados.
+         * @default false
+         */
+        this.loading = false;
+        /**
+         * Força a apresentação da barra contextual.
          *
-         * @remarks Valores aceitos:
-         * - truncate
-         * - wrap
+         * @default false
+         */
+        this.showContextualBar = false;
+        /**
+         * Limite usado para decidir quando agrupar ações globais em um menu.
+         * Quando o número de ações excede esse valor, as ações são agrupadas no
+         * dropdown (atualmente todas são movidas para o menu colapsado).
          *
-         * Observação:
-         * - O overflow é independente de `columnWidth`.
-         * - Com `columnWidth="content"`, a coluna tende a crescer com o conteúdo (`max-content`), o que pode reduzir casos visíveis de truncagem.
-         * - Com `columnWidth="fill"`, a coluna ocupa o espaço disponível (`1fr`), então a truncagem tende a ficar mais evidente quando não há espaço suficiente.
+         * @default 4
+         */
+        this.headingActionsLimit = 4;
+        /**
+         * Limite usado para decidir quando agrupar ações contextuais em um menu.
+         * Quando o número de ações excede esse valor, as ações são agrupadas no
+         * dropdown (atualmente todas são movidas para o menu colapsado).
          *
-         * @default wrap
+         * @default 4
          */
-        this.overflow = TABLE_OVERFLOW.WRAP;
+        this.contextualActionsLimit = 4;
         /**
-         * Define o estado semântico do tooltip nas células da tabela.
+         * Texto do tooltip do botão de ações agrupadas na barra de título.
+         * Quando vazio ou composto apenas por espaços, usa "Mais ações".
+         * Não altera o nome acessível do botão nem os rótulos do menu.
          *
-         * @remarks Valores aceitos:
-         * - info
-         * - warning
-         * - danger
-         * - success
+         * @default 'Mais ações'
+         */
+        this.moreActionsHeadingLabel = 'Mais ações';
+        /**
+         * Texto do tooltip do botão de ações agrupadas da barra contextual.
+         * Quando vazio ou composto apenas por espaços, usa "Mais ações".
+         * Não altera o nome acessível do botão nem os rótulos do menu.
          *
-         * @default info
+         * @default 'Mais ações'
          */
-        this.tooltipState = TABLE_TOOLTIP_STATE.INFO;
+        this.moreActionsContextualLabel = 'Mais ações';
         /**
-         * Indica que as linhas estão sendo atualizadas pelo consumidor.
-         * O componente mantém o conteúdo anterior, aplica `aria-busy="true"` e
-         * exibe o slot `loading` sobre os dados; transporte, erro e substituição das
-         * linhas ficam sob responsabilidade da aplicação.
-         * A prop pode ser alterada diretamente ou pelos métodos `startLoading()` e
-         * `stopLoading()`.
+         * Limite padrão de ações exibidas em cada célula.
+         *
+         * @default 4
+         */
+        this.cellActionsLimit = 4;
+        /**
+         * Habilita a coluna de seleção de linhas.
+         *
          * @default false
          */
-        this.loading = false;
-        this.headers = [];
-        this.rows = [];
-        this.cells = [];
-        this.rowCells = new Map();
-        this.columnIndexes = new Map();
-        this.structureReady = false;
-        this.structureRefreshFrame = null;
-        this.handleColumnWidthEvent = () => {
-            this.scheduleStructureRefresh();
-        };
-        this.handleAlignmentEvent = (event) => {
-            if (!this.structureReady) {
-                this.scheduleStructureRefresh();
-                return;
+        this.hasRowSelection = false;
+        /**
+         * Habilita a coluna de expansão de linhas.
+         *
+         * @default false
+         */
+        this.hasRowExpansion = false;
+        /**
+         * Disponibiliza a interface de busca, sem filtrar ou destacar o conteúdo.
+         * A aplicação recebe `brTableSearch` e atualiza os dados local ou remotamente.
+         *
+         * @default false
+         */
+        this.hasSearch = false;
+        /**
+         * Habilita a paginação da tabela, renderizando `br-table-footer` internamente.
+         *
+         * @remarks A paginação define o subconjunto lógico disponível para a lista
+         * virtual. `pageSize` conta linhas independentes ou grupos completos, e
+         * `visibleRows` controla quantas delas cabem simultaneamente na viewport.
+         * Quando os dados completos ainda não estão disponíveis localmente
+         * (paginação por API), informe `totalItems` e forneça o subconjunto
+         * correspondente após `brTablePageChange`.
+         * @default false
+         */
+        this.hasPagination = false;
+        /**
+         * Página atual exibida pela paginação (1-indexada).
+         *
+         * @remarks Atualizada internamente quando `TableDataStore` já cobre a
+         * página solicitada. Utilize como valor inicial ou para navegar
+         * programaticamente para outra página.
+         * @default 1
+         */
+        this.currentPage = 1;
+        /**
+         * Opções disponíveis de itens por página no seletor da paginação.
+         *
+         * @default [10, 20, 30]
+         */
+        this.pageSizeOptions = [10, 20, 30];
+        /**
+         * Define se a tabela aceita uma única coluna ordenada ou múltiplas colunas.
+         * No modo `multi`, a prioridade é sempre a ordem visual da esquerda para a direita.
+         *
+         * @default single
+         */
+        this.sortMode = TABLE_SORT_MODE.SINGLE;
+        /**
+         * Define se a tabela ordena as linhas localmente ou deixa a aplicação aplicar
+         * a ordenação solicitada. Em `manual`, a tabela mantém os indicadores e emite
+         * `brTableSortChange`, mas não reordena as linhas; use `setData()` para fornecer
+         * os resultados customizados ou remotos. Valores não reconhecidos usam a
+         * estratégia local.
+         *
+         * @default local
+         */
+        this.sortStrategy = TABLE_SORT_STRATEGY.LOCAL;
+        /**
+         * Quantidade de linhas de dados visíveis simultaneamente na viewport.
+         *
+         * @remarks Não limita o conjunto de dados nem realiza paginação. A altura da
+         * região de scroll é derivada desta quantidade e da densidade atual. Mesmo
+         * com `hasPagination` habilitado, esta propriedade continua definindo
+         * apenas a capacidade visual da viewport; `pageSize` define o tamanho lógico
+         * da página.
+         * @default 10
+         */
+        this.visibleRows = 10;
+        /** Altura adicional estimada para conteúdo expandido ainda não medido. */
+        this.virtualExpandedContentHeight = 240;
+        /**
+         * Estratégia padrão para conteúdos que excedem a célula.
+         *
+         * @default wrap
+         */
+        this.overflow = TABLE_OVERFLOW.WRAP;
+        /**
+         * Estado visual padrão dos tooltips.
+         *
+         * @default info
+         */
+        this.tooltipState = TABLE_TOOLTIP_STATE.INFO;
+        this.selectedRowsCount = 0;
+        this.measuredCollapsedRowHeight = null;
+        this.measuredHeaderHeight = null;
+        this.hasGlobalActionsContent = false;
+        this.hasContextualActionsContent = false;
+        this.hasScrollableContent = false;
+        this.generatedHeaderPrefix = Helpers.generateUniqueId();
+        this.dataStore = new TableDataStore();
+        this.isRenderingData = false;
+        this.selfMutationDepth = 0;
+        this.viewportMeasureFrame = null;
+        this.sorting = [];
+        this.openDropdowns = new Set();
+        this.headerHeights = new Map();
+        this.handleViewportScroll = () => {
+            for (const dropdown of this.openDropdowns) {
+                if (dropdown.isConnected)
+                    void dropdown.close();
             }
-            this.updateAlignmentForTarget(event.target);
+            this.openDropdowns.clear();
         };
-        this.handleOverflowEvent = (event) => {
-            if (!this.structureReady) {
-                this.scheduleStructureRefresh();
-                return;
+        this.handleFooterPageChange = (event) => {
+            if (this.dataStore.getItemCount() >= this.resolvePaginationTotalItems()) {
+                this.currentPage = event.detail.page;
             }
-            this.updateOverflowForTarget(event.target);
+            this.brTablePageChange.emit(event.detail);
+        };
+        this.handleFooterPerPageChange = (event) => {
+            this.applyFooterPerPageChange(event.detail.perPage);
         };
-        this.generatedHeaderPrefix = generateUniqueId();
         /**
-         * Recalcula estrutura, tokens e metadados de acessibilidade quando há mudança de slots.
+         * Ressincroniza todas as estruturas derivadas após uma mudança no conteúdo.
+         * A ordem preserva expansão antes de seleção e ambas antes das colunas de dados.
          */
         this.handleStructureChange = () => {
-            this.scheduleStructureRefresh();
+            this.syncBarActionsContent();
+            this.runWithoutSelfMutations(() => {
+                this.syncSelectionStructure();
+                this.syncExpansionStructure();
+                this.syncRowHoverState();
+                this.annotateBoundaries();
+                this.updateColumnWidths();
+                this.updateAllCellAlignments();
+                this.updateAllCellOverflow();
+                this.updateActionDensities();
+                this.applyAriaMetadata();
+            });
+            this.updateSelectionCount();
+            for (const entry of this.headerHeights.values())
+                entry.refresh();
+            this.updateHeaderHeight();
+            this.virtualList.sync();
         };
     }
-    get effectiveDividerStyle() {
-        return resolveAllowedPropValue(this.el, 'dividerStyle', this.dividerStyle, ['solid', 'dashed'], 'solid');
-    }
-    get effectiveHorizontalAlignment() {
-        return resolveAllowedPropValue(this.el, 'horizontalAlignment', this.horizontalAlignment, ['start', 'center', 'end'], undefined, { allowUndefined: true });
+    handleHeaderHeight(event) {
+        const { host, height } = event.detail;
+        if (host.closest('br-table') !== this.el || !Number.isFinite(height) || height < 0)
+            return;
+        this.headerHeights.set(host, event.detail);
+        this.updateHeaderHeight();
     }
-    get effectiveVerticalAlignment() {
-        return resolveAllowedPropValue(this.el, 'verticalAlignment', this.verticalAlignment, ['start', 'center', 'end'], undefined, { allowUndefined: true });
+    updateHeaderHeight() {
+        for (const host of this.headerHeights.keys()) {
+            if (host.closest('br-table') !== this.el)
+                this.headerHeights.delete(host);
+        }
+        const multilevelHeader = this.el.querySelector('br-table-header[data-multilevel]');
+        const height = multilevelHeader?.getBoundingClientRect().height ??
+            Math.max(0, ...Array.from(this.headerHeights.values(), (entry) => entry.height));
+        if (height === this.measuredHeaderHeight)
+            return;
+        this.measuredHeaderHeight = height;
+        this.virtualList?.refreshViewport();
     }
-    get effectiveOverflow() {
-        return resolveAllowedPropValue(this.el, 'overflow', this.overflow, ['truncate', 'wrap'], TABLE_OVERFLOW.WRAP);
+    handleDropdownOpenChange(event) {
+        const dropdown = event.composedPath()[0];
+        if (!(dropdown instanceof HTMLElement) || dropdown.localName !== 'br-dropdown')
+            return;
+        if (findComposedOwner(dropdown, 'br-table') !== this.el)
+            return;
+        const menu = dropdown;
+        if (event.detail.open)
+            this.openDropdowns.add(menu);
+        else
+            this.openDropdowns.delete(menu);
     }
-    get effectiveTooltipState() {
-        return resolveAllowedPropValue(this.el, 'tooltipState', this.tooltipState, ['info', 'warning', 'danger', 'success'], TABLE_TOOLTIP_STATE.INFO);
+    handleCellFocusRegistration(event) {
+        if (event.detail.host.closest('br-table') !== this.el)
+            return;
+        this.keyboard.register(event.detail);
     }
-    get effectiveTooltipMode() {
-        return resolveAllowedPropValue(this.el, 'tooltipMode', this.tooltipMode, [TABLE_TOOLTIP_MODE.INHERIT, TABLE_TOOLTIP_MODE.ENABLED, TABLE_TOOLTIP_MODE.DISABLED], undefined, { allowUndefined: true });
+    handleGridFocusIn(event) {
+        this.keyboard.focusIn(event);
     }
-    /**
-     * Reaplica a largura das colunas quando alterada.
-     */
-    handleTableColumnWidthChange() {
-        this.updateColumnWidths();
+    handleGridFocusOut(event) {
+        this.keyboard.focusOut(event);
     }
-    /**
-     * Reaplica o token de densidade quando alterado.
-     */
-    handleDensityChange() {
-        this.applyDensity();
+    handleGridKeyDown(event) {
+        this.keyboard.keyDown(event);
     }
-    /**
-     * Atualiza os tokens de divisor quando qualquer propriedade relacionada é alterada.
-     */
-    handleDividerChange() {
-        this.applyDividers();
+    applyFooterPerPageChange(perPage) {
+        const nextPageSize = Math.max(1, Math.floor(perPage));
+        if (nextPageSize === this.resolvePageSize())
+            return;
+        this.pageSize = nextPageSize;
+        this.currentPage = 1;
+        this.brTablePageSizeChange.emit({ pageSize: nextPageSize });
     }
     /**
-     * Atualiza os tokens de alinhamento quando alterados.
+     * Inicializa os controllers antes da primeira renderização completa.
      */
-    handleAlignmentChange() {
-        this.updateAllCellAlignments();
+    componentWillLoad() {
+        this.keyboard = new TableKeyboardController(this.el, () => this.getKeyboardRows(), (cell) => {
+            const row = cell.closest('br-table-row');
+            const index = row === null ? -1 : this.getVirtualRows().indexOf(row);
+            this.virtualList.revealRow(index >= 0 ? index : null);
+        }, () => this.resolveConfiguredVisibleRows());
+        this.selection = new TableSelectionController({
+            host: this.el,
+            idPrefix: this.generatedHeaderPrefix,
+            getRows: () => this.dataStore.getRows(),
+            onChange: (detail) => {
+                this.selectedRowsCount = detail.selectedCount;
+                this.brTableSelectionChange.emit(detail);
+            },
+        });
+        this.expansion = new TableExpansionController({
+            host: this.el,
+            getRows: () => this.dataStore.getRows(),
+            onChange: (detail) => {
+                const virtualIndex = this.getVirtualRows().indexOf(detail.row);
+                if (virtualIndex >= 0)
+                    this.virtualList?.invalidateRow(virtualIndex);
+                this.brTableRowExpansionChange.emit(detail);
+            },
+        });
+        this.virtualList = new TableVirtualListController({
+            getRows: () => this.getVirtualRows(),
+            getViewport: () => this.el.shadowRoot?.querySelector('.br-table-scroll') ?? null,
+            getStickyHeaderHeight: () => this.measuredHeaderHeight ?? 0,
+            renderRange: (range) => {
+                this.isRenderingData = true;
+                const offset = this.resolveVirtualRangeOffset();
+                this.runWithoutSelfMutations(() => this.dataStore.renderRange({
+                    ...range,
+                    start: range.start + offset,
+                    end: range.end + offset,
+                }));
+                this.isRenderingData = false;
+            },
+            visibleRows: () => this.resolveConfiguredVisibleRows(),
+            estimatedRowHeight: () => this.resolveVirtualRowHeight(),
+            estimatedExpandedHeight: () => this.virtualExpandedContentHeight,
+            onAfterRender: () => queueMicrotask(() => this.syncRenderedRange()),
+        });
     }
     /**
-     * Atualiza os tokens de overflow quando a propriedade é alterada.
+     * Retoma a coordenação de densidade quando a tabela é reinserida.
      */
-    handleOverflowChange() {
-        this.updateAllCellOverflow();
-    }
-    handleTooltipPropsChange() {
-        this.validateTooltipProps();
-    }
-    validateTooltipProps() {
-        void this.effectiveTooltipState;
-        void this.effectiveTooltipMode;
+    connectedCallback() {
+        if (this.structureObserver === undefined)
+            return;
+        this.observeStructureChanges();
+        this.updateActionDensities();
+        this.syncScrollShadows();
     }
     /**
-     * Ciclo de vida do componente que é chamado após o componente ser carregado no DOM.
-     * Inicializa os tokens visuais após a montagem do componente.
+     * Monta a estrutura derivada e registra os listeners de coordenação.
      */
     componentDidLoad() {
-        this.refreshStructure();
+        this.captureAndRenderInitialData();
+        this.syncHeaderSortState();
+        this.syncSelectionStructure();
+        this.syncExpansionStructure();
+        this.syncRowHoverState();
+        this.virtualList.connect();
+        this.virtualList.reset(false);
+        this.syncBarActionsContent();
+        this.annotateBoundaries();
+        this.registerColumnWidthListener();
+        this.registerAlignmentListener();
+        this.registerOverflowListener();
         this.applyDensity();
+        this.updateActionDensities();
+        this.applyExpandedContentHeight();
         this.applyDividers();
-        this.validateTooltipProps();
-        // garante cálculo inicial após filhos renderizarem
+        this.observeStructureChanges();
         queueMicrotask(() => {
             this.updateColumnWidths();
             this.updateAllCellAlignments();
             this.updateAllCellOverflow();
             this.applyAriaMetadata();
+            this.updateSelectionCount();
+            this.scheduleViewportHeightMeasurement();
+            this.updateScrollableContentState();
         });
     }
-    connectedCallback() {
-        this.el.addEventListener('brColumnWidthChange', this.handleColumnWidthEvent);
-        this.el.addEventListener('brAlignmentChange', this.handleAlignmentEvent);
-        this.el.addEventListener('brOverflowChange', this.handleOverflowEvent);
-    }
-    disconnectedCallback() {
-        this.el.removeEventListener('brColumnWidthChange', this.handleColumnWidthEvent);
-        this.el.removeEventListener('brAlignmentChange', this.handleAlignmentEvent);
-        this.el.removeEventListener('brOverflowChange', this.handleOverflowEvent);
-        if (this.structureRefreshFrame !== null) {
-            cancelAnimationFrame(this.structureRefreshFrame);
-            this.structureRefreshFrame = null;
+    syncScrollShadows() {
+        const viewport = this.el.shadowRoot?.querySelector('.br-table-scroll');
+        const content = this.el.shadowRoot?.querySelector('.br-table-content');
+        if (!this.scrollShadows && viewport && content && viewport.parentElement) {
+            this.scrollShadows = new TableScrollShadows(viewport, content, viewport.parentElement);
         }
+        this.scrollShadows?.update();
     }
-    /** Inicia o estado de carregamento da tabela. */
-    async startLoading() {
-        this.loading = true;
-    }
-    /** Interrompe o estado de carregamento da tabela. */
-    async stopLoading() {
-        this.loading = false;
+    componentDidRender() {
+        this.syncScrollShadows();
+        this.updateScrollableContentState();
     }
     /**
-     * Marca a última linha e a última coluna para permitir estilização condicional.
+     * Libera o observer quando a tabela é removida do documento.
      */
-    refreshStructure() {
-        this.headers = Array.from(this.el.querySelectorAll('br-table-header-cell')).filter((element) => findComposedOwner(element, 'br-table') === this.el);
-        this.rows = Array.from(this.el.querySelectorAll('br-table-row')).filter((element) => findComposedOwner(element, 'br-table') === this.el);
-        this.cells = [
-            ...this.headers,
-            ...Array.from(this.el.querySelectorAll('br-table-cell')).filter((element) => findComposedOwner(element, 'br-table') === this.el),
-        ];
-        this.rowCells.clear();
-        this.columnIndexes.clear();
-        const columnCount = this.headers.length;
-        this.headers.forEach((column, columnIndex) => {
-            if (!(column instanceof HTMLElement))
-                return;
-            const isLastColumn = columnIndex === columnCount - 1;
-            column.toggleAttribute('data-last-column', isLastColumn);
-            this.columnIndexes.set(column, columnIndex);
-        });
-        this.rows.forEach((row, rowIndex) => {
-            const isLastRow = rowIndex === this.rows.length - 1;
-            const rowCells = Array.from(row.querySelectorAll('br-table-cell, br-table-header-cell')).filter((cell) => findComposedOwner(cell, 'br-table-row') === row);
-            this.rowCells.set(row, rowCells);
-            rowCells.forEach((cell, columnIndex) => {
-                if (!(cell instanceof HTMLElement))
-                    return;
-                const isLastColumn = columnIndex === columnCount - 1;
-                cell.toggleAttribute('data-last-row', isLastRow);
-                cell.toggleAttribute('data-last-column', isLastColumn);
-                this.columnIndexes.set(cell, columnIndex);
-            });
-        });
-        this.structureReady = true;
-    }
-    scheduleStructureRefresh() {
-        if (this.structureRefreshFrame !== null)
-            return;
-        this.structureRefreshFrame = requestAnimationFrame(() => {
-            this.structureRefreshFrame = null;
-            this.refreshStructure();
-            this.updateColumnWidths();
-            this.updateAllCellAlignments();
-            this.updateAllCellOverflow();
-            this.applyAriaMetadata();
-        });
+    disconnectedCallback() {
+        this.scrollShadows?.disconnect();
+        this.scrollShadows = undefined;
+        this.openDropdowns.clear();
+        this.keyboard?.disconnect();
+        this.structureObserver?.disconnect();
+        this.virtualList?.disconnect();
+        this.headerHeights.clear();
+        if (this.viewportMeasureFrame !== null)
+            cancelAnimationFrame(this.viewportMeasureFrame);
+        this.viewportMeasureFrame = null;
     }
     /**
-     * Atualiza a largura das colunas com base nos cabeçalhos.
-     * @returns void
+     * Recalcula o grid quando a largura padrão muda.
      */
-    updateColumnWidths() {
-        const headers = this.getHeaderCells();
-        if (headers.length === 0)
-            return;
-        const template = this.buildGridTemplate(headers);
-        this.applyGridTemplate(template);
+    handleTableColumnWidthChange() {
+        this.updateColumnWidths();
     }
     /**
-     * Constrói o template de grid para a tabela com base nos cabeçalhos.
-     * @param headers Os elementos de cabeçalho da tabela.
-     * @returns Uma string representando o template de grid CSS.
+     * Reaplica os tokens e recalcula a virtualização quando a densidade muda.
      */
-    buildGridTemplate(headers) {
-        const tableWidth = this.resolveTableColumnWidth();
-        const columnWidths = headers.map((header) => this.resolveColumnWidth(header, tableWidth));
-        return columnWidths.join(' ');
+    handleDensityChange() {
+        this.invalidateViewportMetrics();
+        this.applyDensity();
+        this.updateActionDensities();
+        this.virtualList?.reset(false);
+        this.scheduleViewportHeightMeasurement();
     }
     /**
-     * Resolve a largura de uma coluna específica com base no cabeçalho e na largura global da tabela.
+     * Recalcula a viewport e a janela virtual quando a quantidade visível muda.
      */
-    resolveTableColumnWidth() {
-        return this.resolveWidthToken(this.columnWidth, COLUMN_WIDTH_MAP[COLUMN_WIDTH_SEMANTICS.FILL], this.el);
+    handleVisibleRowsChange() {
+        this.syncVisibleRange(false);
     }
-    /**
-     * Resolve a largura de uma coluna específica com base no cabeçalho e na largura global da tabela.
-     * @param header O elemento de cabeçalho da coluna.
-     * @param fallback A largura de fallback a ser usada caso o cabeçalho não defina uma largura.
-     * @returns A largura resolvida da coluna.
-     */
-    resolveColumnWidth(header, fallback) {
-        const headerWidth = header.getAttribute('column-width');
-        return this.resolveWidthToken(headerWidth, fallback, header);
+    /** Reinicia a janela virtual quando a paginação é alternada. */
+    handleHasPaginationChange() {
+        this.virtualList.reset(true);
+        this.scheduleViewportHeightMeasurement();
     }
-    /**
-     * Aplica o template de grid à tabela definindo a propriedade CSS customizada correspondente.
-     * @param raw O template de grid bruto a ser aplicado.
-     * @param fallback O template de grid de fallback a ser usado caso o valor bruto seja inválido.
-     * @return void
-     */
-    resolveWidthToken(raw, fallback, host) {
-        if (raw !== undefined && raw !== '') {
-            const isValid = raw in COLUMN_WIDTH_MAP || positivePxValidator(raw) || positiveFrValidator(raw);
-            if (!isValid) {
-                reportInvalidPropValue(host, 'columnWidth', raw, 'Use `fill`, `content`, uma largura positiva em `px` ou uma fração positiva em `fr`.', `Aplicando fallback ${fallback}.`);
-            }
-            else {
-                clearInvalidPropWarning(host, 'columnWidth');
-            }
-        }
-        return resolveTokenValue(raw ?? undefined, {
-            fallback,
-            semanticMap: COLUMN_WIDTH_MAP,
-            validators: [positivePxValidator, positiveFrValidator],
-        });
+    /** Reinicia a janela virtual no subconjunto correspondente à página atual. */
+    handleCurrentPageChange() {
+        if (this.hasPagination)
+            this.virtualList.reset(true);
     }
-    /**
-     * Aplica o template de grid à tabela definindo a propriedade CSS customizada correspondente.
-     * @param template O template de grid a ser aplicado.
-     */
-    applyGridTemplate(template) {
-        this.el.style.setProperty(TABLE_TOKENS.COLUMN_WIDTHS, template);
+    /** Reinicia a página e a janela virtual quando o tamanho lógico da página muda. */
+    handlePageSizeChange() {
+        if (!this.hasPagination)
+            return;
+        this.currentPage = 1;
+        this.virtualList.reset(true);
+        this.scheduleViewportHeightMeasurement();
     }
-    /**
-     * Atualiza o alinhamento de todas as células da tabela com base nos tokens de alinhamento.
-     */
-    updateAllCellAlignments() {
-        const cells = this.getAllCells();
-        cells.forEach((cell) => {
-            this.updateAlignmentForCell(cell);
-        });
+    /** Normaliza a quantidade pública de linhas visíveis para o intervalo suportado. */
+    resolveConfiguredVisibleRows() {
+        if (!Number.isFinite(this.visibleRows))
+            return DEFAULT_VISIBLE_ROWS;
+        return Math.min(MAX_VISIBLE_ROWS, Math.max(MIN_VISIBLE_ROWS, Math.floor(this.visibleRows)));
     }
-    /**
-     * Atualiza o alinhamento de uma célula específica com base nos tokens de alinhamento.
-     * @param cell A célula a ser atualizada.
-     */
-    updateAlignmentForCell(cell) {
-        const horizontal = this.resolveHorizontalAlignmentForCell(cell);
-        const vertical = this.resolveVerticalAlignmentForCell(cell);
-        cell.style.setProperty(TABLE_TOKENS.HORIZONTAL_ALIGNMENT, horizontal);
-        cell.style.setProperty(TABLE_TOKENS.VERTICAL_ALIGNMENT, vertical);
+    /** Quantidade total de itens usada pela paginação, priorizando o valor explícito. */
+    resolvePaginationTotalItems() {
+        return this.totalItems ?? this.dataStore.getItemCount();
+    }
+    /** Resolve o tamanho lógico da página sem acoplá-lo à altura da viewport. */
+    resolvePageSize() {
+        const rawPageSize = this.pageSize ?? this.resolveConfiguredVisibleRows();
+        if (!Number.isFinite(rawPageSize))
+            return this.resolveConfiguredVisibleRows();
+        return Math.max(1, Math.floor(rawPageSize));
+    }
+    /** Retorna a página normalizada para o total e o tamanho atuais. */
+    resolveCurrentPage() {
+        if (!this.hasPagination)
+            return 1;
+        const totalPages = Math.max(1, Math.ceil(this.resolvePaginationTotalItems() / this.resolvePageSize()));
+        return Math.min(Math.max(1, Math.floor(this.currentPage || 1)), totalPages);
     }
     /**
-     * Resolve o alinhamento horizontal de uma célula específica com base nos tokens de alinhamento.
-     * @param cell A célula a ser avaliada.
-     * @returns O valor do token de alinhamento horizontal resolvido.
+     * Retorna o dataset lógico consumido pela lista virtual. Com paginação local,
+     * corresponde apenas ao slice da página; com paginação remota, corresponde
+     * ao subconjunto atualmente fornecido pelo consumidor.
      */
-    resolveHorizontalAlignmentForCell(cell) {
-        // Cell
-        const cellValue = cell.getAttribute('horizontal-alignment');
-        if (cellValue !== null)
-            return this.resolveAlignmentToken(cellValue);
-        // Row
-        const row = findComposedOwner(cell, 'br-table-row');
-        const rowValue = row?.getAttribute('horizontal-alignment');
-        if (rowValue !== null)
-            return this.resolveAlignmentToken(rowValue);
-        // Column (header)
-        const columnValue = this.getColumnAlignment(cell, 'horizontal-alignment');
-        if (columnValue !== null)
-            return this.resolveAlignmentToken(columnValue);
-        // Table
-        if (this.effectiveHorizontalAlignment !== undefined)
-            return this.resolveAlignmentToken(this.effectiveHorizontalAlignment);
-        // Fallback
-        return TABLE_ALIGNMENT_MAP[TABLE_ALIGNMENT.START];
+    getVirtualRows() {
+        const rows = this.dataStore.getRowsView();
+        if (!this.hasPagination)
+            return rows;
+        const totalItems = this.resolvePaginationTotalItems();
+        if (this.dataStore.getItemCount() < totalItems)
+            return rows;
+        const pageSize = this.resolvePageSize();
+        const range = this.dataStore.getPageRange((this.resolveCurrentPage() - 1) * pageSize, pageSize);
+        return this.dataStore.getRowsView(range.start, range.end);
     }
     /**
-     * Resolve o alinhamento vertical de uma célula específica com base nos tokens de alinhamento.
-     * @param cell A célula a ser avaliada.
-     * @returns O valor do token de alinhamento vertical resolvido.
+     * Converte os índices locais da janela virtual para índices do dataset
+     * completo quando a paginação é realizada localmente.
+     *
+     * Na paginação remota, o data store contém somente a página fornecida pelo
+     * consumidor, portanto não há offset físico a aplicar ao renderRange.
      */
-    resolveVerticalAlignmentForCell(cell) {
-        const cellValue = cell.getAttribute('vertical-alignment');
-        if (cellValue !== null)
-            return this.resolveAlignmentToken(cellValue);
-        const row = findComposedOwner(cell, 'br-table-row');
-        const rowValue = row?.getAttribute('vertical-alignment');
-        if (rowValue !== null)
-            return this.resolveAlignmentToken(rowValue);
-        const columnValue = this.getColumnAlignment(cell, 'vertical-alignment');
-        if (columnValue !== null)
-            return this.resolveAlignmentToken(columnValue);
-        if (this.effectiveVerticalAlignment !== undefined)
-            return this.resolveAlignmentToken(this.effectiveVerticalAlignment);
-        return TABLE_ALIGNMENT_MAP[TABLE_ALIGNMENT.START];
+    resolveVirtualRangeOffset() {
+        if (!this.hasPagination)
+            return 0;
+        const totalRows = this.dataStore.getItemCount();
+        const totalItems = this.resolvePaginationTotalItems();
+        if (totalRows < totalItems)
+            return 0;
+        return this.dataStore.getPageRange((this.resolveCurrentPage() - 1) * this.resolvePageSize(), this.resolvePageSize())
+            .start;
+    }
+    /** Atualiza a janela virtual; a paginação apenas altera seu dataset de entrada. */
+    syncVisibleRange(resetScroll) {
+        this.virtualList.reset(resetScroll);
     }
     /**
-     * Resolve um valor de token de alinhamento com base no valor bruto e no mapeamento semântico definido.
-     * @param value O valor bruto do token de alinhamento a ser resolvido.
-     * @returns O valor do token de alinhamento resolvido, ou o valor de fallback se o valor bruto for inválido.
+     * Resolve a altura-base estimada da linha a partir da densidade atual.
+     *
+     * @remarks A célula utiliza a densidade como padding vertical. A estimativa
+     * soma duas vezes esse padding a uma altura de conteúdo de uma linha (24px).
+     * Após a materialização, a lista virtual substitui a estimativa pela altura
+     * efetivamente medida.
      */
-    resolveAlignmentToken(value) {
-        return resolveTokenValue(value ?? undefined, {
-            fallback: TABLE_ALIGNMENT_MAP[TABLE_ALIGNMENT.START],
-            semanticMap: TABLE_ALIGNMENT_MAP,
+    resolveVirtualRowHeight() {
+        const density = resolveTokenValue(this.density, {
+            fallback: TABLE_DENSITY_MAP[TABLE_DENSITY.MEDIUM],
+            semanticMap: TABLE_DENSITY_MAP,
         });
+        const verticalPadding = Number.parseFloat(density);
+        return 24 + verticalPadding * 2;
     }
     /**
-     * Retorna o valor do atributo de alinhamento de uma coluna específica.
-     * @param cell A célula para a qual o alinhamento da coluna deve ser obtido.
-     * @param attribute O atributo de alinhamento a ser obtido ('horizontal-alignment' ou 'vertical-alignment').
-     * @returns O valor do atributo de alinhamento da coluna, ou null se não estiver definido.
+     * Define a altura da região rolável pelo número de itens lógicos solicitado.
+     * Grupos contam como um item, mas reservam a altura de todas as suas linhas.
      */
-    getColumnAlignment(cell, attribute) {
-        const columnIndex = this.getColumnIndex(cell);
-        if (columnIndex === -1)
-            return null;
-        const headers = this.getHeaderCells();
-        const header = headers[columnIndex];
-        return header?.getAttribute(attribute) ?? null;
+    resolveScrollViewportHeight() {
+        const estimatedRowHeight = this.resolveVirtualRowHeight();
+        const rowHeight = Math.max(this.measuredCollapsedRowHeight ?? 0, estimatedRowHeight);
+        const headerHeight = Math.max(this.measuredHeaderHeight ?? 0, rowHeight);
+        const rows = this.getVirtualRows();
+        const configuredHeightRows = this.heightRows !== undefined && Number.isFinite(this.heightRows)
+            ? Math.max(1, Math.floor(this.heightRows))
+            : this.resolveConfiguredVisibleRows();
+        const logicalRows = Math.min(configuredHeightRows, this.dataStore.getItemCount());
+        const pageOffset = this.resolveVirtualRangeOffset();
+        const physicalRange = this.dataStore.getPageRange(pageOffset, logicalRows);
+        const physicalRows = rows.length === 0 ? 0 : Math.min(rows.length, physicalRange.end - pageOffset);
+        const dataRowsHeight = physicalRows * rowHeight;
+        return `${headerHeight + dataRowsHeight}px`;
     }
     /**
-     * Obtém o índice da coluna para uma célula específica, permitindo a associação entre células e seus respectivos cabeçalhos para herança de propriedades como alinhamento e largura.
-     * @param cell A célula para a qual o índice da coluna deve ser obtido.
-     * @returns O índice da coluna correspondente à célula, ou -1 se a célula não estiver dentro de uma linha válida.
+     * Reaplica os divisores após qualquer mudança relacionada.
      */
-    getColumnIndex(cell) {
-        return this.columnIndexes.get(cell) ?? -1;
+    handleDividerChange() {
+        this.applyDividers();
     }
     /**
-     * Constrói o template de grid para a tabela com base nos cabeçalhos.
-     * @return Array de larguras de coluna resolvidas.
+     * Recalcula os alinhamentos herdados de todas as células.
      */
-    getHeaderCells() {
-        return this.headers;
+    handleAlignmentChange() {
+        this.updateAllCellAlignments();
     }
     /**
-     * Obtém todas as células (tanto de corpo quanto de cabeçalho) da tabela, permitindo a aplicação de estilos e tokens de forma abrangente.
-     * @returns Um array contendo todas as células da tabela.
+     * Recalcula o overflow herdado de todas as células.
      */
-    getAllCells() {
-        return this.cells;
+    handleOverflowChange() {
+        this.updateAllCellOverflow();
+    }
+    handleVirtualExpandedContentHeightChange() {
+        this.applyExpandedContentHeight();
+        this.syncVisibleRange(false);
     }
     /**
-     * Aplica metadados ARIA para melhorar a navegação por leitores de tela.
+     * Sincroniza a estrutura quando a seleção é habilitada ou desabilitada.
      */
-    applyAriaMetadata() {
-        const rows = this.rows;
-        const headers = this.getHeaderCells();
-        this.el.setAttribute('aria-colcount', String(headers.length));
-        this.el.setAttribute('aria-rowcount', String(rows.length));
-        rows.forEach((row, rowIndex) => {
-            row.setAttribute('aria-rowindex', String(rowIndex + 1));
-        });
-        headers.forEach((header, headerIndex) => {
-            const colIndex = String(headerIndex + 1);
-            const headerId = header.id || `${this.generatedHeaderPrefix}-${headerIndex + 1}`;
-            header.id = headerId;
-            header.setAttribute('aria-colindex', colIndex);
-        });
-        const bodyCells = this.cells.filter((cell) => cell.tagName === 'BR-TABLE-CELL');
-        bodyCells.forEach((cell) => {
-            const columnIndex = this.getColumnIndex(cell);
-            if (columnIndex === -1)
-                return;
-            const colIndex = String(columnIndex + 1);
-            const header = headers[columnIndex];
-            cell.setAttribute('aria-colindex', colIndex);
-            if (header !== undefined && header.id !== '') {
-                cell.setAttribute('aria-labelledby', header.id);
-            }
-        });
+    handleRowSelectionChange() {
+        this.syncSelectionStructure();
+        this.handleStructureChange();
+    }
+    /** Sincroniza a elegibilidade visual de hover das linhas. */
+    handleRowHoverChange() {
+        this.syncRowHoverState();
     }
     /**
-     * Atualiza os tokens de overflow para todas as células da tabela, garantindo que as mudanças na propriedade de overflow sejam refletidas dinamicamente em todas as células, controlando o comportamento de overflow, text-overflow e white-space conforme definido no token.
+     * Sincroniza a estrutura quando a expansão é habilitada ou desabilitada.
      */
-    updateAllCellOverflow() {
-        this.getAllCells().forEach((cell) => {
-            this.updateOverflowForCell(cell);
-        });
+    handleRowExpansionChange() {
+        this.handleStructureChange();
     }
-    updateAlignmentForTarget(target) {
-        if (target === null || !this.el.contains(target))
-            return;
-        if (target.tagName === 'BR-TABLE-CELL' || target.tagName === 'BR-TABLE-HEADER-CELL') {
-            this.updateAlignmentForCell(target);
-            return;
+    /** Normaliza o estado ativo quando o consumidor alterna entre multi e single-sort. */
+    handleSortModeChange() {
+        if (this.sortMode === TABLE_SORT_MODE.SINGLE && this.sorting.length > 1) {
+            const firstCriterion = this.getSortingByColumnOrder()[0];
+            this.sorting = firstCriterion === undefined ? [] : [firstCriterion];
+            this.applySorting(false);
         }
-        if (target.tagName === 'BR-TABLE-ROW') {
-            this.rowCells.get(target)?.forEach((cell) => {
-                this.updateAlignmentForCell(cell);
-            });
+    }
+    /** Reaplica o estado atual quando a estratégia de ordenação muda. */
+    handleSortStrategyChange() {
+        if (this.dataStore.getColumns().length === 0)
             return;
-        }
-        this.updateAllCellAlignments();
+        this.applySorting(false);
     }
-    updateOverflowForTarget(target) {
-        if (target === null || !this.el.contains(target))
+    /** Consome solicitações emitidas pelo trigger de ordenação do cabeçalho. */
+    handleSortRequest(event) {
+        const header = event
+            .composedPath()
+            .find((node) => node instanceof HTMLElement &&
+            node.tagName.toLowerCase() === 'br-table-header-cell' &&
+            node.hasAttribute('sortable'));
+        if (header === undefined || header.closest('br-table') !== this.el)
             return;
-        if (target.tagName === 'BR-TABLE-CELL' || target.tagName === 'BR-TABLE-HEADER-CELL') {
-            this.updateOverflowForCell(target);
+        const columnIndex = this.dataStore.getColumns().indexOf(header);
+        if (columnIndex < 0)
             return;
-        }
-        if (target.tagName === 'BR-TABLE-ROW') {
-            this.rowCells.get(target)?.forEach((cell) => {
-                this.updateOverflowForCell(cell);
-            });
+        event.stopImmediatePropagation();
+        const nextSorting = this.resolveNextSorting(columnIndex);
+        const requestEvent = this.brTableSortRequest.emit({
+            mode: this.sortMode,
+            columnIndex,
+            currentSorting: this.getSortingByColumnOrder().map((criterion) => ({ ...criterion })),
+            nextSorting: nextSorting.map((criterion) => ({ ...criterion })),
+        });
+        if (requestEvent.defaultPrevented) {
             return;
         }
-        this.updateAllCellOverflow();
+        this.sorting = nextSorting;
+        this.applySorting(true);
     }
     /**
-     * Atualiza os tokens de overflow para uma célula específica, controlando o comportamento de overflow, text-overflow e white-space com base na resolução do token de overflow para a célula, que considera atributos específicos da célula, da linha, da coluna e da tabela para determinar o comportamento final de overflow a ser aplicado.
-     * @param cell A célula para a qual os tokens de overflow devem ser atualizados.
+     * Encaminha mudanças dos checkboxes ao controller de seleção.
      */
-    updateOverflowForCell(cell) {
-        const mode = this.resolveOverflowForCell(cell);
-        const config = TABLE_OVERFLOW_MAP[mode];
-        cell.style.setProperty(TABLE_TOKENS.CELL_OVERFLOW, config.overflow);
-        cell.style.setProperty(TABLE_TOKENS.CELL_TEXT_OVERFLOW, config.textOverflow);
-        cell.style.setProperty(TABLE_TOKENS.CELL_WHITE_SPACE, config.whiteSpace);
-        // O atributo 'applied-overflow' deve sempre aparecer
-        cell.setAttribute('data-applied-overflow', mode);
+    handleSelectionCheckboxChange(event) {
+        this.selection.handleCheckboxChange(event);
     }
     /**
-     * Resolve o token de overflow para uma célula específica, considerando a hierarquia de atributos (célula, linha, coluna, tabela) para determinar o comportamento de overflow final a ser aplicado à célula.
-     * @param cell A célula para a qual o token de overflow deve ser resolvido.
-     * @returns O valor do token de overflow resolvido para a célula, determinando o comportamento de overflow a ser aplicado.
+     * Consome ações internas de expansão e normaliza as demais ações.
      */
-    resolveOverflowForCell(cell) {
-        // Resolução hierárquica: célula > linha > coluna > tabela > fallback
-        let value = cell.getAttribute('overflow');
-        if (value === null) {
-            const row = findComposedOwner(cell, 'br-table-row');
-            value = row?.getAttribute('overflow') ?? null;
+    handleActionClick(event) {
+        if (event.target === this.el) {
+            return;
         }
-        if (value === null) {
-            value = this.getColumnAttribute(cell, 'overflow') ?? null;
+        if (this.expansion.handleActionClick(event)) {
+            event.stopImmediatePropagation();
+            event.stopPropagation();
+            return;
         }
-        if (value === null) {
-            value = this.effectiveOverflow;
+        event.stopImmediatePropagation();
+        event.stopPropagation();
+        if (event.detail.type !== 'row') {
+            this.brTableActionClick.emit(event.detail);
+            return;
         }
-        if (value === null) {
-            value = TABLE_OVERFLOW.WRAP;
+        this.brTableActionClick.emit({
+            ...event.detail,
+            rowIndex: this.resolveActionRowIndex(event),
+        });
+    }
+    /** Resolve o índice da linha associado à ação quando o contexto é `row`. */
+    resolveActionRowIndex(event) {
+        const row = event
+            .composedPath()
+            .find((node) => node instanceof HTMLElement && node.tagName.toLowerCase() === 'br-table-row');
+        if (row === undefined)
+            return undefined;
+        const rowIndex = this.getBodyRows().indexOf(row);
+        return rowIndex >= 0 ? rowIndex : undefined;
+    }
+    /** Inicia o estado visual de carregamento sem alterar os dados da tabela. */
+    async startLoading() {
+        this.loading = true;
+    }
+    /** Interrompe o estado visual de carregamento sem alterar os dados da tabela. */
+    async stopLoading() {
+        this.loading = false;
+    }
+    /**
+     * Substitui os dados lógicos da tabela e reconstrói seus subcomponentes.
+     *
+     * @remarks Esta é a mesma estrutura interna utilizada após a ingestão dos slots.
+     * @param data Colunas, linhas e ações que formarão a tabela.
+     * @example
+     * ```js
+     * const table = document.querySelector('br-table');
+     * await table.setData({
+     *   columns: [],
+     *   headerRows: [
+     *     [{ content: 'Unidade', rowSpan: 2 }, { content: 'Equipe', colSpan: 2 }],
+     *     [{ content: 'Nome', sortable: true }, { content: 'Cargo', sortable: true }],
+     *   ],
+     *   rows: [
+     *     { rowGroup: 'brasilia', cells: [
+     *       { content: 'Brasília', rowSpan: 2, rowHeader: true },
+     *       { content: 'Ana' }, { content: 'Analista' },
+     *     ] },
+     *     { rowGroup: 'brasilia', cells: [{ content: 'Carlos' }, { content: 'Técnico' }] },
+     *   ],
+     * });
+     * ```
+     */
+    async setData(data) {
+        this.invalidateViewportMetrics();
+        const previousSorting = this.sorting.map((criterion) => ({ ...criterion }));
+        this.isRenderingData = true;
+        this.dataStore.replace(data);
+        this.dataStore.mount(this.el);
+        this.isRenderingData = false;
+        await Promise.resolve();
+        this.sorting = this.resolvePreservedSorting(previousSorting);
+        if (this.sorting.length > 0) {
+            this.applySorting(false);
         }
-        return value === TABLE_OVERFLOW.TRUNCATE ? TABLE_OVERFLOW.TRUNCATE : TABLE_OVERFLOW.WRAP;
+        else {
+            this.syncHeaderSortState();
+            this.syncSelectionStructure();
+            this.syncExpansionStructure();
+            this.syncRowHoverState();
+            this.syncVisibleRange(true);
+            this.handleStructureChange();
+        }
+        this.scheduleViewportHeightMeasurement();
+    }
+    /** Preserva apenas critérios que continuam válidos no novo dataset. */
+    resolvePreservedSorting(previousSorting) {
+        const columns = this.dataStore.getColumns();
+        const validSorting = previousSorting.filter(({ columnIndex }) => {
+            if (columnIndex < 0 || columnIndex >= columns.length)
+                return false;
+            return columns[columnIndex]?.hasAttribute('sortable') === true;
+        });
+        if (this.sortMode !== TABLE_SORT_MODE.MULTI) {
+            const first = validSorting[0];
+            return first === undefined ? [] : [first];
+        }
+        return [...validSorting].sort((a, b) => a.columnIndex - b.columnIndex);
     }
     /**
-     * Obtém o valor de um atributo específico de uma coluna para uma célula, permitindo a herança de propriedades da coluna para as células associadas com base no cabeçalho correspondente.
-     * @param cell A célula para a qual o atributo da coluna deve ser obtido.
-     * @param attribute O atributo específico a ser obtido da coluna (por exemplo, 'horizontal-alignment' ou 'vertical-alignment').
-     * @returns O valor do atributo da coluna correspondente à célula, ou null se não estiver definido.
+     * Captura a entrada declarativa inicial e a materializa a partir do modelo virtual.
      */
-    getColumnAttribute(cell, attribute) {
-        const header = this.getHeaderForCell(cell);
-        return header?.getAttribute(attribute) ?? null;
+    captureAndRenderInitialData() {
+        this.invalidateViewportMetrics();
+        this.isRenderingData = true;
+        this.dataStore.capture(this.el);
+        this.dataStore.mount(this.el);
+        this.isRenderingData = false;
     }
     /**
-     * Obtém o elemento de cabeçalho correspondente a uma célula específica, permitindo a associação entre células e seus respectivos cabeçalhos para herança de propriedades como alinhamento e largura.
-     * @param cell A célula para a qual o cabeçalho correspondente deve ser obtido.
-     * @returns O elemento de cabeçalho correspondente à célula, ou null se não for encontrado.
+     * Retorna as linhas atualmente selecionadas.
+     *
+     * @returns Elementos `br-table-row` selecionados no corpo.
      */
-    getHeaderForCell(cell) {
-        const index = this.getColumnIndex(cell);
-        if (index === -1)
-            return null;
-        const headers = this.getHeaderCells();
-        return headers[index] ?? null;
+    async getSelectedRows() {
+        return this.selection.getSelectedRows();
     }
     /**
-     * Resolve e aplica o token de densidade.
+     * Seleciona todas as linhas elegíveis.
      */
-    applyDensity() {
-        const density = resolveDensity(this.el, this.density, { allowUndefined: true });
-        const resolved = resolveTokenValue(density ?? undefined, {
-            fallback: TABLE_DENSITY_MAP[TABLE_DENSITY.MEDIUM],
-            semanticMap: TABLE_DENSITY_MAP,
+    async selectAllRows() {
+        this.selection.selectAll(true);
+    }
+    /**
+     * Limpa a seleção de todas as linhas elegíveis.
+     */
+    async clearSelection() {
+        this.selection.clear();
+    }
+    /** Retorna o estado atual de ordenação aplicado na tabela. */
+    async getSorting() {
+        return this.getSortingByColumnOrder().map((criterion) => ({ ...criterion }));
+    }
+    /**
+     * Expande uma linha elegível do corpo.
+     *
+     * @param rowIndex Índice da linha, começando em zero.
+     */
+    async expandRow(rowIndex) {
+        const row = this.getBodyRows()[rowIndex];
+        if (row !== undefined)
+            this.expansion.setExpanded(row, true);
+    }
+    /**
+     * Recolhe uma linha do corpo.
+     *
+     * @param rowIndex Índice da linha, começando em zero.
+     */
+    async collapseRow(rowIndex) {
+        const row = this.getBodyRows()[rowIndex];
+        if (row !== undefined)
+            this.expansion.setExpanded(row, false);
+    }
+    /**
+     * Recolhe todas as linhas que estiverem expandidas.
+     */
+    async collapseAllRows() {
+        this.expansion.collapseAll();
+    }
+    /** Resolve o próximo estado de ordenação para a coluna acionada. */
+    resolveNextSorting(columnIndex) {
+        const current = this.sorting.find((criterion) => criterion.columnIndex === columnIndex);
+        const nextDirection = current === undefined
+            ? TABLE_SORT_DIRECTION.ASC
+            : current.direction === TABLE_SORT_DIRECTION.ASC
+                ? TABLE_SORT_DIRECTION.DESC
+                : undefined;
+        if (this.sortMode !== TABLE_SORT_MODE.MULTI) {
+            return nextDirection === undefined ? [] : [{ columnIndex, direction: nextDirection }];
+        }
+        const nextSorting = this.sorting.filter((criterion) => criterion.columnIndex !== columnIndex);
+        if (nextDirection !== undefined)
+            nextSorting.push({ columnIndex, direction: nextDirection });
+        return nextSorting.sort((a, b) => a.columnIndex - b.columnIndex);
+    }
+    /** Mantém a prioridade do multi-sort estritamente da esquerda para a direita. */
+    getSortingByColumnOrder() {
+        return [...this.sorting].sort((a, b) => a.columnIndex - b.columnIndex);
+    }
+    /**
+     * Aplica a ordenação ao dataset completo e só então reinicia a janela virtual.
+     */
+    applySorting(emitChange) {
+        this.sorting = this.getSortingByColumnOrder();
+        if (this.sortStrategy !== TABLE_SORT_STRATEGY.MANUAL) {
+            this.dataStore.sortRows(this.sorting);
+        }
+        this.syncHeaderSortState();
+        this.syncSelectionStructure();
+        this.syncExpansionStructure();
+        this.syncRowHoverState();
+        this.syncVisibleRange(true);
+        this.handleStructureChange();
+        if (emitChange) {
+            this.brTableSortChange.emit({
+                mode: this.sortMode,
+                sorting: this.sorting.map((criterion) => ({ ...criterion })),
+                rows: this.dataStore.getRows(),
+            });
+        }
+    }
+    /** Reflete o estado lógico nos cabeçalhos para atualizar ícones e semântica. */
+    syncHeaderSortState() {
+        this.dataStore.getColumns().forEach((header, columnIndex) => {
+            if (!header.hasAttribute('sortable')) {
+                header.removeAttribute('sort-direction');
+                header.removeAttribute('aria-sort');
+                return;
+            }
+            const criterion = this.sorting.find((entry) => entry.columnIndex === columnIndex);
+            if (criterion === undefined) {
+                header.removeAttribute('sort-direction');
+                header.setAttribute('aria-sort', 'none');
+                return;
+            }
+            header.setAttribute('sort-direction', criterion.direction);
+            header.setAttribute('aria-sort', criterion.direction === TABLE_SORT_DIRECTION.ASC ? 'ascending' : 'descending');
         });
-        this.el.style.setProperty(TABLE_TOKENS.DENSITY, resolved);
     }
     /**
-     * Resolve e aplica os tokens relacionados aos divisores
-     * (estilo e fatores de linha/coluna).
+     * Observa linhas adicionadas, removidas ou alteradas em tempo de execução.
      */
-    applyDividers() {
-        const style = resolveTokenValue(this.effectiveDividerStyle, {
-            fallback: TABLE_DIVIDER_STYLE_MAP[TABLE_DIVIDER_STYLE.SOLID],
-            semanticMap: TABLE_DIVIDER_STYLE_MAP,
+    observeStructureChanges() {
+        this.structureObserver?.disconnect();
+        this.structureObserver = new MutationObserver((mutations) => this.handleStructureMutations(mutations));
+        this.structureObserver.observe(this.el, {
+            attributeFilter: [
+                'row-group',
+                'row-span',
+                'col-span',
+                'selected',
+                'disabled',
+                'row-expansion',
+                'expanded',
+                'virtual-expanded-content-height',
+                'aria-label',
+                'aria-labelledby',
+                'style',
+                'class',
+            ],
+            attributes: true,
+            attributeOldValue: true,
+            childList: true,
+            subtree: true,
         });
-        const rowFactor = (this.rowDivider ?? this.hasRowDivider) ? '1' : '0';
-        const columnFactor = (this.columnDivider ?? this.hasColumnDivider) ? '1' : '0';
-        this.el.style.setProperty(TABLE_TOKENS.DIVIDER_STYLE, style);
-        this.el.style.setProperty(TABLE_TOKENS.ROW_DIVIDER_FACTOR, rowFactor);
-        this.el.style.setProperty(TABLE_TOKENS.COLUMN_DIVIDER_FACTOR, columnFactor);
     }
     /**
-     * Retorna o mapa de classes base do componente.
-     *
-     * @returns Um objeto representando as classes CSS a serem aplicadas ao elemento da tabela.
+     * Processa mutações externas: estrutura completa quando linhas mudam e somente
+     * densidade quando a herança CSS dentro da tabela pode ter mudado.
      */
-    getTableCssClassMap() {
-        return {
-            'br-table': true,
-        };
+    handleStructureMutations(mutations) {
+        if (mutations.some((mutation) => mutation.type === 'attributes' &&
+            mutation.target === this.el &&
+            (mutation.attributeName === 'aria-label' || mutation.attributeName === 'aria-labelledby'))) {
+            forceUpdate(this);
+        }
+        if (this.isRenderingData)
+            return;
+        if (mutations.some((mutation) => this.isRelevantStructureMutation(mutation))) {
+            this.handleStructureChange();
+        }
+        else if (mutations.some((mutation) => (mutation.type === 'childList' ||
+            mutation.attributeName === 'style' ||
+            (mutation.attributeName === 'class' && !isHydrationClassMutation(mutation))) &&
+            mutation.target instanceof HTMLElement &&
+            mutation.target.closest('br-table') === this.el)) {
+            this.updateActionDensities();
+        }
     }
     /**
-     * Renderiza a estrutura interna da tabela (header e body).
+     * Executa escritas internas sem realimentar o observer estrutural.
      *
-     * @returns JSX.Element representando o conteúdo da tabela, incluindo os slots para header e body.
+     * @remarks Mutações externas já pendentes são preservadas e reprocessadas;
+     * somente os registros gerados durante `write` são descartados, pois quem
+     * escreve já sincroniza o estado derivado.
+     */
+    runWithoutSelfMutations(write) {
+        const observer = this.structureObserver;
+        if (observer === undefined || this.selfMutationDepth > 0) {
+            write();
+            return;
+        }
+        const pending = observer.takeRecords();
+        this.selfMutationDepth++;
+        try {
+            write();
+        }
+        finally {
+            this.selfMutationDepth--;
+            observer.takeRecords();
+            if (pending.length > 0) {
+                queueMicrotask(() => {
+                    if (this.structureObserver === observer)
+                        this.handleStructureMutations(pending);
+                });
+            }
+        }
+    }
+    /**
+     * Determina se uma mutação exige sincronização estrutural da tabela.
+     */
+    isRelevantStructureMutation(mutation) {
+        if (mutation.type === 'attributes') {
+            return this.handleRowAttributeMutation(mutation);
+        }
+        const changedNodes = Array.from(mutation.addedNodes).concat(Array.from(mutation.removedNodes));
+        return this.hasRowChangeInNodes(changedNodes);
+    }
+    /**
+     * Processa mutações de atributo aplicadas às linhas.
+     */
+    handleGroupingMutation(mutation, target) {
+        const current = target.getAttribute(mutation.attributeName ?? '');
+        const unchanged = mutation.attributeName === 'row-group'
+            ? (mutation.oldValue?.trim() || '') === (current?.trim() || '')
+            : resolveTableSpan(mutation.oldValue) === resolveTableSpan(current);
+        if (unchanged)
+            return false;
+        this.dataStore.invalidateGroups();
+        this.virtualList?.reset(false);
+        forceUpdate(this);
+        return true;
+    }
+    handleRowAttributeMutation(mutation) {
+        const target = mutation.target;
+        if (['row-group', 'row-span', 'col-span'].includes(mutation.attributeName ?? '')) {
+            return this.handleGroupingMutation(mutation, target);
+        }
+        if (!target.matches('br-table-row'))
+            return false;
+        if (mutation.attributeName === 'style' || mutation.attributeName === 'class')
+            return false;
+        if (mutation.attributeName === 'row-expansion' &&
+            (mutation.oldValue ?? TABLE_ROW_EXPANSION.INHERIT) ===
+                (target.getAttribute('row-expansion') ?? TABLE_ROW_EXPANSION.INHERIT)) {
+            return false;
+        }
+        if (mutation.attributeName === 'expanded' || mutation.attributeName === 'virtual-expanded-content-height') {
+            const logicalIndex = Number(target.getAttribute('data-virtual-index')) - this.resolveVirtualRangeOffset();
+            if (Number.isInteger(logicalIndex) && this.getVirtualRows()[logicalIndex] === target) {
+                this.virtualList.invalidateRow(logicalIndex);
+            }
+            return mutation.attributeName === 'expanded';
+        }
+        return true;
+    }
+    /**
+     * Verifica se os nós alterados impactam linhas da tabela.
+     */
+    hasRowChangeInNodes(nodes) {
+        return nodes.some((node) => node instanceof HTMLElement && (node.matches('br-table-row') || node.querySelector('br-table-row') !== null));
+    }
+    /**
+     * Detecta a presença de ações atribuídas às barras.
+     */
+    syncBarActionsContent() {
+        const children = Array.from(this.el.children);
+        this.hasGlobalActionsContent = children.some((child) => child.getAttribute('slot') === 'global-actions');
+        this.hasContextualActionsContent = children.some((child) => child.getAttribute('slot') === 'contextual-actions');
+    }
+    /**
+     * Atualiza o estado reativo usado pela barra contextual.
+     */
+    updateSelectionCount() {
+        this.selectedRowsCount = this.selection.getSelectedRows().length;
+    }
+    /**
+     * Sincroniza células, checkboxes e estado da seleção.
+     */
+    syncSelectionStructure() {
+        this.selection.sync(this.hasRowSelection);
+        this.updateSelectionCount();
+    }
+    /**
+     * Sincroniza células, ações e estado da expansão.
+     */
+    syncExpansionStructure() {
+        this.expansion.sync(this.hasRowExpansion);
+    }
+    /** Aplica às linhas a marca consumida pelo estilo de hover das células. */
+    syncRowHoverState() {
+        this.dataStore.getRows().forEach((row) => {
+            row.toggleAttribute('data-row-hover-enabled', this.hasRowHover);
+        });
+    }
+    /**
+     * Retorna somente as linhas pertencentes ao corpo da tabela.
      */
-    renderContent() {
-        return (h("div", { class: { 'br-table-content': true, loading: this.loading }, part: "content" }, h("slot", { name: "header", onSlotchange: this.handleStructureChange }), h("slot", { name: "body", onSlotchange: this.handleStructureChange })));
+    getBodyRows() {
+        return this.dataStore.getRows();
+    }
+    /** Atualiza somente os elementos atualmente materializados pela lista virtual. */
+    syncRenderedRange() {
+        this.runWithoutSelfMutations(() => {
+            this.annotateBoundaries();
+            this.updateAllCellAlignments();
+            this.updateAllCellOverflow();
+            this.updateActionDensities();
+            this.applyAriaMetadata();
+        });
+        this.updateScrollableContentState();
+    }
+    updateActionDensities() {
+        const densities = this.getAllCells().map((cell) => ({
+            cell,
+            density: resolveTableDensityFromElement(cell),
+        }));
+        densities.forEach(({ cell, density }) => {
+            if (cell.getAttribute('action-density') !== density)
+                cell.setAttribute('action-density', density);
+            cell.querySelectorAll('br-table-action').forEach((action) => {
+                if (action.getAttribute('density') !== density)
+                    action.setAttribute('density', density);
+            });
+        });
     }
+    updateScrollableContentState() {
+        const viewport = this.el.shadowRoot?.querySelector('.br-table-scroll');
+        const nextHasScrollableContent = viewport !== null &&
+            viewport !== undefined &&
+            (viewport.scrollHeight > viewport.clientHeight + 1 || viewport.scrollWidth > viewport.clientWidth + 1);
+        if (this.hasScrollableContent !== nextHasScrollableContent) {
+            this.hasScrollableContent = nextHasScrollableContent;
+        }
+    }
+    /**
+     * Mede cabeçalho e uma linha colapsada já renderizada para garantir que
+     * `visibleRows` corresponda à quantidade real de linhas visíveis.
+     * A estimativa baseada em densidade continua sendo usada somente antes da
+     * primeira materialização.
+     */
     /**
-     * Renderiza o host do componente.
+     * Invalida as métricas que definem a altura externa da viewport.
      *
-     * @returns JSX.Element representando o elemento host do componente, contendo a estrutura da tabela.
+     * @remarks A altura não deve ser recalculada durante o scroll, porque
+     * diferentes janelas podem conter linhas com alturas distintas. Recalcular
+     * nesse momento faria o próprio `br-table` crescer ou encolher e deslocaria
+     * elementos externos à tabela.
      */
-    render() {
-        return (h(Host, { key: 'a58c9c25006857f42da639db4ff06fa1a7ba199b', role: "table", "aria-busy": this.loading ? 'true' : null }, h("div", { key: '32b7107a5f08f8f4d3fc018dfaa9da52765a62db', class: this.getTableCssClassMap(), part: "container" }, this.renderContent(), this.loading ? (h("div", { part: "loading", role: "status", "aria-live": "polite" }, h("slot", { name: "loading" }, h("br-loading", { size: "small", label: "Carregando dados" })))) : null)));
+    invalidateViewportMetrics() {
+        this.measuredCollapsedRowHeight = null;
     }
-    static get is() { return "br-table"; }
-    static get encapsulation() { return "shadow"; }
-    static get originalStyleUrls() {
-        return {
-            "$": ["table.scss"]
-        };
+    scheduleViewportHeightMeasurement() {
+        if (this.measuredCollapsedRowHeight !== null && this.measuredHeaderHeight !== null)
+            return;
+        if (this.viewportMeasureFrame !== null)
+            return;
+        this.viewportMeasureFrame = requestAnimationFrame(() => {
+            this.viewportMeasureFrame = null;
+            for (const entry of this.headerHeights.values())
+                entry.refresh();
+            this.updateHeaderHeight();
+            this.applyMeasuredViewportHeight();
+        });
     }
-    static get styleUrls() {
-        return {
-            "$": ["table.css"]
-        };
+    applyMeasuredViewportHeight() {
+        const viewport = this.el.shadowRoot?.querySelector('.br-table-scroll');
+        if (viewport === null || viewport === undefined)
+            return;
+        const referenceRow = this.dataStore.getRenderedRows().find((row) => !row.hasAttribute('expanded'));
+        const measuredRowHeight = referenceRow === undefined
+            ? 0
+            : Math.max(0, ...Array.from(referenceRow.querySelectorAll('br-table-cell'))
+                .filter((cell) => Number(cell.getAttribute('aria-rowspan') ?? 1) <= 1)
+                .map((cell) => cell.shadowRoot?.querySelector('.br-table-cell')?.getBoundingClientRect().height ?? 0));
+        const rowHeight = measuredRowHeight > 0 ? measuredRowHeight : this.resolveVirtualRowHeight();
+        const rowHeightChanged = this.measuredCollapsedRowHeight !== rowHeight;
+        if (rowHeightChanged)
+            this.measuredCollapsedRowHeight = rowHeight;
+        // O JSX usa os valores medidos por meio de resolveScrollViewportHeight().
+        // Mantê-los em @State evita que uma renderização posterior restaure a
+        // estimativa baseada apenas na densidade.
     }
-    static get properties() {
-        return {
-            "columnWidth": {
-                "type": "string",
+    /**
+     * Marca limites de linha e coluna usados pelos estilos de divisores.
+     */
+    /** Matriz lógica inclui células mescladas nas posições ocupadas. */
+    getKeyboardRows() {
+        const headerRows = Array.from(this.el.querySelectorAll('br-table-header > br-table-row'));
+        const matrices = [
+            getTablePlacements(headerRows, 'br-table-header-cell'),
+            ...getTableRowGroups(this.getVirtualRows()).map((group) => getTablePlacements(group, 'br-table-cell')),
+        ];
+        return matrices.flatMap((placements) => {
+            const matrix = [];
+            for (const { cell, row, column, rowSpan, colSpan } of placements) {
+                for (let y = row; y < row + rowSpan; y++) {
+                    matrix[y] ?? (matrix[y] = []);
+                    for (let x = column; x < column + colSpan; x++)
+                        matrix[y][x] = cell;
+                }
+            }
+            return matrix.filter((row) => row.length > 0);
+        });
+    }
+    syncHeaderGrouping() {
+        applyTableHeaderLayout(this.el.querySelector('br-table-header'));
+    }
+    annotateBoundaries() {
+        this.syncHeaderGrouping();
+        const columns = this.getHeaderCells();
+        const columnCount = columns.length;
+        const logicalLastRow = this.dataStore.getRowCount() - 1;
+        columns.forEach((column, columnIndex) => {
+            if (!(column instanceof HTMLElement))
+                return;
+            column.toggleAttribute('data-last-column', columnIndex === columnCount - 1);
+        });
+        this.dataStore.getRenderedRows().forEach((row) => {
+            const logicalIndex = Number(row.getAttribute('data-virtual-index'));
+            const isLastRow = logicalIndex === logicalLastRow;
+            const cells = Array.from(row.querySelectorAll('br-table-cell'));
+            cells.forEach((cell, columnIndex) => {
+                if (!(cell instanceof HTMLElement))
+                    return;
+                cell.toggleAttribute('data-last-row', isLastRow);
+                cell.toggleAttribute('data-last-column', columnIndex === columnCount - 1);
+            });
+        });
+    }
+    /**
+     * Registra a coordenação de mudanças de largura emitidas pelas colunas.
+     */
+    registerColumnWidthListener() {
+        this.el.addEventListener('brColumnWidthChange', () => {
+            this.updateColumnWidths();
+            this.applyAriaMetadata();
+        });
+    }
+    /**
+     * Recalcula e aplica a definição de colunas do grid.
+     */
+    updateColumnWidths() {
+        const headers = this.getHeaderCells();
+        if (headers.length === 0)
+            return;
+        const template = this.buildGridTemplate(headers);
+        this.applyGridTemplate(template);
+    }
+    /**
+     * Constrói o valor de `grid-template-columns` na ordem dos cabeçalhos.
+     */
+    buildGridTemplate(headers) {
+        const tableWidth = this.resolveTableColumnWidth();
+        const columnWidths = headers.map((header) => this.resolveColumnWidth(header, tableWidth));
+        return columnWidths.join(' ');
+    }
+    /**
+     * Resolve a largura padrão declarada na tabela.
+     */
+    resolveTableColumnWidth() {
+        return this.resolveWidthToken(this.columnWidth, COLUMN_WIDTH_MAP[COLUMN_WIDTH_SEMANTICS.FILL]);
+    }
+    /**
+     * Resolve a largura de uma coluna com fallback para a tabela.
+     */
+    resolveColumnWidth(header, fallback) {
+        const headerWidth = header.getAttribute('column-width');
+        return this.resolveWidthToken(headerWidth, fallback);
+    }
+    /**
+     * Valida e converte larguras semânticas ou valores CSS aceitos.
+     */
+    resolveWidthToken(raw, fallback) {
+        return resolveTokenValue(raw ?? undefined, {
+            fallback,
+            semanticMap: COLUMN_WIDTH_MAP,
+            validators: [positivePxValidator, positiveFrValidator],
+        });
+    }
+    /**
+     * Publica a definição de colunas por meio do token do grid.
+     */
+    applyGridTemplate(template) {
+        this.el.style.setProperty(TABLE_TOKENS.COLUMN_WIDTHS, template);
+    }
+    /**
+     * Registra a coordenação de mudanças de alinhamento emitidas pelos filhos.
+     */
+    registerAlignmentListener() {
+        this.el.addEventListener('brAlignmentChange', () => {
+            this.updateAllCellAlignments();
+            this.applyAriaMetadata();
+        });
+    }
+    /**
+     * Recalcula os alinhamentos efetivos de todas as células.
+     */
+    updateAllCellAlignments() {
+        const cells = this.getAllCells();
+        cells.forEach((cell) => {
+            this.updateAlignmentForCell(cell);
+        });
+    }
+    /**
+     * Aplica os alinhamentos efetivos como tokens locais da célula.
+     */
+    updateAlignmentForCell(cell) {
+        const horizontal = this.resolveHorizontalAlignmentForCell(cell);
+        const vertical = this.resolveVerticalAlignmentForCell(cell);
+        cell.style.setProperty(TABLE_TOKENS.HORIZONTAL_ALIGNMENT, horizontal);
+        cell.style.setProperty(TABLE_TOKENS.VERTICAL_ALIGNMENT, vertical);
+    }
+    /**
+     * Resolve o alinhamento horizontal conforme a hierarquia da tabela.
+     */
+    resolveHorizontalAlignmentForCell(cell) {
+        const cellValue = cell.getAttribute('horizontal-alignment');
+        if (cellValue !== null)
+            return this.resolveAlignmentToken(cellValue);
+        const row = cell.closest('br-table-row');
+        const rowValue = row?.getAttribute('horizontal-alignment');
+        if (rowValue !== null)
+            return this.resolveAlignmentToken(rowValue);
+        const columnValue = this.getColumnAlignment(cell, 'horizontal-alignment');
+        if (columnValue !== null)
+            return this.resolveAlignmentToken(columnValue);
+        if (this.horizontalAlignment !== undefined)
+            return this.resolveAlignmentToken(this.horizontalAlignment);
+        return TABLE_ALIGNMENT_MAP[TABLE_ALIGNMENT.START];
+    }
+    /**
+     * Resolve o alinhamento vertical conforme a hierarquia da tabela.
+     */
+    resolveVerticalAlignmentForCell(cell) {
+        const cellValue = cell.getAttribute('vertical-alignment');
+        if (cellValue !== null)
+            return this.resolveAlignmentToken(cellValue);
+        const row = cell.closest('br-table-row');
+        const rowValue = row?.getAttribute('vertical-alignment');
+        if (rowValue !== null)
+            return this.resolveAlignmentToken(rowValue);
+        const columnValue = this.getColumnAlignment(cell, 'vertical-alignment');
+        if (columnValue !== null)
+            return this.resolveAlignmentToken(columnValue);
+        if (this.verticalAlignment !== undefined)
+            return this.resolveAlignmentToken(this.verticalAlignment);
+        return TABLE_ALIGNMENT_MAP[TABLE_ALIGNMENT.START];
+    }
+    /**
+     * Converte um alinhamento semântico no valor CSS correspondente.
+     */
+    resolveAlignmentToken(value) {
+        return resolveTokenValue(value ?? undefined, {
+            fallback: TABLE_ALIGNMENT_MAP[TABLE_ALIGNMENT.START],
+            semanticMap: TABLE_ALIGNMENT_MAP,
+        });
+    }
+    /**
+     * Obtém um atributo herdável no cabeçalho da coluna correspondente.
+     */
+    getColumnAlignment(cell, attribute) {
+        const columnIndex = this.getColumnIndex(cell);
+        if (columnIndex === -1)
+            return null;
+        const headers = this.getHeaderCells();
+        const header = headers[columnIndex];
+        return header?.getAttribute(attribute) ?? null;
+    }
+    /**
+     * Retorna a posição de uma célula dentro de sua linha.
+     */
+    getColumnIndex(cell) {
+        const row = cell.closest('br-table-row');
+        if (row === null)
+            return -1;
+        const group = row.parentElement?.hasAttribute('data-table-row-group')
+            ? Array.from(row.parentElement.querySelectorAll(':scope > br-table-row'))
+            : [row];
+        return getTablePlacements(group, 'br-table-cell').find((entry) => entry.cell === cell)?.column ?? -1;
+    }
+    /**
+     * Retorna os cabeçalhos na ordem visual do grid.
+     */
+    getHeaderCells() {
+        return getTableLeafHeaders(Array.from(this.el.querySelectorAll('br-table-header > br-table-row')));
+    }
+    /**
+     * Retorna células de cabeçalho e de dados.
+     */
+    getAllCells() {
+        return Array.from(this.el.querySelectorAll('br-table-cell, br-table-header-cell'));
+    }
+    /**
+     * Registra a coordenação de mudanças de overflow emitidas pelos filhos.
+     */
+    registerOverflowListener() {
+        this.el.addEventListener('brOverflowChange', () => {
+            this.updateAllCellOverflow();
+            this.applyAriaMetadata();
+        });
+    }
+    /**
+     * Aplica contagens e índices ARIA à estrutura atual.
+     */
+    applyAriaMetadata() {
+        this.syncHeaderGrouping();
+        const headerRows = Array.from(this.el.querySelectorAll('br-table-header > br-table-row'));
+        const bodyRows = this.dataStore.getRenderedRows();
+        const tableGrid = this.el.shadowRoot?.querySelector('.br-table-content');
+        const grouped = this.dataStore.getItemCount() !== this.dataStore.getRowCount();
+        const remote = this.hasPagination && this.dataStore.getItemCount() < this.resolvePaginationTotalItems();
+        const logicalRowCount = remote ? this.resolvePaginationTotalItems() : this.dataStore.getRowCount();
+        tableGrid?.setAttribute('aria-colcount', String(this.getHeaderCells().length));
+        tableGrid?.setAttribute('aria-rowcount', grouped && remote ? '-1' : String(logicalRowCount + headerRows.length));
+        headerRows.forEach((row, index) => {
+            row.setAttribute('aria-rowindex', String(index + 1));
+        });
+        const headerPlacements = getTablePlacements(headerRows, 'br-table-header-cell');
+        headerPlacements.forEach(({ cell, column }, index) => {
+            cell.id || (cell.id = `${this.generatedHeaderPrefix}-${index + 1}`);
+            cell.setAttribute('aria-colindex', String(column + 1));
+        });
+        bodyRows.forEach((row) => {
+            const offset = remote && !grouped ? (this.resolveCurrentPage() - 1) * this.resolvePageSize() : 0;
+            const logicalIndex = Number(row.getAttribute('data-virtual-index'));
+            if (grouped && remote)
+                row.removeAttribute('aria-rowindex');
+            else
+                row.setAttribute('aria-rowindex', String(logicalIndex + offset + headerRows.length + 1));
+        });
+        for (const group of getTableRowGroups(bodyRows)) {
+            for (const { cell, column, rowSpan, colSpan } of getTablePlacements(group, 'br-table-cell')) {
+                cell.setAttribute('aria-colindex', String(column + 1));
+                if (rowSpan > 1)
+                    cell.setAttribute('aria-rowspan', String(rowSpan));
+                else
+                    cell.removeAttribute('aria-rowspan');
+                if (colSpan > 1)
+                    cell.setAttribute('aria-colspan', String(colSpan));
+                else
+                    cell.removeAttribute('aria-colspan');
+            }
+        }
+        this.keyboard?.sync();
+    }
+    /**
+     * Recalcula o overflow efetivo de todas as células.
+     */
+    updateAllCellOverflow() {
+        this.getAllCells().forEach((cell) => {
+            this.updateOverflowForCell(cell);
+        });
+    }
+    /**
+     * Aplica a configuração efetiva de overflow como tokens locais.
+     */
+    updateOverflowForCell(cell) {
+        const mode = this.resolveOverflowForCell(cell);
+        const config = TABLE_OVERFLOW_MAP[mode];
+        cell.style.setProperty(TABLE_TOKENS.CELL_OVERFLOW, config.overflow);
+        cell.style.setProperty(TABLE_TOKENS.CELL_TEXT_OVERFLOW, config.textOverflow);
+        cell.style.setProperty(TABLE_TOKENS.CELL_WHITE_SPACE, config.whiteSpace);
+        cell.setAttribute('data-applied-overflow', mode);
+    }
+    /**
+     * Resolve o overflow conforme célula, linha, coluna e tabela.
+     */
+    resolveOverflowForCell(cell) {
+        let value = cell.getAttribute('overflow');
+        if (value === null) {
+            const row = cell.closest('br-table-row');
+            value = row?.getAttribute('overflow') ?? null;
+        }
+        if (value === null) {
+            value = this.getColumnAttribute(cell, 'overflow') ?? null;
+        }
+        if (value === null) {
+            value = this.overflow ?? null;
+        }
+        if (value === null) {
+            value = TABLE_OVERFLOW.WRAP;
+        }
+        return value === TABLE_OVERFLOW.TRUNCATE ? TABLE_OVERFLOW.TRUNCATE : TABLE_OVERFLOW.WRAP;
+    }
+    /**
+     * Obtém um atributo no cabeçalho correspondente à célula.
+     */
+    getColumnAttribute(cell, attribute) {
+        const header = this.getHeaderForCell(cell);
+        return header?.getAttribute(attribute) ?? null;
+    }
+    /**
+     * Localiza o cabeçalho que ocupa a mesma coluna da célula.
+     */
+    getHeaderForCell(cell) {
+        const index = this.getColumnIndex(cell);
+        if (index === -1)
+            return null;
+        const headers = this.getHeaderCells();
+        return headers[index] ?? null;
+    }
+    /** Publica a altura padrão da área expandida para herança pelas linhas. */
+    applyExpandedContentHeight() {
+        const value = Number.isFinite(this.virtualExpandedContentHeight)
+            ? Math.max(1, this.virtualExpandedContentHeight)
+            : 240;
+        this.el.style.setProperty(TABLE_TOKENS.EXPANDED_CONTENT_HEIGHT, `${value}px`);
+    }
+    /**
+     * Converte a densidade semântica em tokens de espaçamento.
+     */
+    applyDensity() {
+        const resolved = resolveTokenValue(this.density, {
+            fallback: TABLE_DENSITY_MAP[TABLE_DENSITY.MEDIUM],
+            semanticMap: TABLE_DENSITY_MAP,
+        });
+        const resolvedToolbarPadding = resolveTokenValue(this.density, {
+            fallback: TABLE_BAR_PADDING_MAP[TABLE_DENSITY.MEDIUM],
+            semanticMap: TABLE_BAR_PADDING_MAP,
+        });
+        this.el.style.setProperty(TABLE_TOKENS.DENSITY, resolved);
+        this.el.style.setProperty(TABLE_TOKENS.BAR_PADDING, resolvedToolbarPadding);
+    }
+    /**
+     * Aplica estilo e fatores de visibilidade dos divisores.
+     */
+    applyDividers() {
+        const style = resolveTokenValue(this.dividerStyle, {
+            fallback: TABLE_DIVIDER_STYLE_MAP[TABLE_DIVIDER_STYLE.SOLID],
+            semanticMap: TABLE_DIVIDER_STYLE_MAP,
+        });
+        const rowFactor = (this.rowDivider ?? this.hasRowDivider) ? '1' : '0';
+        const columnFactor = (this.columnDivider ?? this.hasColumnDivider) ? '1' : '0';
+        this.el.style.setProperty(TABLE_TOKENS.DIVIDER_STYLE, style);
+        this.el.style.setProperty(TABLE_TOKENS.ROW_DIVIDER_FACTOR, rowFactor);
+        this.el.style.setProperty(TABLE_TOKENS.COLUMN_DIVIDER_FACTOR, columnFactor);
+    }
+    /**
+     * Renderiza barras, slots e o grid principal.
+     *
+     * @remarks `role="grid"` fica isolado no contêiner que só possui os dois
+     * elementos `role="rowgroup"` como filhos; a barra de ações e o rodapé
+     * ficam fora dessa árvore para não serem contados como filhos inválidos do
+     * papel `grid`. O nome acessível vai como `aria-label` (string), pois um
+     * `aria-labelledby` não resolveria um id do light DOM a partir da shadow tree.
+     */
+    renderContent(accessibleName) {
+        return (h(Fragment, null, h("br-table-bar", { "prop:density": this.density ?? TABLE_DENSITY.MEDIUM, "prop:heading": this.heading ?? '', "prop:headingActionsLimit": this.headingActionsLimit, "prop:contextualActionsLimit": this.contextualActionsLimit, "prop:hasGlobalActionsContent": this.hasGlobalActionsContent, "prop:hasContextualActionsContent": this.hasContextualActionsContent, "prop:selectedRowsCount": this.selectedRowsCount, "prop:showContextualBar": this.showContextualBar || this.selectedRowsCount > 0, "prop:hasSearch": this.hasSearch, "attr:data-br-table-heading-actions-tooltip-label": this.moreActionsHeadingLabel, "attr:data-br-table-contextual-actions-tooltip-label": this.moreActionsContextualLabel, style: {
+                [TABLE_TOKENS.DENSITY]: resolveTokenValue(this.density, {
+                    fallback: TABLE_DENSITY_MAP[TABLE_DENSITY.MEDIUM],
+                    semanticMap: TABLE_DENSITY_MAP,
+                }),
+            } }, h("slot", { name: "global-actions", slot: "global-actions" }), h("slot", { name: "contextual-actions", slot: "contextual-actions" })), h("div", { class: { 'br-table-scroll-shell': true, loading: this.loading }, style: {
+                height: this.resolveScrollViewportHeight(),
+                '--table-scroll-header-height': `${this.measuredHeaderHeight ?? 0}px`,
+            } }, h("div", { class: "br-table-scroll", part: "scroll-container", style: { height: this.resolveScrollViewportHeight() }, onScroll: this.handleViewportScroll }, h("div", { class: { 'br-table-content': true, loading: this.loading }, role: "grid", "aria-label": accessibleName, "aria-multiselectable": this.hasRowSelection ? 'true' : null, "aria-busy": this.loading ? 'true' : null, "aria-hidden": this.loading && this.dataStore.getRowCount() === 0 && this.dataStore.getColumns().length === 0
+                ? 'true'
+                : null, part: "content" }, h("slot", { name: "header", onSlotchange: this.handleStructureChange }), h("slot", { name: "body", onSlotchange: this.handleStructureChange }))))));
+    }
+    /** Resolve o nome acessível do papel `grid`, sempre como texto plano. */
+    resolveAccessibleGridName() {
+        const explicitLabelledby = this.el.getAttribute('aria-labelledby')?.trim();
+        const root = this.el.getRootNode();
+        if (explicitLabelledby && (root instanceof Document || root instanceof ShadowRoot)) {
+            const referencedText = explicitLabelledby
+                .split(/\s+/)
+                .map((id) => root.getElementById(id)?.textContent?.trim())
+                .filter(Boolean)
+                .join(' ')
+                .replace(/\s+/g, ' ');
+            if (referencedText.length > 0)
+                return referencedText;
+        }
+        const explicitLabel = this.el.getAttribute('aria-label')?.trim();
+        if (explicitLabel)
+            return explicitLabel;
+        return this.heading?.trim() || 'Tabela';
+    }
+    /**
+     * Renderiza o componente com semântica ARIA de grid.
+     */
+    render() {
+        return (h(Host, { key: 'a8583b9c76f2d800732bae952ec638fb9960ee81', "aria-busy": this.loading ? 'true' : null }, h("div", { key: '22bce3d4db20241d4fb03e792e0b3c5ee2dabcaf', class: "br-table", part: "container" }, this.renderContent(this.resolveAccessibleGridName())), this.hasPagination && (h("br-table-footer", { key: '4bf01e2f882971c10159c5f2a9d7ce78fcd1db9a', part: "footer", "prop:currentPage": this.currentPage, "prop:pageSize": this.resolvePageSize(), pageSizeOptions: this.pageSizeOptions, "prop:totalItems": this.resolvePaginationTotalItems(), "prop:density": this.density ?? 'medium', "attr:has-scroll": this.hasScrollableContent ? '' : null, onBrInternalTableFooterPageChange: this.handleFooterPageChange, onBrInternalTableFooterPerPageChange: this.handleFooterPerPageChange })), this.loading ? (h("div", { part: "loading", role: "status", "aria-live": "polite" }, h("div", { class: "br-table-loading-panel", role: "region", "aria-label": "Carregamento da tabela", tabIndex: 0 }, h("slot", { name: "loading" }, h("br-loading", { density: "medium", label: "Carregando dados", labelPosition: "bottom" }))))) : null));
+    }
+    static get is() { return "br-table"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["table.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["table.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "columnWidth": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "ColumnWidth",
+                    "resolved": "\"content\" | \"fill\" | `${number}fr` | `${number}px`",
+                    "references": {
+                        "ColumnWidth": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::ColumnWidth",
+                            "referenceLocation": "ColumnWidth"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "fill"
+                        }],
+                    "text": "Largura padr\u00E3o utilizada pelas colunas sem configura\u00E7\u00E3o pr\u00F3pria."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "column-width"
+            },
+            "density": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "TableDensity",
+                    "resolved": "\"large\" | \"medium\" | \"small\"",
+                    "references": {
+                        "TableDensity": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableDensity",
+                            "referenceLocation": "TableDensity"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Quando omitida, a propriedade permanece `undefined` e a densidade\nvisual m\u00E9dia \u00E9 aplicada aos tokens da tabela."
+                        }, {
+                            "name": "default",
+                            "text": "undefined"
+                        }],
+                    "text": "Densidade visual aplicada aos espa\u00E7amentos da tabela."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "density"
+            },
+            "dividerStyle": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "TableDividerStyle",
+                    "resolved": "\"dashed\" | \"solid\"",
+                    "references": {
+                        "TableDividerStyle": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableDividerStyle",
+                            "referenceLocation": "TableDividerStyle"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "solid"
+                        }],
+                    "text": "Estilo aplicado aos divisores habilitados."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "divider-style"
+            },
+            "hasColumnDivider": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Use `columnDivider` instead."
+                        }, {
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Habilita divisores entre colunas quando `columnDivider` n\u00E3o \u00E9 informado."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "has-column-divider",
+                "defaultValue": "false"
+            },
+            "columnDivider": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Quando informado, tem preced\u00EAncia sobre `hasColumnDivider`,\ninclusive quando `false`. Na aus\u00EAncia de ambos, os divisores ficam desabilitados."
+                        }],
+                    "text": "Habilita divisores entre colunas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "column-divider"
+            },
+            "hasRowDivider": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "deprecated",
+                            "text": "Use `rowDivider` instead."
+                        }, {
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Habilita divisores entre linhas quando `rowDivider` n\u00E3o \u00E9 informado."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "has-row-divider",
+                "defaultValue": "false"
+            },
+            "rowDivider": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Quando informado, tem preced\u00EAncia sobre `hasRowDivider`,\ninclusive quando `false`. Na aus\u00EAncia de ambos, os divisores ficam desabilitados."
+                        }],
+                    "text": "Habilita divisores entre linhas."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "row-divider"
+            },
+            "hasRowHover": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Habilita o realce visual das linhas ao passar o ponteiro."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "has-row-hover",
+                "defaultValue": "false"
+            },
+            "loading": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Mant\u00E9m os dados anteriores, reduz sua opacidade e exibe o slot\n`loading` em um painel central com scrim sobre toda a tabela, incluindo\nbarra de a\u00E7\u00F5es e pagina\u00E7\u00E3o. O scrim fica limitado ao componente.\nReflete o atributo `loading` e pode ser alterada diretamente ou pelos m\u00E9todos\n`startLoading()` e `stopLoading()`. N\u00E3o bloqueia o teclado nem gerencia\nrequisi\u00E7\u00F5es, erros ou substitui\u00E7\u00E3o dos dados."
+                        }, {
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Indica que as linhas est\u00E3o sendo atualizadas pelo consumidor."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "loading",
+                "defaultValue": "false"
+            },
+            "heading": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "null"
+                        }],
+                    "text": "T\u00EDtulo apresentado na barra principal."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "heading"
+            },
+            "showContextualBar": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "For\u00E7a a apresenta\u00E7\u00E3o da barra contextual."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "show-contextual-bar",
+                "defaultValue": "false"
+            },
+            "headingActionsLimit": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "4"
+                        }],
+                    "text": "Limite usado para decidir quando agrupar a\u00E7\u00F5es globais em um menu.\nQuando o n\u00FAmero de a\u00E7\u00F5es excede esse valor, as a\u00E7\u00F5es s\u00E3o agrupadas no\ndropdown (atualmente todas s\u00E3o movidas para o menu colapsado)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "heading-actions-limit",
+                "defaultValue": "4"
+            },
+            "contextualActionsLimit": {
+                "type": "number",
                 "mutable": false,
                 "complexType": {
-                    "original": "ColumnWidth",
-                    "resolved": "\"content\" | \"fill\" | `${number}fr` | `${number}px`",
-                    "references": {
-                        "ColumnWidth": {
-                            "location": "import",
-                            "path": "./table-types",
-                            "id": "src/components/table/table-types.ts::ColumnWidth",
-                            "referenceLocation": "ColumnWidth"
-                        }
-                    }
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [{
-                            "name": "remarks",
-                            "text": "Valores aceitos:\n- fill\n- content\n- ${number}px\n- ${number}fr\n\nObserva\u00E7\u00E3o:\n- `columnWidth` n\u00E3o define o comportamento de `overflow`, mas pode interferir na sua percep\u00E7\u00E3o ao alterar o espa\u00E7o dispon\u00EDvel da coluna.\n- `content` (`max-content`) tende a expandir a coluna e reduzir casos vis\u00EDveis de truncagem.\n- `fill` (`1fr`) tende a evidenciar truncagem quando o espa\u00E7o horizontal \u00E9 insuficiente."
-                        }, {
                             "name": "default",
-                            "text": "fill"
-                        }, {
-                            "name": "example",
-                            "text": "```html\n<br-table column-width=\"160px\"></br-table>\n```"
+                            "text": "4"
                         }],
-                    "text": "Largura global aplicada a todas as colunas."
+                    "text": "Limite usado para decidir quando agrupar a\u00E7\u00F5es contextuais em um menu.\nQuando o n\u00FAmero de a\u00E7\u00F5es excede esse valor, as a\u00E7\u00F5es s\u00E3o agrupadas no\ndropdown (atualmente todas s\u00E3o movidas para o menu colapsado)."
                 },
                 "getter": false,
                 "setter": false,
                 "reflect": true,
-                "attribute": "column-width"
+                "attribute": "contextual-actions-limit",
+                "defaultValue": "4"
             },
-            "density": {
+            "moreActionsHeadingLabel": {
                 "type": "string",
                 "mutable": false,
                 "complexType": {
-                    "original": "TableDensity",
-                    "resolved": "\"large\" | \"medium\" | \"small\"",
-                    "references": {
-                        "TableDensity": {
-                            "location": "import",
-                            "path": "./table-types",
-                            "id": "src/components/table/table-types.ts::TableDensity",
-                            "referenceLocation": "TableDensity"
-                        }
-                    }
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
-                    "tags": [],
-                    "text": "Define a densidade visual do componente.\n\n- `small`: Alta densidade (componente menor, mais compacto e com menos espa\u00E7amento).\n- `medium`: Densidade intermedi\u00E1ria, padr\u00E3o recomendado para a maioria dos casos.\n- `large`: Baixa densidade (componente maior, mais espa\u00E7amento e altura).\n\nValores inv\u00E1lidos usam `medium`. Quando omitida, a densidade m\u00E9dia \u00E9 aplicada ao token."
+                    "tags": [{
+                            "name": "default",
+                            "text": "'Mais a\u00E7\u00F5es'"
+                        }],
+                    "text": "Texto do tooltip do bot\u00E3o de a\u00E7\u00F5es agrupadas na barra de t\u00EDtulo.\nQuando vazio ou composto apenas por espa\u00E7os, usa \"Mais a\u00E7\u00F5es\".\nN\u00E3o altera o nome acess\u00EDvel do bot\u00E3o nem os r\u00F3tulos do menu."
                 },
                 "getter": false,
                 "setter": false,
-                "reflect": true,
-                "attribute": "density"
+                "reflect": false,
+                "attribute": "more-actions-heading-label",
+                "defaultValue": "'Mais a\u00E7\u00F5es'"
             },
-            "dividerStyle": {
+            "moreActionsContextualLabel": {
                 "type": "string",
                 "mutable": false,
                 "complexType": {
-                    "original": "TableDividerStyle",
-                    "resolved": "\"dashed\" | \"solid\"",
-                    "references": {
-                        "TableDividerStyle": {
-                            "location": "import",
-                            "path": "./table-types",
-                            "id": "src/components/table/table-types.ts::TableDividerStyle",
-                            "referenceLocation": "TableDividerStyle"
-                        }
-                    }
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "'Mais a\u00E7\u00F5es'"
+                        }],
+                    "text": "Texto do tooltip do bot\u00E3o de a\u00E7\u00F5es agrupadas da barra contextual.\nQuando vazio ou composto apenas por espa\u00E7os, usa \"Mais a\u00E7\u00F5es\".\nN\u00E3o altera o nome acess\u00EDvel do bot\u00E3o nem os r\u00F3tulos do menu."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "more-actions-contextual-label",
+                "defaultValue": "'Mais a\u00E7\u00F5es'"
+            },
+            "moreActionsLabel": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
                 },
                 "required": false,
                 "optional": true,
                 "docs": {
                     "tags": [{
-                            "name": "remarks",
-                            "text": "Valores aceitos:\n- solid\n- dashed"
-                        }, {
                             "name": "default",
-                            "text": "solid"
+                            "text": "undefined"
                         }],
-                    "text": "Define o estilo visual dos divisores."
+                    "text": "Texto completo do tooltip dos bot\u00F5es de a\u00E7\u00F5es agrupadas nas c\u00E9lulas.\nQuando informado, prevalece sobre `moreActionsLabel` de cada c\u00E9lula.\nQuando omitido, a c\u00E9lula usa seu valor local ou \"Mais a\u00E7\u00F5es\".\nValores vazios ou compostos apenas por espa\u00E7os usam \"Mais a\u00E7\u00F5es\".\nAceita texto simples por atributo ou propriedade.\nReflete o valor no atributo `more-actions-label` para sincronizar as c\u00E9lulas."
                 },
                 "getter": false,
                 "setter": false,
                 "reflect": true,
-                "attribute": "divider-style"
+                "attribute": "more-actions-label"
             },
-            "hasColumnDivider": {
+            "cellActionsLimit": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "4"
+                        }],
+                    "text": "Limite padr\u00E3o de a\u00E7\u00F5es exibidas em cada c\u00E9lula."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "cell-actions-limit",
+                "defaultValue": "4"
+            },
+            "hasRowSelection": {
                 "type": "boolean",
                 "mutable": false,
                 "complexType": {
@@ -757,24 +1984,21 @@ export class Table {
                     "references": {}
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [{
                             "name": "default",
                             "text": "false"
-                        }, {
-                            "name": "deprecated",
-                            "text": "Use `columnDivider`."
                         }],
-                    "text": "Ativa divisores verticais entre colunas."
+                    "text": "Habilita a coluna de sele\u00E7\u00E3o de linhas."
                 },
                 "getter": false,
                 "setter": false,
                 "reflect": true,
-                "attribute": "has-column-divider",
+                "attribute": "has-row-selection",
                 "defaultValue": "false"
             },
-            "columnDivider": {
+            "hasRowExpansion": {
                 "type": "boolean",
                 "mutable": false,
                 "complexType": {
@@ -783,17 +2007,21 @@ export class Table {
                     "references": {}
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
-                    "tags": [],
-                    "text": "Ativa divisores verticais. Quando informada, tem preced\u00EAncia sobre `hasColumnDivider`."
+                    "tags": [{
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Habilita a coluna de expans\u00E3o de linhas."
                 },
                 "getter": false,
                 "setter": false,
                 "reflect": true,
-                "attribute": "column-divider"
+                "attribute": "has-row-expansion",
+                "defaultValue": "false"
             },
-            "hasRowDivider": {
+            "hasSearch": {
                 "type": "boolean",
                 "mutable": false,
                 "complexType": {
@@ -802,24 +2030,21 @@ export class Table {
                     "references": {}
                 },
                 "required": false,
-                "optional": true,
+                "optional": false,
                 "docs": {
                     "tags": [{
                             "name": "default",
                             "text": "false"
-                        }, {
-                            "name": "deprecated",
-                            "text": "Use `rowDivider`."
                         }],
-                    "text": "Ativa divisores horizontais entre linhas."
+                    "text": "Disponibiliza a interface de busca, sem filtrar ou destacar o conte\u00FAdo.\nA aplica\u00E7\u00E3o recebe `brTableSearch` e atualiza os dados local ou remotamente."
                 },
                 "getter": false,
                 "setter": false,
                 "reflect": true,
-                "attribute": "has-row-divider",
+                "attribute": "has-search",
                 "defaultValue": "false"
             },
-            "rowDivider": {
+            "hasPagination": {
                 "type": "boolean",
                 "mutable": false,
                 "complexType": {
@@ -828,15 +2053,241 @@ export class Table {
                     "references": {}
                 },
                 "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "A pagina\u00E7\u00E3o define o subconjunto l\u00F3gico dispon\u00EDvel para a lista\nvirtual. `pageSize` conta linhas independentes ou grupos completos, e\n`visibleRows` controla quantas delas cabem simultaneamente na viewport.\nQuando os dados completos ainda n\u00E3o est\u00E3o dispon\u00EDveis localmente\n(pagina\u00E7\u00E3o por API), informe `totalItems` e forne\u00E7a o subconjunto\ncorrespondente ap\u00F3s `brTablePageChange`."
+                        }, {
+                            "name": "default",
+                            "text": "false"
+                        }],
+                    "text": "Habilita a pagina\u00E7\u00E3o da tabela, renderizando `br-table-footer` internamente."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "has-pagination",
+                "defaultValue": "false"
+            },
+            "currentPage": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Atualizada internamente quando `TableDataStore` j\u00E1 cobre a\np\u00E1gina solicitada. Utilize como valor inicial ou para navegar\nprogramaticamente para outra p\u00E1gina."
+                        }, {
+                            "name": "default",
+                            "text": "1"
+                        }],
+                    "text": "P\u00E1gina atual exibida pela pagina\u00E7\u00E3o (1-indexada)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "current-page",
+                "defaultValue": "1"
+            },
+            "pageSize": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Quando omitida, utiliza `visibleRows` como fallback para manter\ncompatibilidade com a API anterior. Defina um valor maior que\n`visibleRows` para que pagina\u00E7\u00E3o e virtualiza\u00E7\u00E3o operem simultaneamente."
+                        }],
+                    "text": "Quantidade de itens pertencentes a cada p\u00E1gina (linhas independentes ou grupos completos)."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "page-size"
+            },
+            "pageSizeOptions": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "number[]",
+                    "resolved": "number[]",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "[10, 20, 30]"
+                        }],
+                    "text": "Op\u00E7\u00F5es dispon\u00EDveis de itens por p\u00E1gina no seletor da pagina\u00E7\u00E3o."
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "[10, 20, 30]"
+            },
+            "totalItems": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Necess\u00E1rio apenas quando `TableDataStore` n\u00E3o cont\u00E9m o conjunto\ncompleto (pagina\u00E7\u00E3o por API). Quando omitido, \u00E9 derivado automaticamente\nda quantidade de linhas independentes e grupos j\u00E1 presentes na tabela."
+                        }],
+                    "text": "Quantidade total de itens do conjunto de dados."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "total-items"
+            },
+            "sortMode": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "TableSortMode",
+                    "resolved": "\"multi\" | \"single\"",
+                    "references": {
+                        "TableSortMode": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableSortMode",
+                            "referenceLocation": "TableSortMode"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "single"
+                        }],
+                    "text": "Define se a tabela aceita uma \u00FAnica coluna ordenada ou m\u00FAltiplas colunas.\nNo modo `multi`, a prioridade \u00E9 sempre a ordem visual da esquerda para a direita."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "sort-mode",
+                "defaultValue": "'single'"
+            },
+            "sortStrategy": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "TableSortStrategy",
+                    "resolved": "\"local\" | \"manual\"",
+                    "references": {
+                        "TableSortStrategy": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableSortStrategy",
+                            "referenceLocation": "TableSortStrategy"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "local"
+                        }],
+                    "text": "Define se a tabela ordena as linhas localmente ou deixa a aplica\u00E7\u00E3o aplicar\na ordena\u00E7\u00E3o solicitada. Em `manual`, a tabela mant\u00E9m os indicadores e emite\n`brTableSortChange`, mas n\u00E3o reordena as linhas; use `setData()` para fornecer\nos resultados customizados ou remotos. Valores n\u00E3o reconhecidos usam a\nestrat\u00E9gia local."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "sort-strategy",
+                "defaultValue": "'local'"
+            },
+            "visibleRows": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "N\u00E3o limita o conjunto de dados nem realiza pagina\u00E7\u00E3o. A altura da\nregi\u00E3o de scroll \u00E9 derivada desta quantidade e da densidade atual. Mesmo\ncom `hasPagination` habilitado, esta propriedade continua definindo\napenas a capacidade visual da viewport; `pageSize` define o tamanho l\u00F3gico\nda p\u00E1gina."
+                        }, {
+                            "name": "default",
+                            "text": "10"
+                        }],
+                    "text": "Quantidade de linhas de dados vis\u00EDveis simultaneamente na viewport."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "visible-rows",
+                "defaultValue": "10"
+            },
+            "heightRows": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
                 "optional": true,
+                "docs": {
+                    "tags": [{
+                            "name": "default",
+                            "text": "visibleRows"
+                        }],
+                    "text": "Quantidade de itens l\u00F3gicos usada somente para calcular a altura da viewport.\nCada grupo cont\u00EDguo conta como um item; a altura inclui todas as linhas\nf\u00EDsicas que comp\u00F5em os grupos reservados. N\u00E3o altera pagina\u00E7\u00E3o, rolagem ou\nvirtualiza\u00E7\u00E3o. Quando omitida, acompanha `visibleRows`."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "height-rows"
+            },
+            "virtualExpandedContentHeight": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "Ativa divisores horizontais. Quando informada, tem preced\u00EAncia sobre `hasRowDivider`."
+                    "text": "Altura adicional estimada para conte\u00FAdo expandido ainda n\u00E3o medido."
                 },
                 "getter": false,
                 "setter": false,
                 "reflect": true,
-                "attribute": "row-divider"
+                "attribute": "virtual-expanded-content-height",
+                "defaultValue": "240"
             },
             "horizontalAlignment": {
                 "type": "string",
@@ -847,8 +2298,8 @@ export class Table {
                     "references": {
                         "TableAlignment": {
                             "location": "import",
-                            "path": "./table-types",
-                            "id": "src/components/table/table-types.ts::TableAlignment",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableAlignment",
                             "referenceLocation": "TableAlignment"
                         }
                     }
@@ -857,13 +2308,10 @@ export class Table {
                 "optional": true,
                 "docs": {
                     "tags": [{
-                            "name": "remarks",
-                            "text": "Valores aceitos:\n- start\n- center\n- end"
-                        }, {
                             "name": "default",
                             "text": "start"
                         }],
-                    "text": "Define o alinhamento horizontal do conte\u00FAdo das c\u00E9lulas."
+                    "text": "Alinhamento horizontal padr\u00E3o da tabela."
                 },
                 "getter": false,
                 "setter": false,
@@ -879,8 +2327,8 @@ export class Table {
                     "references": {
                         "TableAlignment": {
                             "location": "import",
-                            "path": "./table-types",
-                            "id": "src/components/table/table-types.ts::TableAlignment",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableAlignment",
                             "referenceLocation": "TableAlignment"
                         }
                     }
@@ -889,13 +2337,10 @@ export class Table {
                 "optional": true,
                 "docs": {
                     "tags": [{
-                            "name": "remarks",
-                            "text": "Valores aceitos:\n- start\n- center\n- end"
-                        }, {
                             "name": "default",
                             "text": "start"
                         }],
-                    "text": "Define o alinhamento vertical do conte\u00FAdo das c\u00E9lulas."
+                    "text": "Alinhamento vertical padr\u00E3o da tabela."
                 },
                 "getter": false,
                 "setter": false,
@@ -911,8 +2356,8 @@ export class Table {
                     "references": {
                         "TableOverflow": {
                             "location": "import",
-                            "path": "./table-types",
-                            "id": "src/components/table/table-types.ts::TableOverflow",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableOverflow",
                             "referenceLocation": "TableOverflow"
                         }
                     }
@@ -921,13 +2366,10 @@ export class Table {
                 "optional": true,
                 "docs": {
                     "tags": [{
-                            "name": "remarks",
-                            "text": "Valores aceitos:\n- truncate\n- wrap\n\nObserva\u00E7\u00E3o:\n- O overflow \u00E9 independente de `columnWidth`.\n- Com `columnWidth=\"content\"`, a coluna tende a crescer com o conte\u00FAdo (`max-content`), o que pode reduzir casos vis\u00EDveis de truncagem.\n- Com `columnWidth=\"fill\"`, a coluna ocupa o espa\u00E7o dispon\u00EDvel (`1fr`), ent\u00E3o a truncagem tende a ficar mais evidente quando n\u00E3o h\u00E1 espa\u00E7o suficiente."
-                        }, {
                             "name": "default",
                             "text": "wrap"
                         }],
-                    "text": "Define o comportamento de overflow para as c\u00E9lulas."
+                    "text": "Estrat\u00E9gia padr\u00E3o para conte\u00FAdos que excedem a c\u00E9lula."
                 },
                 "getter": false,
                 "setter": false,
@@ -944,8 +2386,8 @@ export class Table {
                     "references": {
                         "TableTooltipState": {
                             "location": "import",
-                            "path": "./table-types",
-                            "id": "src/components/table/table-types.ts::TableTooltipState",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableTooltipState",
                             "referenceLocation": "TableTooltipState"
                         }
                     }
@@ -954,13 +2396,10 @@ export class Table {
                 "optional": true,
                 "docs": {
                     "tags": [{
-                            "name": "remarks",
-                            "text": "Valores aceitos:\n- info\n- warning\n- danger\n- success"
-                        }, {
                             "name": "default",
                             "text": "info"
                         }],
-                    "text": "Define o estado sem\u00E2ntico do tooltip nas c\u00E9lulas da tabela."
+                    "text": "Estado visual padr\u00E3o dos tooltips."
                 },
                 "getter": false,
                 "setter": false,
@@ -977,8 +2416,8 @@ export class Table {
                     "references": {
                         "TableTooltipMode": {
                             "location": "import",
-                            "path": "./table-types",
-                            "id": "src/components/table/table-types.ts::TableTooltipMode",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableTooltipMode",
                             "referenceLocation": "TableTooltipMode"
                         }
                     }
@@ -987,9 +2426,6 @@ export class Table {
                 "optional": true,
                 "docs": {
                     "tags": [{
-                            "name": "remarks",
-                            "text": "Valores aceitos:\n- inherit\n- enabled\n- disabled"
-                        }, {
                             "name": "default",
                             "text": "disabled (valor efetivo)"
                         }],
@@ -999,31 +2435,206 @@ export class Table {
                 "setter": false,
                 "reflect": true,
                 "attribute": "tooltip-mode"
-            },
-            "loading": {
-                "type": "boolean",
-                "mutable": true,
+            }
+        };
+    }
+    static get states() {
+        return {
+            "selectedRowsCount": {},
+            "measuredCollapsedRowHeight": {},
+            "measuredHeaderHeight": {},
+            "hasGlobalActionsContent": {},
+            "hasContextualActionsContent": {},
+            "hasScrollableContent": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "brTableActionClick",
+                "name": "brTableActionClick",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "O `detail` utiliza `TableActionClickDetail`."
+                        }],
+                    "text": "Reemite a\u00E7\u00F5es globais, contextuais e de linha para o consumidor."
+                },
                 "complexType": {
-                    "original": "boolean",
-                    "resolved": "boolean",
-                    "references": {}
+                    "original": "TableActionClickDetail",
+                    "resolved": "{ type: \"contextual\" | \"row\" | \"global\"; label: string; rowIndex?: number; }",
+                    "references": {
+                        "TableActionClickDetail": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableActionClickDetail",
+                            "referenceLocation": "TableActionClickDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "brTableSelectionChange",
+                "name": "brTableSelectionChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "O `detail` utiliza `TableSelectionChangeDetail`."
+                        }],
+                    "text": "Emitido quando o conjunto de linhas selecionadas muda."
                 },
-                "required": false,
-                "optional": false,
+                "complexType": {
+                    "original": "TableSelectionChangeDetail",
+                    "resolved": "{ selectedRows: HTMLBrTableRowElement[]; selectedIndexes: number[]; selectedCount: number; rowIndex?: number; source: TableSelectionChangeSource; }",
+                    "references": {
+                        "TableSelectionChangeDetail": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableSelectionChangeDetail",
+                            "referenceLocation": "TableSelectionChangeDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "brTableRowExpansionChange",
+                "name": "brTableRowExpansionChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
                 "docs": {
                     "tags": [{
-                            "name": "default",
-                            "text": "false"
+                            "name": "remarks",
+                            "text": "O `detail` utiliza `TableRowExpansionChangeDetail`."
                         }],
-                    "text": "Indica que as linhas est\u00E3o sendo atualizadas pelo consumidor.\nO componente mant\u00E9m o conte\u00FAdo anterior, aplica `aria-busy=\"true\"` e\nexibe o slot `loading` sobre os dados; transporte, erro e substitui\u00E7\u00E3o das\nlinhas ficam sob responsabilidade da aplica\u00E7\u00E3o.\nA prop pode ser alterada diretamente ou pelos m\u00E9todos `startLoading()` e\n`stopLoading()`."
+                    "text": "Emitido quando uma linha \u00E9 expandida ou recolhida."
                 },
-                "getter": false,
-                "setter": false,
-                "reflect": true,
-                "attribute": "loading",
-                "defaultValue": "false"
-            }
-        };
+                "complexType": {
+                    "original": "TableRowExpansionChangeDetail",
+                    "resolved": "{ row: HTMLBrTableRowElement; rowIndex: number; expanded: boolean; source: TableRowExpansionChangeSource; }",
+                    "references": {
+                        "TableRowExpansionChangeDetail": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableRowExpansionChangeDetail",
+                            "referenceLocation": "TableRowExpansionChangeDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "brTableSortChange",
+                "name": "brTableSortChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido sempre que o conjunto de crit\u00E9rios de ordena\u00E7\u00E3o muda."
+                },
+                "complexType": {
+                    "original": "TableSortChangeDetail",
+                    "resolved": "{ mode: TableSortMode; sorting: TableSortState[]; rows: HTMLBrTableRowElement[]; }",
+                    "references": {
+                        "TableSortChangeDetail": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableSortChangeDetail",
+                            "referenceLocation": "TableSortChangeDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "brTableSortRequest",
+                "name": "brTableSortRequest",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido antes de aplicar uma solicita\u00E7\u00E3o de ordena\u00E7\u00E3o; `preventDefault()` cancela a mudan\u00E7a local."
+                },
+                "complexType": {
+                    "original": "TableSortRequestDetail",
+                    "resolved": "{ mode: TableSortMode; columnIndex: number; currentSorting: TableSortState[]; nextSorting: TableSortState[]; }",
+                    "references": {
+                        "TableSortRequestDetail": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableSortRequestDetail",
+                            "referenceLocation": "TableSortRequestDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "brTablePageChange",
+                "name": "brTablePageChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido quando o consumidor solicita outra p\u00E1gina pela pagina\u00E7\u00E3o do rodap\u00E9."
+                },
+                "complexType": {
+                    "original": "TablePageChangeDetail",
+                    "resolved": "{ page: number; }",
+                    "references": {
+                        "TablePageChangeDetail": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TablePageChangeDetail",
+                            "referenceLocation": "TablePageChangeDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "brTablePageSizeChange",
+                "name": "brTablePageSizeChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Emitido quando o consumidor solicita outra quantidade de itens por p\u00E1gina; atualize `visibleRows` ao tratar."
+                },
+                "complexType": {
+                    "original": "TablePageSizeChangeDetail",
+                    "resolved": "{ pageSize: number; }",
+                    "references": {
+                        "TablePageSizeChangeDetail": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TablePageSizeChangeDetail",
+                            "referenceLocation": "TablePageSizeChangeDetail"
+                        }
+                    }
+                }
+            }, {
+                "method": "brTableSearch",
+                "name": "brTableSearch",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Evento customizado originado em `br-table-bar` e propagado pela tabela,\nsem reemiss\u00E3o. Envia `{ term }` por Enter ou bot\u00E3o e `{ term: '' }` ao fechar.\nDigita\u00E7\u00E3o, inicializa\u00E7\u00E3o e altera\u00E7\u00F5es program\u00E1ticas n\u00E3o emitem o evento.\nPropaga, atravessa Shadow DOM e \u00E9 cancel\u00E1vel."
+                },
+                "complexType": {
+                    "original": "TableSearchDetail",
+                    "resolved": "{ term: string; }",
+                    "references": {
+                        "TableSearchDetail": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableSearchDetail",
+                            "referenceLocation": "TableSearchDetail"
+                        }
+                    }
+                }
+            }];
     }
     static get methods() {
         return {
@@ -1040,7 +2651,7 @@ export class Table {
                     "return": "Promise<void>"
                 },
                 "docs": {
-                    "text": "Inicia o estado de carregamento da tabela.",
+                    "text": "Inicia o estado visual de carregamento sem alterar os dados da tabela.",
                     "tags": []
                 }
             },
@@ -1057,7 +2668,189 @@ export class Table {
                     "return": "Promise<void>"
                 },
                 "docs": {
-                    "text": "Interrompe o estado de carregamento da tabela.",
+                    "text": "Interrompe o estado visual de carregamento sem alterar os dados da tabela.",
+                    "tags": []
+                }
+            },
+            "setData": {
+                "complexType": {
+                    "signature": "(data: TableData) => Promise<void>",
+                    "parameters": [{
+                            "name": "data",
+                            "type": "{ headerRows?: TableColumnData[][]; columns: TableColumnData[]; rows: TableRowData[]; globalActions?: TableActionData[]; contextualActions?: TableActionData[]; }",
+                            "docs": "Colunas, linhas e a\u00E7\u00F5es que formar\u00E3o a tabela."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "TableData": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableData",
+                            "referenceLocation": "TableData"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Substitui os dados l\u00F3gicos da tabela e reconstr\u00F3i seus subcomponentes.",
+                    "tags": [{
+                            "name": "remarks",
+                            "text": "Esta \u00E9 a mesma estrutura interna utilizada ap\u00F3s a ingest\u00E3o dos slots."
+                        }, {
+                            "name": "param",
+                            "text": "data Colunas, linhas e a\u00E7\u00F5es que formar\u00E3o a tabela."
+                        }, {
+                            "name": "example",
+                            "text": "```js\nconst table = document.querySelector('br-table');\nawait table.setData({\n  columns: [],\n  headerRows: [\n    [{ content: 'Unidade', rowSpan: 2 }, { content: 'Equipe', colSpan: 2 }],\n    [{ content: 'Nome', sortable: true }, { content: 'Cargo', sortable: true }],\n  ],\n  rows: [\n    { rowGroup: 'brasilia', cells: [\n      { content: 'Bras\u00EDlia', rowSpan: 2, rowHeader: true },\n      { content: 'Ana' }, { content: 'Analista' },\n    ] },\n    { rowGroup: 'brasilia', cells: [{ content: 'Carlos' }, { content: 'T\u00E9cnico' }] },\n  ],\n});\n```"
+                        }]
+                }
+            },
+            "getSelectedRows": {
+                "complexType": {
+                    "signature": "() => Promise<HTMLBrTableRowElement[]>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "HTMLBrTableRowElement": {
+                            "location": "global",
+                            "id": "global::HTMLBrTableRowElement"
+                        }
+                    },
+                    "return": "Promise<HTMLBrTableRowElement[]>"
+                },
+                "docs": {
+                    "text": "Retorna as linhas atualmente selecionadas.",
+                    "tags": [{
+                            "name": "returns",
+                            "text": "Elementos `br-table-row` selecionados no corpo."
+                        }]
+                }
+            },
+            "selectAllRows": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Seleciona todas as linhas eleg\u00EDveis.",
+                    "tags": []
+                }
+            },
+            "clearSelection": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Limpa a sele\u00E7\u00E3o de todas as linhas eleg\u00EDveis.",
+                    "tags": []
+                }
+            },
+            "getSorting": {
+                "complexType": {
+                    "signature": "() => Promise<TableSortState[]>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "TableSortState": {
+                            "location": "import",
+                            "path": "./table.types",
+                            "id": "src/components/table/table.types.ts::TableSortState",
+                            "referenceLocation": "TableSortState"
+                        }
+                    },
+                    "return": "Promise<TableSortState[]>"
+                },
+                "docs": {
+                    "text": "Retorna o estado atual de ordena\u00E7\u00E3o aplicado na tabela.",
+                    "tags": []
+                }
+            },
+            "expandRow": {
+                "complexType": {
+                    "signature": "(rowIndex: number) => Promise<void>",
+                    "parameters": [{
+                            "name": "rowIndex",
+                            "type": "number",
+                            "docs": "\u00CDndice da linha, come\u00E7ando em zero."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Expande uma linha eleg\u00EDvel do corpo.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "rowIndex \u00CDndice da linha, come\u00E7ando em zero."
+                        }]
+                }
+            },
+            "collapseRow": {
+                "complexType": {
+                    "signature": "(rowIndex: number) => Promise<void>",
+                    "parameters": [{
+                            "name": "rowIndex",
+                            "type": "number",
+                            "docs": "\u00CDndice da linha, come\u00E7ando em zero."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Recolhe uma linha do corpo.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "rowIndex \u00CDndice da linha, come\u00E7ando em zero."
+                        }]
+                }
+            },
+            "collapseAllRows": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Recolhe todas as linhas que estiverem expandidas.",
                     "tags": []
                 }
             }
@@ -1071,6 +2864,18 @@ export class Table {
             }, {
                 "propName": "density",
                 "methodName": "handleDensityChange"
+            }, {
+                "propName": "visibleRows",
+                "methodName": "handleVisibleRowsChange"
+            }, {
+                "propName": "hasPagination",
+                "methodName": "handleHasPaginationChange"
+            }, {
+                "propName": "currentPage",
+                "methodName": "handleCurrentPageChange"
+            }, {
+                "propName": "pageSize",
+                "methodName": "handlePageSizeChange"
             }, {
                 "propName": "hasColumnDivider",
                 "methodName": "handleDividerChange"
@@ -1096,11 +2901,80 @@ export class Table {
                 "propName": "overflow",
                 "methodName": "handleOverflowChange"
             }, {
-                "propName": "tooltipState",
-                "methodName": "handleTooltipPropsChange"
+                "propName": "virtualExpandedContentHeight",
+                "methodName": "handleVirtualExpandedContentHeightChange"
+            }, {
+                "propName": "hasRowSelection",
+                "methodName": "handleRowSelectionChange"
+            }, {
+                "propName": "hasRowHover",
+                "methodName": "handleRowHoverChange"
+            }, {
+                "propName": "hasRowExpansion",
+                "methodName": "handleRowExpansionChange"
+            }, {
+                "propName": "sortMode",
+                "methodName": "handleSortModeChange"
+            }, {
+                "propName": "sortStrategy",
+                "methodName": "handleSortStrategyChange"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "brInternalTableHeaderHeight",
+                "method": "handleHeaderHeight",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "brDropdownOpenChange",
+                "method": "handleDropdownOpenChange",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "brInternalTableCellFocus",
+                "method": "handleCellFocusRegistration",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "focusin",
+                "method": "handleGridFocusIn",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "focusout",
+                "method": "handleGridFocusOut",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "keydown",
+                "method": "handleGridKeyDown",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "brInternalTableSortRequest",
+                "method": "handleSortRequest",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "checkedChange",
+                "method": "handleSelectionCheckboxChange",
+                "target": undefined,
+                "capture": false,
+                "passive": false
             }, {
-                "propName": "tooltipMode",
-                "methodName": "handleTooltipPropsChange"
+                "name": "brTableActionClick",
+                "method": "handleActionClick",
+                "target": undefined,
+                "capture": false,
+                "passive": false
             }];
     }
 }