@govbr-ds/webcomponents 2.0.0-next.56 → 2.0.0-next.58

package/dist/types/components/menu/menu-logo/menu-logo.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Para uma descrição detalhada, consulte a [documentação do GovBR-DS](https://www.gov.br/ds/components/menu-logo?tab=designer).
+ *
+ * @slot default - Conteúdo opcional que substitui a imagem padrão
+ */
+export declare class MenuLogo {
+    /**
+     * Referência ao elemento host do componente.
+     * Utilize esta propriedade para acessar e manipular o elemento do DOM associado ao componente.
+     */
+    el: HTMLBrMenuLogoElement;
+    /**
+     * ID personalizado para o elemento, útil para acessibilidade e identificação única.
+     * Se não for fornecido, um ID único será gerado automaticamente.
+     */
+    readonly customId: string;
+    /**
+     * URL da imagem
+     */
+    src: string;
+    /**
+     * Texto alternativo da imagem
+     */
+    alt?: string;
+    /**
+     * Largura da imagem (com unidade, ex: '100px', '50%')
+     */
+    width?: string;
+    /**
+     * Altura da imagem (com unidade, ex: '80px', 'auto')
+     */
+    height?: string;
+    /**
+     * Estado para controlar se a imagem falhou ao carregar
+     */
+    hasError: boolean;
+    /**
+     * Manipula erros no carregamento da imagem
+     */
+    private handleError;
+    private handleLoad;
+    render(): any;
+}

package/dist/types/components/menu/menu-social/menu-social.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+/**
+ * Menu Social - Representa cada link para acesso a redes sociais.
+ *
+ * @slot icon - Slot para inserção de componente de ícone personalizado
+ */
+export declare class MenuSocial {
+    /**
+     * Referência ao elemento host do componente.
+     * Utilize esta propriedade para acessar e manipular o elemento do DOM associado ao componente.
+     */
+    el: HTMLBrMenuSocialElement;
+    /**
+     * Identificador único.
+     * Caso não seja fornecido, um ID gerado automaticamente será usado.
+     */
+    readonly customId: string;
+    /**
+     * URL do link
+     */
+    url: string;
+    /**
+     * Rótulo para acessibilidade
+     */
+    ariaLabel: string;
+    /**
+     * Ícone da rede social
+     * */
+    readonly icon: string;
+    /**
+     * Evento emitido quando o link de rede social é clicado
+     */
+    brSocialClick: EventEmitter<void>;
+    private handleClick;
+    render(): any;
+}

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

@@ -0,0 +1,260 @@
+/**
+ * Componente raiz do Menu responsivo do Design System. Ele organiza navegação hierárquica, rodapé contextual e
+ * comportamentos como push/contextual, integrando `br-menu-list`, `br-menu-item` e subcomponentes auxiliares.
+ *
+ * @example
+ * ```html
+ * <br-menu push>
+ *   <div slot="header">Minha aplicação</div>
+ *   <br-menu-list label="Administração">
+ *     <br-menu-item href="/dashboard" active>Dashboard</br-menu-item>
+ *     <br-menu-item href="/usuarios">Usuários</br-menu-item>
+ *   </br-menu-list>
+ * </br-menu>
+ * ```
+ *
+ * @slot default - Conteúdo principal do menu (menu-list e menu-item)
+ * @slot header - Cabeçalho do menu (exibido apenas em modo não-contextual)
+ * @slot logo - Logotipos de parceiros no rodapé
+ * @slot link - Links externos no rodapé (use br-menu-link)
+ * @slot social - Ícones de redes sociais no rodapé
+ * @slot info - Informações adicionais no rodapé
+ *
+ * @part footer - O contêiner principal do rodapé do menu, que agrupa as seções de logos, links, redes sociais e informações.
+ * @part logo - A área específica para exibir os logotipos de parceiros ou relacionados, dentro do rodapé.
+ * @part link - A seção destinada a links úteis ou de navegação secundária no rodapé do menu.
+ * @part social - O contêiner para os ícones de redes sociais.
+ * @part info - Uma área para informações adicionais, como textos de licença ou direitos autorais.
+ */
+export declare class Menu {
+    /**
+     * Referência ao elemento host do componente.
+     * Utilize esta propriedade para acessar e manipular o elemento do DOM associado ao componente.
+     */
+    private el;
+    /**
+     * Classes CSS para definir breakpoints responsivos do menu.
+     * Utilize esta propriedade para controlar a largura do menu em diferentes tamanhos de tela.
+     * @default 'col-sm-4 col-lg-3'
+     */
+    breakpoints: string;
+    /**
+     * Define se o menu deve usar comportamento push (sempre visível em telas maiores).
+     * Quando ativado, o menu permanece fixo na lateral e empurra o conteúdo principal.
+     * @default false
+     */
+    push: boolean;
+    /**
+     * Define se o menu deve usar comportamento contextual (aparece na parte inferior).
+     * Quando ativado, o menu é posicionado na parte inferior da tela em dispositivos móveis.
+     * @default false
+     */
+    contextual: boolean;
+    /**
+     * Define a densidade dos itens do menu, alterando o espaçamento interno.
+     * - `small` (densidade alta): itens mais compactos
+     * - `medium` (padrão): equilíbrio entre economia de espaço e separação
+     * - `large` (densidade baixa): maior espaçamento (recomendado em touch)
+     * @default 'medium'
+     */
+    density: 'large' | 'medium' | 'small';
+    /**
+     * Título da seção de redes sociais exibida no rodapé do menu.
+     * Utilize esta propriedade para personalizar o texto que aparece acima dos ícones sociais.
+     * @default 'Redes Sociais'
+     */
+    socialTitle: string;
+    /**
+     * Rótulo do botão trigger do menu contextual.
+     * Exibido apenas em modo contextual e em telas menores (mobile).
+     * @default 'Menu Contextual'
+     */
+    contextualLabel: string;
+    active: boolean;
+    inSubmenu: boolean;
+    currentLevel: number;
+    expandedDropMenus: {
+        [key: string]: boolean;
+    };
+    navigationStack: Array<{
+        element: HTMLElement;
+        label: string;
+        id: string;
+    }>;
+    private previouslyFocusedElement;
+    private rafIds;
+    componentDidLoad(): void;
+    /**
+     * Método do ciclo de vida do componente.
+     * Este método é chamado quando o componente é desconectado do DOM.
+     * Realiza limpeza de recursos para evitar vazamento de memória.
+     */
+    disconnectedCallback(): void;
+    private ensureSingleActiveItem;
+    handleMenuItemClick(ev: Event): void;
+    handleKeyDown(ev: KeyboardEvent): void;
+    handleNavigateToSubmenu(ev: CustomEvent<{
+        element: HTMLElement;
+        label: string;
+    }>): void;
+    handleFolderToggled(ev: CustomEvent<boolean>): void;
+    handleMenuHeaderClose(): void;
+    /**
+     * Alterna o estado expandido de um menu drop-down no modo acordeão.
+     *
+     * Este método recebe o identificador único (`itemId`) de um menu do tipo drop-down (nível 0)
+     * e inverte o seu estado de expansão dentro do objeto `expandedDropMenus`.
+     *
+     * Se o menu estiver atualmente expandido, ele será recolhido; se estiver recolhido, será expandido.
+     * O spread operator (`...this.expandedDropMenus`) garante que os estados dos outros menus sejam preservados.
+     *
+     * @param itemId - Identificador único do menu drop-down a ser alternado.
+     */
+    private toggleDropMenu;
+    /**
+     * Recolhe todos os folders do nível 0, exceto o especificado.
+     * Garante que apenas um folder possa estar expandido por vez no comportamento acordeão.
+     *
+     * @param activeItemId - ID do folder que deve permanecer expandido
+     */
+    private collapseOtherFolders;
+    /**
+     * Navega para um nível específico do menu (drill-down).
+     *
+     * Este método é chamado quando o usuário interage com um item de menu de nível 2 ou superior,
+     * ou seja, quando o comportamento esperado é de drill-down (aprofundamento em submenus).
+     *
+     * Funcionamento:
+     * 1. Adiciona o item atual à pilha de navegação (`navigationStack`), permitindo que o usuário volte para níveis anteriores.
+     * 2. Obtém o nível do menu a partir do atributo `menu-level` do elemento clicado.
+     * 3. Atualiza o estado `currentLevel` para refletir o novo nível de profundidade (sempre um nível abaixo do atual).
+     * 4. Define `inSubmenu` como `true`, indicando que o usuário está navegando em um submenu.
+     * 5. Oculta todos os itens do menu, exceto o submenu selecionado, para garantir foco e clareza na navegação.
+     * 6. Marca o elemento ativo como "drill active" para controle visual e de acessibilidade.
+     *
+     * @param item - Objeto contendo o elemento do menu, seu rótulo e identificador único.
+     */
+    private navigateToLevel;
+    private focusFirstChildOfList;
+    private toggleMenu;
+    private closeMenu;
+    private resetNavigation;
+    private isVisibleElement;
+    private getTopLevelTargets;
+    /**
+     * Obtém todos os elementos navegáveis visíveis no menu, incluindo itens dentro de agrupamentos expandidos.
+     * Utilizado para navegação global por setas no modo contextual.
+     */
+    private getAllVisibleTargets;
+    /**
+     * Coleta recursivamente todos os targets visíveis de um elemento e seus descendentes.
+     * Respeita o estado expandido/recolhido dos agrupamentos.
+     */
+    private collectVisibleTargetsFrom;
+    /**
+     * Obtém targets com escopo limitado ao menu-list mais próximo (usado em drill-down).
+     */
+    private getScopedTargets;
+    private isNodeWithinHost;
+    private findClosestMenuListFrom;
+    private getTargetsForMenuList;
+    private focusFirstVisibleTarget;
+    /**
+     * Coleta recursivamente os elementos focáveis no modo drill-down.
+     * Respeita a ordem do DOM e a hierarquia dos elementos.
+     * Apenas coleta elementos que não têm o atributo 'hidden'.
+     */
+    private collectDrillDownTargets;
+    /**
+     * Obtém todos os elementos focáveis dentro do menu que estão visíveis.
+     * Inclui botões, links e outros elementos interativos.
+     * No modo contextual, inclui itens dentro de agrupamentos expandidos.
+     */
+    private getFocusableElements;
+    private getDeepActiveElement;
+    /**
+     * Oculta todos os elementos do menu, exceto o elemento ativo e sua cadeia de ancestrais,
+     * garantindo que apenas o submenu relevante esteja visível durante a navegação drill-down.
+     *
+     * Funcionamento detalhado:
+     * 1. Oculta todos os elementos <br-menu-list> e <br-menu-item> do menu, aplicando o atributo 'hidden'.
+     *    Isso garante que nada além do caminho de navegação atual fique visível.
+     * 2. Remove o atributo 'drill-ancestor' de quaisquer listas marcadas anteriormente, limpando o estado visual.
+     * 3. Remove o atributo 'hidden' do elemento ativo (o submenu ou item selecionado), tornando-o visível.
+     * 4. Percorre a cadeia de ancestrais do elemento ativo:
+     *    - Para cada ancestral do tipo <br-menu-list> ou <br-menu-item>, remove o 'hidden' para garantir visibilidade.
+     *    - Para ancestrais <br-menu-list> (exceto o próprio ativo), adiciona o atributo 'drill-ancestor' para permitir
+     *      estilização diferenciada (por exemplo, ocultar cabeçalhos mas manter o conteúdo visível).
+     *    - Interrompe o loop ao chegar no elemento host do componente.
+     * 5. Exibe todos os filhos diretos do elemento ativo que sejam <br-menu-list> ou <br-menu-item>,
+     *    removendo o 'hidden' para mostrar as opções do submenu.
+     * 6. Exibe também filhos que estejam dentro de um <ul> (estrutura comum em subníveis),
+     *    garantindo que todos os itens relevantes do submenu estejam visíveis.
+     *
+     * Este método é fundamental para a experiência de navegação drill-down, pois controla
+     * exatamente quais partes do menu são exibidas ao usuário em cada etapa da navegação.
+     *
+     * @param activeElement O elemento <br-menu-list> ou <br-menu-item> que representa o submenu/item atualmente ativo.
+     */
+    private hideAllExcept;
+    /**
+     * Exibe todos os itens e listas do menu, removendo o atributo 'hidden' de cada um.
+     *
+     * Esta função é utilizada para restaurar a visualização completa do menu,
+     * normalmente após uma navegação drill-down ou ao retornar ao nível raiz.
+     *
+     * O método percorre todos os elementos <br-menu-list> e <br-menu-item> dentro do componente
+     * e garante que estejam visíveis, removendo o atributo 'hidden' que pode ter sido
+     * adicionado durante a navegação entre submenus.
+     */
+    private showAllMenuItems;
+    /**
+     * Marca ou desmarca um elemento <br-menu-list> como ativo no contexto de navegação drill-down.
+     *
+     * Quando 'active' é true, adiciona o atributo 'drill-active' ao elemento, indicando que
+     * ele está no foco da navegação. Quando 'active' é false, remove esse atributo.
+     *
+     * Esse atributo pode ser utilizado para aplicar estilos visuais ou lógica condicional
+     * durante a navegação entre níveis do menu.
+     *
+     * @param element Elemento <br-menu-list> a ser marcado/desmarcado
+     * @param active Boolean indicando se o elemento deve ser marcado como ativo
+     */
+    private setDrillActive;
+    /**
+     * Remove todos os marcadores de navegação drill-down do menu.
+     *
+     * Esta função percorre todos os elementos <br-menu-list> que possuem os atributos
+     * 'drill-active' ou 'drill-ancestor' e remove esses atributos. Isso é necessário
+     * para garantir que, ao retornar ao nível raiz ou reiniciar a navegação, nenhum
+     * marcador visual ou lógico de navegação anterior permaneça ativo.
+     */
+    private clearAllDrillMarkers;
+    /**
+     * Realiza a navegação de retorno (voltar) em menus do tipo drill-down.
+     *
+     * Esta função é chamada quando o usuário deseja voltar um nível na navegação do menu.
+     * Ela utiliza uma pilha de navegação (navigationStack) para controlar o histórico de navegação.
+     *
+     * - Se houver elementos na pilha, remove o elemento do topo (nível atual) e desmarca como ativo.
+     * - Se, após a remoção, a pilha estiver vazia, significa que o usuário retornou ao nível raiz:
+     *   - Restaura o estado inicial do menu, mostrando todos os itens e limpando marcadores de navegação.
+     * - Caso contrário, ativa o elemento do nível anterior e oculta os demais, mantendo o contexto do drill-down.
+     */
+    private goBack;
+    private handleToggleMenu;
+    private handleGoBack;
+    private handleCloseMenu;
+    /**
+     * Verifica se um slot específico possui conteúdo.
+     */
+    private hasSlotContent;
+    private getEffectiveBreakpoints;
+    private getCssClassMap;
+    /**
+     * Retorna as classes CSS para o painel do menu.
+     * Aplica breakpoints apenas quando o menu NÃO está no modo push ou contextual.
+     */
+    private getMenuPanelClasses;
+    render(): any;
+}

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

@@ -87,7 +87,13 @@ export declare class Select {
         value: string;
         selected?: boolean;
     }[];
+    filteredOptions: {
+        label: string;
+        value: string;
+        selected?: boolean;
+    }[];
     inputValue: string;
+    searchTerm: string;
     /** Valor selecionado (string para single, string[] para multiple) */
     value?: string | string[];
     selectedValue?: string | string[];
@@ -126,6 +132,8 @@ export declare class Select {
     private closeSelect;
     private handleSelection;
     private updateSelectedOptions;
+    private normalizeText;
+    private getFilteredOptions;
     private getStringValue;
     private emitSelectedOptions;
     private updateSelectedAllState;
@@ -141,6 +149,23 @@ export declare class Select {
      * Inverte o valor da prop `isOpen`
      */
     toggleOpen(): Promise<void>;
+    /**
+     * Limpa todas as opções selecionadas.
+     */
+    clear(): Promise<void>;
+    /**
+     * Retorna o valor selecionado.
+     * @returns {Promise<string | string[]>} O valor atual.
+     */
+    getValue(): Promise<string | string[]>;
+    /**
+     * Define o valor do componente.
+     * @param {string | string[]} newValue O novo valor a ser definido.
+     */
+    setValue(newValue: string | string[]): Promise<void>;
     private getCssClassMap;
+    private handleSearchInput;
+    private handleSearchFocus;
+    private handleSearchBlur;
     render(): any;
 }

package/dist/types/components/skip-link/skip-link-item/skip-link-item.d.ts

@@ -0,0 +1,111 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+/**
+ * Item individual do componente Skip Link.
+ * Representa um link de navegação rápida para uma seção específica da página.
+ * Permite navegação por atalhos de teclado usando Alt+[keyNumber].
+ *
+ * @slot default - Conteúdo do item (texto do link).
+ * @slot tag - Slot opcional para personalizar a tag numérica que exibe o atalho de teclado. Por padrão, a tag é criada automaticamente com o valor de `key-number`.
+ *
+ * @example
+ * ```html
+ * <br-skiplink-item target="#main-content" key-number="1">
+ *   Ir para o conteúdo principal
+ * </br-skiplink-item>
+ * ```
+ *
+ */
+export declare class SkipLinkItem {
+    /**
+     * Referência ao elemento host do componente.
+     * Utilize esta propriedade para acessar e manipular o elemento do DOM associado ao componente.
+     */
+    el: HTMLBrSkiplinkItemElement;
+    elementInternals: ElementInternals;
+    /**
+     * ID do elemento de destino ou seletor CSS.
+     * Este é o elemento para o qual o usuário será levado ao ativar este item.
+     */
+    readonly target: string;
+    /**
+     * Número da tecla para acesso rápido.
+     * Permite que o usuário ative este item pressionando Alt+[keyNumber].
+     * Aceita valores de 1 a 9.
+     * Esta propriedade implementa uma alternativa ao accessKey nativa,
+     * fornecendo um atalho de teclado consistente e acessível.
+     */
+    readonly keyNumber?: number;
+    /**
+     * ID personalizado.
+     * Caso não seja fornecido, um ID gerado automaticamente será usado.
+     */
+    readonly customId: string;
+    /**
+     * Controla a visibilidade da tag numérica.
+     * Quando `true`, a tag numérica não será exibida, mesmo que `keyNumber` esteja definido.
+     * O atalho de teclado continua funcionando, apenas a indicação visual é ocultada.
+     */
+    readonly hideTag: boolean;
+    /**
+     * Estado interno que armazena o índice do item (1, 2, 3...).
+     * Definido automaticamente pelo componente pai.
+     */
+    private itemIndex;
+    /**
+     * Estado interno que armazena o total de itens.
+     * Definido automaticamente pelo componente pai.
+     */
+    private itemTotal;
+    /**
+     * MutationObserver para monitorar mudanças nos atributos de contagem.
+     * Observa quando o componente pai define data-item-index e data-item-total.
+     */
+    private mutationObserver;
+    /**
+     * Evento emitido quando o item é clicado/ativado.
+     * O evento contém informações sobre o item e o target.
+     */
+    brSkiplinkItemClick: EventEmitter<{
+        itemId: string;
+        target: string;
+    }>;
+    /**
+     * Evento emitido quando o item recebe foco.
+     */
+    brSkiplinkItemFocus: EventEmitter<{
+        itemId: string;
+    }>;
+    /**
+     * Move o foco para este item.
+     */
+    itemFocus(): Promise<void>;
+    /**
+     * Navega para o target definido.
+     * Move o foco para o elemento alvo e ajusta a rolagem da página se necessário.
+     */
+    navigateToTarget(): Promise<void>;
+    /**
+     * Listener para cliques no item.
+     */
+    handleClick(_event: MouseEvent): void;
+    /**
+     * Listener para teclas Enter, Space e atalho Alt+[keyNumber].
+     */
+    handleKeyDown(event: KeyboardEvent): void;
+    /**
+     * Listener para foco no item.
+     */
+    handleFocus(): void;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    /**
+     * Atualiza a contagem de itens lendo os atributos definidos pelo componente pai.
+     */
+    private updateItemCount;
+    /**
+     * Retorna a string de contagem no formato (X/Y) se disponível.
+     */
+    private getItemCountText;
+    render(): any;
+}

package/dist/types/components/skip-link/skip-link.d.ts

@@ -0,0 +1,173 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * O componente Skip Link consiste em uma lista de itens que auxiliam os usuários a navegarem
+ * por uma página com o auxílio do teclado, sendo extremamente útil para pessoas que dependem
+ * de leitores de tela ou navegação via teclado.
+ *
+ * Este componente implementa atalhos de teclado para acessibilidade, permitindo que o usuário
+ * acesse rapidamente áreas importantes da página utilizando Alt+[número]. Os números das teclas
+ * são definidos na propriedade `key-number` de cada item e exibidos visualmente na interface.
+ *
+ * Para uma descrição detalhada, consulte a [documentação do GovBR-DS](https://www.gov.br/ds/components/skip-link?tab=designer).
+ *
+ * @slot default - Slot padrão para inserir elementos `<br-skiplink-item>`.
+ *
+ * @part container - Container principal do skiplink.
+ *
+ * @example
+ * ```html
+ * <br-skip-link>
+ *   <br-skiplink-item target="#main-content" key-number="1">
+ *     Ir para o conteúdo principal
+ *   </br-skiplink-item>
+ *   <br-skiplink-item target="#menu" key-number="2">
+ *     Ir para o menu
+ *   </br-skiplink-item>
+ *   <br-skiplink-item target="#search" key-number="3">
+ *     Ir para a busca
+ *   </br-skiplink-item>
+ * </br-skip-link>
+ * ```
+ * Neste exemplo, o componente exibirá automaticamente as tags com os números 1, 2 e 3
+ * ao lado dos textos. O usuário pode usar Alt+1 para ir ao conteúdo principal,
+ * Alt+2 para ir ao menu, e Alt+3 para ir à busca.
+ */
+export declare class SkipLink {
+    /**
+     * Referência ao elemento host do componente.
+     * Utilize esta propriedade para acessar e manipular o elemento do DOM associado ao componente.
+     */
+    el: HTMLBrSkipLinkElement;
+    elementInternals: ElementInternals;
+    /**
+     * Identificador único.
+     * Caso não seja fornecido, um ID gerado automaticamente será usado.
+     */
+    readonly customId: string;
+    /**
+     * Define se o skip link apresenta um ou múltiplos itens visíveis.
+     * - 'simple': Exibe apenas um item por vez.
+     * - 'compound': Exibe uma lista com múltiplos itens.
+     */
+    readonly variant: 'simple' | 'compound';
+    /**
+     * Define a posição do skip link na tela.
+     * - 'top-left': Posicionado no canto superior esquerdo.
+     * - 'top-center': Posicionado no centro superior.
+     * - 'top-right': Posicionado no canto superior direito.
+     */
+    readonly position: 'top-left' | 'top-center' | 'top-right';
+    /**
+     * Define o z-index do componente.
+     * Controla a ordem de empilhamento do componente na página.
+     */
+    readonly zIndex: number | null;
+    /**
+     * Exibe a contagem de itens no formato (1/4), (2/4), etc.
+     * Quando `true`, cada item mostrará sua posição relativa ao total de itens.
+     * Por padrão, é `true` para o modo simple e `false` para o modo compound.
+     */
+    readonly showItemCount?: boolean;
+    /**
+     * Estado interno que controla a visibilidade do componente.
+     */
+    private isVisible;
+    /**
+     * Define se o componente está em modo tela pequena
+     */
+    private isSmallScreen;
+    /**
+     * Define se o componente precisa mudar para modo simples por falta de espaço
+     */
+    private needsSimpleMode;
+    /**
+     * Largura do container pai
+     */
+    private containerWidth;
+    /**
+     * ResizeObserver para monitorar mudanças no tamanho do container
+     */
+    private resizeObserver;
+    /**
+     * Evento emitido quando um item do skiplink é ativado.
+     * O evento contém informações sobre o item acionado e o elemento target.
+     */
+    brSkiplinkNavigation: EventEmitter<{
+        itemId: string;
+        target: string;
+    }>;
+    /**
+     * Evento emitido quando o skiplink se torna visível.
+     */
+    brDidShow: EventEmitter<void>;
+    /**
+     * Evento emitido quando o skiplink se torna oculto.
+     */
+    brDidHide: EventEmitter<void>;
+    updateStyles(): void;
+    /**
+     * Observa mudanças nos estados que afetam o modo efetivo (simple/compound)
+     * e atualiza as contagens dos itens quando necessário.
+     */
+    watchModeChanges(): void;
+    /**
+     * Listener para eventos de navegação dos itens filhos.
+     */
+    handleItemNavigation(event: CustomEvent<{
+        itemId: string;
+        target: string;
+    }>): void;
+    /**
+     * Listener para evento de foco no componente.
+     */
+    handleFocusIn(): void;
+    /**
+     * Listener para evento de perda de foco no componente.
+     */
+    handleFocusOut(event: FocusEvent): void;
+    /**
+     * Listener para a tecla Escape.
+     */
+    handleKeyDown(event: KeyboardEvent): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    /**
+     * Manipulador global para atalhos de teclado Alt+[número].
+     */
+    private globalKeyHandler;
+    /**
+     * Calcula a largura total dos itens e atualiza os estados do componente
+     */
+    private updateContainerSize;
+    /**
+     * Calcula a largura total dos itens do skip-link e determina se deve usar modo simple ou compound.
+     */
+    private calculateItemsWidth;
+    /**
+     * Soma a largura de todos os itens do skip-link
+     */
+    private sumItemsWidth;
+    /**
+     * Calcula a largura disponível descontando margens e margem de segurança
+     */
+    private calculateAvailableWidth;
+    /**
+     * Atualiza os atributos de contagem nos itens filhos.
+     * Adiciona data-item-index e data-item-total em cada br-skiplink-item.
+     * A contagem é exibida quando o componente está em modo simple (incluindo modo responsivo).
+     */
+    private updateItemCounts;
+    /**
+     * Oculta o componente programaticamente.
+     */
+    hide(): Promise<void>;
+    /**
+     * Exibe o componente programaticamente.
+     */
+    show(): Promise<void>;
+    private getEffectivePosition;
+    private getCssClassMap;
+    render(): any;
+}

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

@@ -1,3 +1,4 @@
+import { EventEmitter } from '../../stencil-public-runtime';
 /**
  * Para uma descrição detalhada, consulte a [documentação do GovBR-DS](https://www.gov.br/ds/components/upload?tab=designer).
  *
@@ -63,6 +64,10 @@ export declare class Upload {
      */
     multiple: boolean;
     elementInternals: ElementInternals;
+    /**
+     * Evento emitido quando a lista de arquivos selecionados é alterada.
+     */
+    selectedFilesChange: EventEmitter<FileList>;
     private getCssClassMap;
     private handleRemoveFileSelection;
     private renderFilesUploaded;