import type { ColumnWidth, TableAlignment, TableDensity, TableDividerStyle, TableOverflow, TableTooltipMode, TableTooltipState } from './table-types';
/**
 * O `br-table` estrutura e exibe conjuntos de dados organizados em linhas e colunas.
 *
 * Estruture a tabela usando os subcomponentes `br-table-header`, `br-table-body`, `br-table-row` e `br-table-cell`. Para exibir um indicador de carregamento durante atualizações assíncronas, use a propriedade `loading`.
 *
 * ```html
 * <br-table>
 *   <br-table-header slot="header">
 *     <br-table-row>
 *       <br-table-header-cell>Nome</br-table-header-cell>
 *       <br-table-header-cell>Cargo</br-table-header-cell>
 *     </br-table-row>
 *   </br-table-header>
 *   <br-table-body slot="body">
 *     <br-table-row>
 *       <br-table-cell>Maria Silva</br-table-cell>
 *       <br-table-cell>Analista</br-table-cell>
 *     </br-table-row>
 *   </br-table-body>
 * </br-table>
 * ```
 *
 * ### Quando usar
 *
 * - Dados bidimensionais com cabeçalhos de coluna e necessidades de ordenação ou comparação.
 *
 * ### Quando evitar
 *
 * - Listas simples de itens lineares: use `br-list`.
 * - Agrupamento de informações de um único registro: use `br-card`.
 *
 * Consulte as [diretrizes de design 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 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.
 */
export declare class Table {
    /**
     * Referência ao elemento host do componente.
     * Utilize esta propriedade para acessar e manipular o elemento do DOM associado ao componente.
     *
     */
    el: HTMLBrTableElement;
    /**
     * Largura global aplicada a todas as colunas.
     *
     *  @remarks Valores aceitos:
     * - fill
     * - content
     * - ${number}px
     * - ${number}fr
     *
     * Observação:
     * - `columnWidth` não define o comportamento de `overflow`, mas pode interferir na sua percepção ao alterar o espaço disponível da coluna.
     * - `content` (`max-content`) tende a expandir a coluna e reduzir casos visíveis de truncagem.
     * - `fill` (`1fr`) tende a evidenciar truncagem quando o espaço horizontal é insuficiente.
     *
     * @default fill
     * @example
     * ```html
     * <br-table column-width="160px"></br-table>
     * ```
     */
    columnWidth?: ColumnWidth;
    /**
     * Define a densidade visual do componente.
     *
     * - `small`: Alta densidade (componente menor, mais compacto e com menos espaçamento).
     * - `medium`: Densidade intermediária, padrão recomendado para a maioria dos casos.
     * - `large`: Baixa densidade (componente maior, mais espaçamento e altura).
     *
     * Valores inválidos usam `medium`. Quando omitida, a densidade média é aplicada ao token.
     */
    density?: TableDensity;
    /**
     * Define o estilo visual dos divisores.
     *
     * @remarks Valores aceitos:
     * - solid
     * - dashed
     *
     * @default solid
     */
    dividerStyle?: TableDividerStyle;
    /**
     * Ativa divisores verticais entre colunas.
     *
     * @default false
     * @deprecated Use `columnDivider`.
     */
    hasColumnDivider?: boolean;
    /** Ativa divisores verticais. Quando informada, tem precedência sobre `hasColumnDivider`. */
    columnDivider?: boolean;
    /**
     * Ativa divisores horizontais entre linhas.
     *
     * @default false
     * @deprecated Use `rowDivider`.
     */
    hasRowDivider?: boolean;
    /** Ativa divisores horizontais. Quando informada, tem precedência sobre `hasRowDivider`. */
    rowDivider?: boolean;
    /**
     * Define o alinhamento horizontal do conteúdo das células.
     *
     * @remarks Valores aceitos:
     * - start
     * - center
     * - end
     *
     * @default start
     */
    horizontalAlignment?: TableAlignment;
    /**
     * Define o alinhamento vertical do conteúdo das células.
     *
     * @remarks Valores aceitos:
     * - start
     * - center
     * - end
     *
     * @default start
     */
    verticalAlignment?: TableAlignment;
    /**
     * Define o comportamento de overflow para as células.
     *
     * @remarks Valores aceitos:
     * - truncate
     * - wrap
     *
     * 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 wrap
     */
    overflow?: TableOverflow;
    /**
     * Define o estado semântico do tooltip nas células da tabela.
     *
     * @remarks Valores aceitos:
     * - info
     * - warning
     * - danger
     * - success
     *
     * @default info
     */
    tooltipState?: TableTooltipState;
    /**
     * Define o modo de resolução do tooltip nas células da tabela.
     *
     * @remarks Valores aceitos:
     * - inherit
     * - enabled
     * - disabled
     *
     * @default disabled (valor efetivo)
     */
    tooltipMode?: TableTooltipMode;
    private get effectiveDividerStyle();
    private get effectiveHorizontalAlignment();
    private get effectiveVerticalAlignment();
    private get effectiveOverflow();
    private get effectiveTooltipState();
    private get effectiveTooltipMode();
    /**
     * 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()`.
     * @default false
     */
    loading: boolean;
    private headers;
    private rows;
    private cells;
    private rowCells;
    private columnIndexes;
    private structureReady;
    private structureRefreshFrame;
    private readonly handleColumnWidthEvent;
    private readonly handleAlignmentEvent;
    private readonly handleOverflowEvent;
    /**
     * Reaplica a largura das colunas quando alterada.
     */
    protected handleTableColumnWidthChange(): void;
    /**
     * Reaplica o token de densidade quando alterado.
     */
    protected handleDensityChange(): void;
    /**
     * Atualiza os tokens de divisor quando qualquer propriedade relacionada é alterada.
     */
    protected handleDividerChange(): void;
    /**
     * Atualiza os tokens de alinhamento quando alterados.
     */
    protected handleAlignmentChange(): void;
    /**
     * Atualiza os tokens de overflow quando a propriedade é alterada.
     */
    protected handleOverflowChange(): void;
    protected handleTooltipPropsChange(): void;
    private validateTooltipProps;
    /**
     * 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.
     */
    componentDidLoad(): void;
    connectedCallback(): void;
    disconnectedCallback(): void;
    /** Inicia o estado de carregamento da tabela. */
    startLoading(): Promise<void>;
    /** Interrompe o estado de carregamento da tabela. */
    stopLoading(): Promise<void>;
    private generatedHeaderPrefix;
    /**
     * Marca a última linha e a última coluna para permitir estilização condicional.
     */
    private refreshStructure;
    private scheduleStructureRefresh;
    /**
     * Atualiza a largura das colunas com base nos cabeçalhos.
     * @returns void
     */
    private 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.
     */
    private buildGridTemplate;
    /**
     * Resolve a largura de uma coluna específica com base no cabeçalho e na largura global da tabela.
     */
    private resolveTableColumnWidth;
    /**
     * 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.
     */
    private resolveColumnWidth;
    /**
     * 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
     */
    private resolveWidthToken;
    /**
     * Aplica o template de grid à tabela definindo a propriedade CSS customizada correspondente.
     * @param template O template de grid a ser aplicado.
     */
    private applyGridTemplate;
    /**
     * Atualiza o alinhamento de todas as células da tabela com base nos tokens de alinhamento.
     */
    private updateAllCellAlignments;
    /**
     * Atualiza o alinhamento de uma célula específica com base nos tokens de alinhamento.
     * @param cell A célula a ser atualizada.
     */
    private updateAlignmentForCell;
    /**
     * 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.
     */
    private resolveHorizontalAlignmentForCell;
    /**
     * 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.
     */
    private resolveVerticalAlignmentForCell;
    /**
     * 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.
     */
    private resolveAlignmentToken;
    /**
     * 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.
     */
    private getColumnAlignment;
    /**
     * 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.
     */
    private getColumnIndex;
    /**
     * Constrói o template de grid para a tabela com base nos cabeçalhos.
     * @return Array de larguras de coluna resolvidas.
     */
    private getHeaderCells;
    /**
     * 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.
     */
    private getAllCells;
    /**
     * Recalcula estrutura, tokens e metadados de acessibilidade quando há mudança de slots.
     */
    private handleStructureChange;
    /**
     * Aplica metadados ARIA para melhorar a navegação por leitores de tela.
     */
    private applyAriaMetadata;
    /**
     * 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.
     */
    private updateAllCellOverflow;
    private updateAlignmentForTarget;
    private updateOverflowForTarget;
    /**
     * 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.
     */
    private updateOverflowForCell;
    /**
     * 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.
     */
    private resolveOverflowForCell;
    /**
     * 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.
     */
    private getColumnAttribute;
    /**
     * 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.
     */
    private getHeaderForCell;
    /**
     * Resolve e aplica o token de densidade.
     */
    private applyDensity;
    /**
     * Resolve e aplica os tokens relacionados aos divisores
     * (estilo e fatores de linha/coluna).
     */
    private applyDividers;
    /**
     * Retorna o mapa de classes base do componente.
     *
     * @returns Um objeto representando as classes CSS a serem aplicadas ao elemento da tabela.
     */
    private getTableCssClassMap;
    /**
     * Renderiza a estrutura interna da tabela (header e body).
     *
     * @returns JSX.Element representando o conteúdo da tabela, incluindo os slots para header e body.
     */
    private renderContent;
    /**
     * Renderiza o host do componente.
     *
     * @returns JSX.Element representando o elemento host do componente, contendo a estrutura da tabela.
     */
    render(): any;
}