import { ChangeDetectorRef, ElementRef, EventEmitter, NgZone } from '@angular/core';
import { Components } from '@govbr-ds/webcomponents';
import type { LoadingChangeDetail as IBrLoadingLoadingChangeDetail } from '@govbr-ds/webcomponents';
import type { LoadingCompleteDetail as IBrLoadingLoadingCompleteDetail } from '@govbr-ds/webcomponents';
import type { LoadingValueDetail as IBrLoadingLoadingValueDetail } from '@govbr-ds/webcomponents';
import type { LoadingIndeterminateStateDetail as IBrLoadingLoadingIndeterminateStateDetail } from '@govbr-ds/webcomponents';
import type { IUploadFile as IBrUploadIUploadFile } from '@govbr-ds/webcomponents';
import * as i0 from "@angular/core";
export declare class BrAvatar {
    protected z: NgZone;
    protected el: HTMLBrAvatarElement;
    /**
   * Ajusta a densidade, alterando o espaçamento interno para um visual mais compacto ou mais expandido. @default 'medium'
   */
    set density(_: Components.BrAvatar['density']);
    /**
   * Identificador único; gerado automaticamente quando omitido. @default Helpers.generateUniqueId('br-avatar')
   */
    set customId(_: Components.BrAvatar['customId']);
    /**
   * URL da imagem a ser exibida no avatar do tipo 'fotográfico'.
Deve ser uma URL válida que aponta para a imagem desejada.
   */
    set src(_: Components.BrAvatar['src']);
    /**
   * Texto alternativo (alt) associado à imagem do avatar. Essencial para acessibilidade.
Deve descrever de forma clara e concisa o conteúdo da imagem, por exemplo: "Foto de perfil de João Silva". @default 'Foto de perfil do usuário'
   */
    set alt(_: Components.BrAvatar['alt']);
    /**
   * Força a exibição do ícone padrão, sobrescreve outras opções (texto ou imagem).
Útil para manter consistência visual ou quando se deseja um avatar neutro independente do conteúdo disponível. @default false
   */
    set isIconic(_: Components.BrAvatar['isIconic']);
    /**
   * Conteúdo textual do avatar.
Apenas o primeiro caractere será exibido em maiúscula.
   */
    set text(_: Components.BrAvatar['text']);
    /**
   * Define se o avatar está desabilitado @default false
   */
    set disabled(_: Components.BrAvatar['disabled']);
    /**
   * Permite definir a cor de fundo do componente.
Aceita os seguintes formatos de cor:
- Cores nomeadas do CSS: 'red', 'blue', 'green', 'yellow', etc.
- Códigos hexadecimais: '#ff0000', '#00ff00', '#0000ff', etc.
- Valores RGB: 'rgb(255, 0, 0)', 'rgb(0, 255, 0)', etc.
- Valores RGBA: 'rgba(255, 0, 0, 0.5)', 'rgba(0, 255, 0, 0.8)', etc.
- Valores HSL: 'hsl(0, 100%, 50%)', 'hsl(120, 100%, 50%)', etc.
- Valores HSLA: 'hsla(0, 100%, 50%, 0.5)', 'hsla(240, 100%, 50%, 0.7)', etc.
Se não especificada, usa a cor padrão do tema. @default '#DBE8FB'
   */
    set bgColor(_: Components.BrAvatar['bgColor']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrAvatar, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrAvatar, "br-avatar", never, { "alt": { "alias": "alt"; "required": false; }; "bgColor": { "alias": "bgColor"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isIconic": { "alias": "isIconic"; "required": false; }; "src": { "alias": "src"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrAvatar extends Components.BrAvatar {
}
export declare class BrBreadcrumb {
    protected z: NgZone;
    protected el: HTMLBrBreadcrumbElement;
    /**
   * Identificador único; gerado automaticamente quando omitido. @default Helpers.generateUniqueId('br-breadcrumb')
   */
    set customId(_: Components.BrBreadcrumb['customId']);
    /**
   * Caso não seja fornecido, o valor padrão será /. @default '/'
   */
    set homeUrl(_: Components.BrBreadcrumb['homeUrl']);
    /**
   * Define o array de objetos que receberá os nomes e links do breadcrumb.
Define valor padrão do breadcrumb 'defaultCrumbs'.
   */
    set crumbs(_: Components.BrBreadcrumb['crumbs']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrBreadcrumb, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrBreadcrumb, "br-breadcrumb", never, { "crumbs": { "alias": "crumbs"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "homeUrl": { "alias": "homeUrl"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrBreadcrumb extends Components.BrBreadcrumb {
}
export declare class BrButton {
    protected z: NgZone;
    protected el: HTMLBrButtonElement;
    /**
   * Define se o botão usará um esquema de cores escuro.
   */
    set colorMode(_: Components.BrButton['colorMode']);
    /**
   * Identificador único; gerado automaticamente quando omitido. @default Helpers.generateUniqueId('br-button')
   */
    set customId(_: Components.BrButton['customId']);
    /**
   * Ajusta a densidade, alterando o espaçamento interno para um visual mais compacto ou mais expandido. @default 'medium'
   */
    set density(_: Components.BrButton['density']);
    /**
   * Desativa o botão, tornando-o não interativo. @default false
   */
    set disabled(_: Components.BrButton['disabled']);
    /**
   * Define a ênfase do botão, alterando sua aparência para criar hierarquia visual e destacar ações importantes.
   */
    set emphasis(_: Components.BrButton['emphasis']);
    /**
   * Indica se o botão está no estado ativo.
Se definido como verdadeiro, o botão será exibido como ativo. @default false
   */
    set isActive(_: Components.BrButton['isActive']);
    /**
   * Aplica o estado de "progresso" ao botão.
O botão exibirá um indicador de carregamento ou progresso. @default false
   */
    set isLoading(_: Components.BrButton['isLoading']);
    /**
   * Define o formato do botão.
   */
    set shape(_: Components.BrButton['shape']);
    /**
   * Define o tipo de botão, especificando seu comportamento padrão.
   */
    set type(_: Components.BrButton['type']);
    /**
   * Define o valor inicial do botão em um formulário.
   */
    set value(_: Components.BrButton['value']);
    /**
   * Define o índice de tabulação do botão.
Útil para remover o botão da sequência de tabulação (tabindex="-1") quando ele é puramente decorativo ou o foco é gerenciado por um componente pai.
   */
    set customTabIndex(_: Components.BrButton['customTabIndex']);
    /**
   * Define o rótulo acessível do botão.
Este rótulo é usado por tecnologias assistivas para descrever a função do botão.
É especialmente importante para botões com formato circular, onde o texto pode não ser visível.
Se o botão não tiver um rótulo acessível, uma mensagem de aviso será exibida no console.
   */
    set ariaLabel(_: Components.BrButton['ariaLabel']);
    /**
   * Define o estado de pressionado do botão.
Este atributo é usado para indicar se o botão está atualmente pressionado ou não.
É especialmente útil para botões que podem ser alternados entre os estados pressionado e não pressionado.
O valor deve ser 'true' ou 'false'.
   */
    set ariaPressed(_: Components.BrButton['ariaPressed']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrButton, "br-button", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaPressed": { "alias": "ariaPressed"; "required": false; }; "colorMode": { "alias": "colorMode"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "customTabIndex": { "alias": "customTabIndex"; "required": false; }; "density": { "alias": "density"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "emphasis": { "alias": "emphasis"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrButton extends Components.BrButton {
}
export declare class BrCard {
    protected z: NgZone;
    protected el: HTMLBrCardElement;
    /**
   * Identificador único; gerado automaticamente quando omitido. @default Helpers.generateUniqueId('br-card')
   */
    set customId(_: Components.BrCard['customId']);
    /**
   * Define se o card está desabilitado.
Quando true, o card fica com opacidade reduzida e não responde a interações. @default false
   */
    set disabled(_: Components.BrCard['disabled']);
    /**
   * Define se o card tem hover interativo.
Quando true, o card terá efeitos visuais ao passar o mouse. @default false
   */
    set hover(_: Components.BrCard['hover']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrCard, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrCard, "br-card", never, { "customId": { "alias": "customId"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hover": { "alias": "hover"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrCard extends Components.BrCard {
}
export declare class BrCheckbox {
    protected z: NgZone;
    protected el: HTMLBrCheckboxElement;
    /**
   * Define o estado intermediário do checkbox.
Quando verdadeiro, exibe uma marcação parcial visual que indica seleção parcial.
Útil para representar grupos onde alguns itens estão selecionados, mas não todos.
Ao clicar no checkbox neste estado, ele será automaticamente alterado para marcado. @default false
   */
    set indeterminate(_: Components.BrCheckbox['indeterminate']);
    /**
   * Define o estado de seleção do checkbox.
Se definido como verdadeiro, o checkbox estará marcado. Caso contrário, estará desmarcado. @default false
   */
    set checked(_: Components.BrCheckbox['checked']);
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-checkbox-${checkboxId++}`
   */
    set customId(_: Components.BrCheckbox['customId']);
    /**
   * Desativa o checkbox, tornando-o não interativo. @default false
   */
    set disabled(_: Components.BrCheckbox['disabled']);
    /**
   * Define se o label associado ao checkbox deve ser oculto.
Se definido como verdadeiro, o texto do label será oculto, mas o checkbox ainda estará visível e funcional. @default false
   */
    set hasHiddenLabel(_: Components.BrCheckbox['hasHiddenLabel']);
    /**
   * Texto descritivo exibido à direita do checkbox.
Caso um slot seja utilizado para fornecer um texto alternativo, o valor desta propriedade será ignorado.
   */
    set label(_: Components.BrCheckbox['label']);
    /**
   * Define o nome do checkbox, que é utilizado para agrupar checkboxes em formulários e identificar o campo.
O valor é obrigatório e deve ser fornecido para garantir o correto funcionamento em formulários.
   */
    set name(_: Components.BrCheckbox['name']);
    /**
   * Indica a validade do checkbox.
Se não for especificado, o valor padrão é `null`, indicando que a validade não foi definida.
   */
    set state(_: Components.BrCheckbox['state']);
    /**
   * Define o valor associado ao checkbox quando ele faz parte de um formulário nativo (`<form>`).
Esse valor é enviado com o formulário quando o checkbox está selecionado.
**Nota:** Esta propriedade não deve ser utilizada para determinar se o checkbox está selecionado; para verificar o estado de seleção, use a propriedade `checked`.
   */
    set value(_: Components.BrCheckbox['value']);
    /**
   * Indica se o checkbox é pai de um grupo de checkboxes. @default false
   */
    set isFather(_: Components.BrCheckbox['isFather']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrCheckbox, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrCheckbox, "br-checkbox", never, { "checked": { "alias": "checked"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hasHiddenLabel": { "alias": "hasHiddenLabel"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "isFather": { "alias": "isFather"; "required": false; }; "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "state": { "alias": "state"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrCheckbox extends Components.BrCheckbox {
    /**
     * Disparado depois que o valor do `checked` foi alterado
     */
    checkedChange: EventEmitter<CustomEvent<boolean>>;
    /**
     * Disparado depois que o valor do `indeterminate` foi alterado.
     */
    indeterminateChange: EventEmitter<CustomEvent<boolean>>;
}
export declare class BrCheckgroup {
    protected z: NgZone;
    protected el: HTMLBrCheckgroupElement;
    /**
   * Texto descritivo do grupo.
   */
    set label(_: Components.BrCheckgroup['label']);
    /**
   * Define o texto do label quando o checkbox está marcado. @default 'Desselecionar tudo'
   */
    set labelSelecionado(_: Components.BrCheckgroup['labelSelecionado']);
    /**
   * Define o texto do label quando o checkbox está desmarcado. @default 'Selecionar tudo'
   */
    set labelDesselecionado(_: Components.BrCheckgroup['labelDesselecionado']);
    /**
   * Define o estado intermediário do checkbox.
Se definido como verdadeiro, o checkbox exibirá um estado intermediário, que é um estado visual que indica que a opção está parcialmente selecionada.
Este estado é útil quando o checkbox faz parte de um grupo com seleção parcial. @default false
   */
    set indeterminate(_: Components.BrCheckgroup['indeterminate']);
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-checkgroup-${checkgroupId++}`
   */
    set customId(_: Components.BrCheckgroup['customId']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrCheckgroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrCheckgroup, "br-checkgroup", never, { "customId": { "alias": "customId"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelDesselecionado": { "alias": "labelDesselecionado"; "required": false; }; "labelSelecionado": { "alias": "labelSelecionado"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrCheckgroup extends Components.BrCheckgroup {
}
export declare class BrCollapse {
    protected z: NgZone;
    protected el: HTMLBrCollapseElement;
    /**
   * Identificador único do componente. Um valor é gerado automaticamente quando não informado. @default Helpers.generateUniqueId('clp')
   */
    set customId(_: Components.BrCollapse['customId']);
    /**
   * Controla se o collapse está aberto. @default false
   */
    set open(_: Components.BrCollapse['open']);
    /**
   * Identifica o grupo de accordion; quando informado, mantém apenas um item aberto por vez no mesmo grupo. @default null
   */
    set accordionGroup(_: Components.BrCollapse['accordionGroup']);
    /**
   * Classe CSS do ícone exibido quando o conteúdo está oculto. @default 'fa6-solid:chevron-down'
   */
    set iconToShow(_: Components.BrCollapse['iconToShow']);
    /**
   * Classe CSS do ícone exibido quando o conteúdo está visível. @default 'fa6-solid:chevron-up'
   */
    set iconToHide(_: Components.BrCollapse['iconToHide']);
    /**
   * Define a posição do ícone no acionador: 'left' ou 'right'. @default 'right'
   */
    set iconPosition(_: Components.BrCollapse['iconPosition']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrCollapse, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrCollapse, "br-collapse", never, { "accordionGroup": { "alias": "accordionGroup"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; "iconToHide": { "alias": "iconToHide"; "required": false; }; "iconToShow": { "alias": "iconToShow"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrCollapse extends Components.BrCollapse {
    /**
     * Emitido ao expandir, com o identificador e o grupo de accordion.
     */
    brDidOpen: EventEmitter<CustomEvent<{
        id: string;
        accordionGroup: string;
    }>>;
    /**
     * Emitido ao recolher, com o identificador e o grupo de accordion.
     */
    brDidClose: EventEmitter<CustomEvent<{
        id: string;
        accordionGroup: string;
    }>>;
}
export declare class BrCrumb {
    protected z: NgZone;
    protected el: HTMLBrCrumbElement;
    /**
   * Rótulo (texto) do crumb.
   */
    set label(_: Components.BrCrumb['label']);
    /**
   * URL ou caminho para o qual o usuário será direcionado ao clicar no crumb.
   */
    set url(_: Components.BrCrumb['url']);
    /**
   * Define o alvo do link quando `url` está presente. (ex: _blank, _self).
   */
    set target(_: Components.BrCrumb['target']);
    /**
   * Define se o crumb é o item inicial (Home). @default false
   */
    set home(_: Components.BrCrumb['home']);
    /**
   * Define se o crumb é a página atual ativa no breadcrumb. @default false
   */
    set active(_: Components.BrCrumb['active']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrCrumb, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrCrumb, "br-crumb", never, { "active": { "alias": "active"; "required": false; }; "home": { "alias": "home"; "required": false; }; "label": { "alias": "label"; "required": false; }; "target": { "alias": "target"; "required": false; }; "url": { "alias": "url"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrCrumb extends Components.BrCrumb {
    /**
     * Evento disparado quando as propriedades do crumb mudam.
  O componente pai (br-breadcrumb) escuta este evento para se atualizar.
     */
    brCrumbPropsChange: EventEmitter<CustomEvent<void>>;
}
export declare class BrDatetimePicker {
    protected z: NgZone;
    protected el: HTMLBrDatetimePickerElement;
    /**
   * Define se a data atual deve ser selecionada automaticamente ao abrir o datetime-picker.
O padrão é false @default false
   */
    set autoSelectToday(_: Components.BrDatetimePicker['autoSelectToday']);
    /**
   * Define se o datetime-picker está desabilitado. @default false
   */
    set disabled(_: Components.BrDatetimePicker['disabled']);
    /**
   * Define o modo do datetime-picker.
Os valores possíveis são:
- "date": Permite selecionar apenas a data.
- "time": Permite selecionar apenas o horário.
- "datetime": Permite selecionar tanto a data quanto o horário. @default 'datetime'
   */
    set mode(_: Components.BrDatetimePicker['mode']);
    /**
   * Define o nome do campo do datetime-picker.
Este nome será utilizado ao submeter o formulário que contém o datetime-picker.
   */
    set name(_: Components.BrDatetimePicker['name']);
    /**
   * Define o placeholder do campo de entrada do datetime-picker.
   */
    set placeholder(_: Components.BrDatetimePicker['placeholder']);
    /**
   * Define o valor inicial do datetime-picker.
Pode ser uma instância de Date ou null.
Se não for fornecido, o valor padrão será null.
   */
    set value(_: Components.BrDatetimePicker['value']);
    /**
   * Define o dia da semana em que a semana começa.
Os valores possíveis são:
0 - Domingo
1 - Segunda-feira
2 - Terça-feira
3 - Quarta-feira
4 - Quinta-feira
5 - Sexta-feira
6 - Sábado @default 0
   */
    set weekStartsOn(_: Components.BrDatetimePicker['weekStartsOn']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrDatetimePicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrDatetimePicker, "br-datetime-picker", never, { "autoSelectToday": { "alias": "autoSelectToday"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "name": { "alias": "name"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrDatetimePicker extends Components.BrDatetimePicker {
    /**
     * Evento disparado quando a data selecionada é alterada, tanto por interação do usuário quanto por métodos programáticos. @returns Data selecionada ou null se nenhuma data estiver selecionada
     */
    brDateTimeChange: EventEmitter<CustomEvent<Date | null>>;
}
export declare class BrDivider {
    protected z: NgZone;
    protected el: HTMLBrDividerElement;
    /**
   * ID personalizado para o elemento, útil para acessibilidade e identificação única.
Se não for fornecido, um ID único será gerado automaticamente. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrDivider['customId']);
    /**
   * Orientação do divisor.Em modo vertical, posicione dentro de um container com `display: flex`. @default 'horizontal'
   */
    set orientation(_: Components.BrDivider['orientation']);
    /**
   * Espessura visual do divisor. @default 'small'
   */
    set thickness(_: Components.BrDivider['thickness']);
    /**
   * Estilo de borda do divisor. @default 'solid'
   */
    set borderStyle(_: Components.BrDivider['borderStyle']);
    /**
   * Ativa variante de alto contraste para fundos escuros. @default false
   */
    set isDarkMode(_: Components.BrDivider['isDarkMode']);
    /**
   * Cor do divisor.
Aceita os seguintes formatos de cor:
- Cores nomeadas do CSS: 'red', 'blue', 'green', 'yellow', etc.
- Códigos hexadecimais: '#ff0000', '#00ff00', '#0000ff', etc.
- Valores RGB: 'rgb(255, 0, 0)', 'rgb(0, 255, 0)', etc.
- Valores RGBA: 'rgba(255, 0, 0, 0.5)', 'rgba(0, 255, 0, 0.8)', etc.
- Valores HSL: 'hsl(0, 100%, 50%)', 'hsl(120, 100%, 50%)', etc.
- Valores HSLA: 'hsla(0, 100%, 50%, 0.5)', 'hsla(240, 100%, 50%, 0.7)', etc.
Se não definida, usa a cor padrão do tema. @default ''
   */
    set color(_: Components.BrDivider['color']);
    /**
   * Alinhamento do conteúdo quando há slot interno.
   */
    set align(_: Components.BrDivider['align']);
    /**
   * Faz o divisor ocupar toda a largura do container, compensando paddings laterais. @default false
   */
    set bleed(_: Components.BrDivider['bleed']);
    /**
   * Margin top em pixels; se omitido, aplica padrão interno. @default null
   */
    set marginTop(_: Components.BrDivider['marginTop']);
    /**
   * Margin bottom em pixels; se omitido, aplica padrão interno. @default null
   */
    set marginBottom(_: Components.BrDivider['marginBottom']);
    /**
   * Margin left em pixels; se omitido, aplica padrão interno. @default null
   */
    set marginLeft(_: Components.BrDivider['marginLeft']);
    /**
   * Margin right em pixels; se omitido, aplica padrão interno. @default null
   */
    set marginRight(_: Components.BrDivider['marginRight']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrDivider, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrDivider, "br-divider", never, { "align": { "alias": "align"; "required": false; }; "bleed": { "alias": "bleed"; "required": false; }; "borderStyle": { "alias": "borderStyle"; "required": false; }; "color": { "alias": "color"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "isDarkMode": { "alias": "isDarkMode"; "required": false; }; "marginBottom": { "alias": "marginBottom"; "required": false; }; "marginLeft": { "alias": "marginLeft"; "required": false; }; "marginRight": { "alias": "marginRight"; "required": false; }; "marginTop": { "alias": "marginTop"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "thickness": { "alias": "thickness"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrDivider extends Components.BrDivider {
}
export declare class BrDropdown {
    protected z: NgZone;
    protected el: HTMLBrDropdownElement;
    /**
   * Indica se o dropdown está aberto ou fechado.
Esta propriedade é refletida no DOM e pode ser alterada externamente.
O valor padrão é falso (fechado). @default false
   */
    set isOpen(_: Components.BrDropdown['isOpen']);
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrDropdown['customId']);
    /**
   * Define o posicionamento do target (alvo) em relação ao trigger (acionador). @default 'bottom-start'
   */
    set placement(_: Components.BrDropdown['placement']);
    /**
   * Define se o dropdown deve permanecer aberto quando outro dropdown é aberto.
Quando definido como false (padrão), o dropdown será fechado automaticamente quando outro dropdown for aberto.
Quando definido como true, o dropdown permanecerá aberto mesmo quando outro dropdown for aberto. @default false
   */
    set preventAutoDismiss(_: Components.BrDropdown['preventAutoDismiss']);
    /**
   * Define o z-index do elemento target (alvo) do dropdown.
Permite customizar a ordem de sobreposição do painel dropdown em relação aos demais elementos da página.
O valor padrão utiliza a variável CSS do design system: var(--z-index-layer-1). @default 'var(--z-index-layer-1)'
   */
    set targetZIndex(_: Components.BrDropdown['targetZIndex']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrDropdown, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrDropdown, "br-dropdown", never, { "customId": { "alias": "customId"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "preventAutoDismiss": { "alias": "preventAutoDismiss"; "required": false; }; "targetZIndex": { "alias": "targetZIndex"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrDropdown extends Components.BrDropdown {
    /**
     * Evento emitido quando o estado do dropdown muda.
     */
    brDropdownChange: EventEmitter<CustomEvent<{
        isOpen: boolean;
    }>>;
    /**
     * Evento emitido quando o dropdown é aberto.
  Este evento é usado para implementar o auto-dismiss de outros dropdowns.
     */
    brDidOpen: EventEmitter<CustomEvent<{
        id: string;
    }>>;
}
export declare class BrFooter {
    protected z: NgZone;
    protected el: HTMLBrFooterElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrFooter['customId']);
    /**
   * Indica o tema do rodapé. @default 'dark'
   */
    set theme(_: Components.BrFooter['theme']);
    /**
   * Texto de descrição das redes sociais. @default 'Redes Sociais'
   */
    set socialNetworkTitle(_: Components.BrFooter['socialNetworkTitle']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrFooter, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrFooter, "br-footer", never, { "customId": { "alias": "customId"; "required": false; }; "socialNetworkTitle": { "alias": "socialNetworkTitle"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrFooter extends Components.BrFooter {
}
export declare class BrFooterCategory {
    protected z: NgZone;
    protected el: HTMLBrFooterCategoryElement;
    /**
   * Identificador único do componente; gerado automaticamente quando omitido. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrFooterCategory['customId']);
    /**
   * Título da categoria exibido no cabeçalho da lista. @default ''
   */
    set label(_: Components.BrFooterCategory['label']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrFooterCategory, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrFooterCategory, "br-footer-category", never, { "customId": { "alias": "customId"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrFooterCategory extends Components.BrFooterCategory {
}
export declare class BrFooterItem {
    protected z: NgZone;
    protected el: HTMLBrFooterItemElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrFooterItem['customId']);
    /**
   * URL ou caminho para o qual o usuário será direcionado ao clicar no item.
Quando definido, o item será renderizado como um link.
   */
    set href(_: Components.BrFooterItem['href']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrFooterItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrFooterItem, "br-footer-item", never, { "customId": { "alias": "customId"; "required": false; }; "href": { "alias": "href"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrFooterItem extends Components.BrFooterItem {
}
export declare class BrFooterLegal {
    protected z: NgZone;
    protected el: HTMLBrFooterLegalElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrFooterLegal['customId']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrFooterLegal, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrFooterLegal, "br-footer-legal", never, { "customId": { "alias": "customId"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrFooterLegal extends Components.BrFooterLegal {
}
export declare class BrFooterLogo {
    protected z: NgZone;
    protected el: HTMLBrFooterLogoElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrFooterLogo['customId']);
    /**
   * Url da logo padrão. @default ''
   */
    set src(_: Components.BrFooterLogo['src']);
    /**
   * Descrição da logo. @default 'logo'
   */
    set description(_: Components.BrFooterLogo['description']);
    /**
   * Posição da logo. @default 'left'
   */
    set position(_: Components.BrFooterLogo['position']);
    /**
   * Define se a logo é de um parceiro. @default false
   */
    set isPartner(_: Components.BrFooterLogo['isPartner']);
    /**
   * URL de destino quando a logo for clicada.
Se fornecido, a logo será envolvida em um link.
   */
    set href(_: Components.BrFooterLogo['href']);
    /**
   * Target do link quando href é fornecido. @default '_self'
   */
    set target(_: Components.BrFooterLogo['target']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrFooterLogo, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrFooterLogo, "br-footer-logo", never, { "customId": { "alias": "customId"; "required": false; }; "description": { "alias": "description"; "required": false; }; "href": { "alias": "href"; "required": false; }; "isPartner": { "alias": "isPartner"; "required": false; }; "position": { "alias": "position"; "required": false; }; "src": { "alias": "src"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrFooterLogo extends Components.BrFooterLogo {
}
export declare class BrFooterSocial {
    protected z: NgZone;
    protected el: HTMLBrFooterSocialElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrFooterSocial['customId']);
    /**
   * Ícone da rede social
   */
    set icon(_: Components.BrFooterSocial['icon']);
    /**
   * Descrição do ícone da rede social
   */
    set description(_: Components.BrFooterSocial['description']);
    /**
   * URL da rede social @default null
   */
    set href(_: Components.BrFooterSocial['href']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrFooterSocial, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrFooterSocial, "br-footer-social", never, { "customId": { "alias": "customId"; "required": false; }; "description": { "alias": "description"; "required": false; }; "href": { "alias": "href"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrFooterSocial extends Components.BrFooterSocial {
}
export declare class BrHeader {
    protected z: NgZone;
    protected el: HTMLBrHeaderElement;
    /**
   * Texto exibido como título do cabeçalho. @default null
   */
    set caption(_: Components.BrHeader['caption']);
    /**
   * URL associada ao título do cabeçalho. @default null
   */
    set captionUrl(_: Components.BrHeader['captionUrl']);
    /**
   * Identificador único do cabeçalho; gerado automaticamente quando omitido. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrHeader['customId']);
    /**
   * Densidade do cabeçalho: controla espaçamento e proporções. @default 'medium'
   */
    set density(_: Components.BrHeader['density']);
    /**
   * Ativa o modo compacto do cabeçalho. @default false
   */
    set isCompact(_: Components.BrHeader['isCompact']);
    /**
   * Fixa o cabeçalho no topo durante a rolagem. @default false
   */
    set isSticky(_: Components.BrHeader['isSticky']);
    /**
   * Texto da assinatura exibida ao lado da logo. @default null
   */
    set signature(_: Components.BrHeader['signature']);
    /**
   * Define qual lista encolhe primeiro quando o espaço é limitado. @default 'functions'
   */
    set shrinkFirst(_: Components.BrHeader['shrinkFirst']);
    /**
   * Texto exibido como subtítulo do cabeçalho. @default null
   */
    set subcaption(_: Components.BrHeader['subcaption']);
    /**
   * URL associada ao subtítulo do cabeçalho. @default null
   */
    set subcaptionUrl(_: Components.BrHeader['subcaptionUrl']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrHeader, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrHeader, "br-header", never, { "caption": { "alias": "caption"; "required": false; }; "captionUrl": { "alias": "captionUrl"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "isCompact": { "alias": "isCompact"; "required": false; }; "isSticky": { "alias": "isSticky"; "required": false; }; "shrinkFirst": { "alias": "shrinkFirst"; "required": false; }; "signature": { "alias": "signature"; "required": false; }; "subcaption": { "alias": "subcaption"; "required": false; }; "subcaptionUrl": { "alias": "subcaptionUrl"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrHeader extends Components.BrHeader {
    /**
     * Evento disparado quando o cabeçalho entra ou sai do modo compacto.
  O evento contém os detalhes do estado compacto e o ID do componente pai. @event headerCompactChange
     */
    headerCompactChange: EventEmitter<CustomEvent<{
        parentId: string;
        isCompact: boolean;
    }>>;
    /**
     * Evento disparado para indicar qual lista deve encolher primeiro.
  O evento contém os detalhes do ID do componente pai e o nome da lista. @event headerWidthChange
     */
    headerWidthChange: EventEmitter<CustomEvent<{
        id: string;
        listNames: ('links' | 'functions')[];
        shrink: boolean;
    }>>;
}
export declare class BrHeaderFunction {
    protected z: NgZone;
    protected el: HTMLBrHeaderFunctionElement;
    /**
   * Identificador único; gerado automaticamente quando omitido. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrHeaderFunction['customId']);
    /**
   * URL de destino da funcionalidade. @default null
   */
    set href(_: Components.BrHeaderFunction['href']);
    /**
   * Nome do ícone exibido. @default null
   */
    set iconName(_: Components.BrHeaderFunction['iconName']);
    /**
   * Define o alvo do link quando `href` está presente. Pode ser:
- `_blank` para abrir em uma nova aba,
- `_self` para abrir na mesma aba,
- `_parent` para abrir na aba pai,
- `_top` para abrir na aba superior. @default '_self'
   */
    set target(_: Components.BrHeaderFunction['target']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrHeaderFunction, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrHeaderFunction, "br-header-function", never, { "customId": { "alias": "customId"; "required": false; }; "href": { "alias": "href"; "required": false; }; "iconName": { "alias": "iconName"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrHeaderFunction extends Components.BrHeaderFunction {
}
export declare class BrHeaderLink {
    protected z: NgZone;
    protected el: HTMLBrHeaderLinkElement;
    /**
   * Identificador único; gerado automaticamente quando omitido. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrHeaderLink['customId']);
    /**
   * URL do link. @default null
   */
    set href(_: Components.BrHeaderLink['href']);
    /**
   * Define o alvo do link quando `href` está presente. Pode ser:
- `_blank` para abrir em uma nova aba,
- `_self` para abrir na mesma aba,
- `_parent` para abrir na aba pai,
- `_top` para abrir na aba superior. @default '_self'
   */
    set target(_: Components.BrHeaderLink['target']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrHeaderLink, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrHeaderLink, "br-header-link", never, { "customId": { "alias": "customId"; "required": false; }; "href": { "alias": "href"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrHeaderLink extends Components.BrHeaderLink {
}
export declare class BrHeaderList {
    protected z: NgZone;
    protected el: HTMLBrHeaderListElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrHeaderList['customId']);
    /**
   * Título da lista. @default null
   */
    set listTitle(_: Components.BrHeaderList['listTitle']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrHeaderList, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrHeaderList, "br-header-list", never, { "customId": { "alias": "customId"; "required": false; }; "listTitle": { "alias": "listTitle"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrHeaderList extends Components.BrHeaderList {
    /**
     * Evento disparado para indicar qual lista deve encolher primeiro.
  O evento envia o ID do componente pai e o nome da lista. @event headerWidthChange
     */
    headerListUpdate: EventEmitter<CustomEvent<{
        id: string;
        listName: string;
    }>>;
    /**
     * Evento disparado quando a lista recebe foco.
  O evento envia o ID do componente. @event headerListFocused
     */
    headerListFocused: EventEmitter<CustomEvent<{
        id: string;
    }>>;
}
export declare class BrHeaderLogo {
    protected z: NgZone;
    protected el: HTMLBrHeaderLogoElement;
    /**
   * Identificador único; gerado automaticamente quando omitido. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrHeaderLogo['customId']);
    /**
   * Texto alternativo/descritivo da logo. @default 'logo'
   */
    set description(_: Components.BrHeaderLogo['description']);
    /**
   * URL de destino quando a logo for clicada.
Se fornecido, a logo será envolvida em um link.
   */
    set href(_: Components.BrHeaderLogo['href']);
    /**
   * Alterna para versão compacta quando true. @default false
   */
    set isCompact(_: Components.BrHeaderLogo['isCompact']);
    /**
   * Target do link quando href é fornecido. @default '_self'
   */
    set target(_: Components.BrHeaderLogo['target']);
    /**
   * Url da logo padrão. @default ''
   */
    set src(_: Components.BrHeaderLogo['src']);
    /**
   * Largura da imagem. @default null
   */
    set width(_: Components.BrHeaderLogo['width']);
    /**
   * Altura da imagem. @default null
   */
    set height(_: Components.BrHeaderLogo['height']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrHeaderLogo, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrHeaderLogo, "br-header-logo", never, { "customId": { "alias": "customId"; "required": false; }; "description": { "alias": "description"; "required": false; }; "height": { "alias": "height"; "required": false; }; "href": { "alias": "href"; "required": false; }; "isCompact": { "alias": "isCompact"; "required": false; }; "src": { "alias": "src"; "required": false; }; "target": { "alias": "target"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrHeaderLogo extends Components.BrHeaderLogo {
}
export declare class BrIcon {
    protected z: NgZone;
    protected el: HTMLBrIconElement;
    /**
   * Nome do ícone a ser exibido, utilizando a biblioteca Iconify.
Este nome deve corresponder ao nome do ícone definido na biblioteca para que ele seja exibido corretamente.
   */
    set iconName(_: Components.BrIcon['iconName']);
    /**
   * Define a altura do ícone. Pode ser especificada em qualquer unidade CSS válida, como pixels (px), ems (em), rems (rem), etc.
O valor padrão é '16'. @default '16'
   */
    set height(_: Components.BrIcon['height']);
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-icon-${iconId++}`
   */
    set customId(_: Components.BrIcon['customId']);
    /**
   * Define a largura do ícone. Pode ser especificada em qualquer unidade CSS válida, como pixels (px), ems (em), rems (rem), etc.
O valor padrão é '24'. @default '24'
   */
    set width(_: Components.BrIcon['width']);
    /**
   * Permite adicionar classes CSS adicionais ao ícone.
Use esta propriedade para aplicar estilos personalizados ao ícone, além dos estilos padrão.
   */
    set cssClasses(_: Components.BrIcon['cssClasses']);
    /**
   * Se definido como verdadeiro, o ícone será alinhado verticalmente ao texto ao seu redor.
Útil quando o ícone é usado em linha com texto para garantir que esteja alinhado corretamente com o texto.
O valor padrão é `false`. @default false
   */
    set isInline(_: Components.BrIcon['isInline']);
    /**
   * Define o ângulo de rotação do ícone.
   */
    set rotate(_: Components.BrIcon['rotate']);
    /**
   * Define o tipo de espelhamento do ícone.
   */
    set flip(_: Components.BrIcon['flip']);
    /**
   * Determina se o ícone pode receber foco.
Se definido como verdadeiro, o ícone pode ser navegado usando Tab.
O valor padrão é `false`. @default false
   */
    set isFocusable(_: Components.BrIcon['isFocusable']);
    /**
   * Controla o comportamento de carregamento do ícone através do observer interno do Iconify.

Comportamento:
- Padrão (propriedade não definida): carregamento imediato aplicando `noobserver` para evitar problemas de layout shift
- `lazy={true}`: ativa o observer para carregamento lazy otimizado (útil em documentos longos com muitos ícones)
- `lazy={false}`: carregamento imediato aplicando `noobserver` (mesmo comportamento do padrão)

**Nota**: O padrão foi alterado para carregamento imediato para resolver problemas de deslocamento de layout
que ocorriam quando ícones eram carregados depois do conteúdo inicial.
   */
    set lazy(_: Components.BrIcon['lazy']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrIcon, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrIcon, "br-icon", never, { "cssClasses": { "alias": "cssClasses"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "flip": { "alias": "flip"; "required": false; }; "height": { "alias": "height"; "required": false; }; "iconName": { "alias": "iconName"; "required": false; }; "isFocusable": { "alias": "isFocusable"; "required": false; }; "isInline": { "alias": "isInline"; "required": false; }; "lazy": { "alias": "lazy"; "required": false; }; "rotate": { "alias": "rotate"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrIcon extends Components.BrIcon {
}
export declare class BrInput {
    protected z: NgZone;
    protected el: HTMLBrInputElement;
    /**
   * Especifica o tipo de entrada do campo. @default 'text'
   */
    set type(_: Components.BrInput['type']);
    /**
   * Controla o comportamento de preenchimento automático do navegador para o input.
   */
    set autocomplete(_: Components.BrInput['autocomplete']);
    /**
   * Ajusta a densidade, alterando o espaçamento interno para um visual mais compacto ou mais expandido. @default 'medium'
   */
    set density(_: Components.BrInput['density']);
    /**
   * Desativa o input, tornando-o não interativo. @default false
   */
    set disabled(_: Components.BrInput['disabled']);
    /**
   * Se verdadeiro, o rótulo e o input estarão na mesma linha (layout inline). @default false
   */
    set isInline(_: Components.BrInput['isInline']);
    /**
   * Se verdadeiro, o input terá destaque visual. @default false
   */
    set isHighlight(_: Components.BrInput['isHighlight']);
    /**
   * Define o estado do input @remarks O estado é propagado para o slot de feedback, mas também pode ser controlado diretamente pelo conteúdo do slot.
   */
    set state(_: Components.BrInput['state']);
    /**
   * Texto exibido como rótulo do input.
   */
    set label(_: Components.BrInput['label']);
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-input-${inputId++}`
   */
    set customId(_: Components.BrInput['customId']);
    /**
   * Nome do input, utilizado para identificação em formulários.
   */
    set name(_: Components.BrInput['name']);
    /**
   * Texto exibido dentro do input quando está vazio, fornecendo uma dica ou sugestão ao usuário.
   */
    set placeholder(_: Components.BrInput['placeholder']);
    /**
   * Se verdadeiro, o valor do input é exibido, mas não pode ser editado pelo usuário. @default false
   */
    set readonly(_: Components.BrInput['readonly']);
    /**
   * Se verdadeiro, o input é obrigatório e deve ser preenchido antes que o formulário possa ser enviado. @default false
   */
    set required(_: Components.BrInput['required']);
    /**
   * Valor exibido no input.
Pode ser alterado pelo usuário se a propriedade `readonly` não estiver ativa.
   */
    set value(_: Components.BrInput['value']);
    /**
   * Largura do campo de entrada (por exemplo, '88px').
Quando definido, sobrescreve a largura padrão de 100%.
   */
    set controlWidth(_: Components.BrInput['controlWidth']);
    /**
   * Remove a borda do input quando não está em foco.
Útil para composições contextuais (ex.: paginação). @default false
   */
    set borderless(_: Components.BrInput['borderless']);
    /**
   * Texto adicional que fornece ajuda ou informações sobre o input.
   */
    set helpText(_: Components.BrInput['helpText']);
    /**
   * Controla a correção automática do texto. @default 'off'
   */
    set autocorrect(_: Components.BrInput['autocorrect']);
    /**
   * Define o valor mínimo para campos de entrada numéricos.
   */
    set min(_: Components.BrInput['min']);
    /**
   * Define o valor máximo para campos de entrada numéricos.
   */
    set max(_: Components.BrInput['max']);
    /**
   * Define o comprimento mínimo do valor do campo de entrada.
   */
    set minlength(_: Components.BrInput['minlength']);
    /**
   * Define o comprimento máximo do valor do campo de entrada.
   */
    set maxlength(_: Components.BrInput['maxlength']);
    /**
   * Se verdadeiro, permite a seleção de múltiplos arquivos. @default false
   */
    set multiple(_: Components.BrInput['multiple']);
    /**
   * Define o padrão de entrada para validação.
   */
    set pattern(_: Components.BrInput['pattern']);
    /**
   * Máscara aplicada ao valor digitado (use `#` para marcar posições numéricas).
   */
    set mask(_: Components.BrInput['mask']);
    /**
   * Define o valor do passo para campos de entrada numéricos.
   */
    set step(_: Components.BrInput['step']);
    /**
   * Texto exibido no botão de ação à direita do input.
   */
    set actionLabel(_: Components.BrInput['actionLabel']);
    /**
   * Define o tabindex do botão de ação.
Útil para remover o botão da sequência de tabulação quando o foco é gerenciado externamente (ex.: br-select).
   */
    set actionTabIndex(_: Components.BrInput['actionTabIndex']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrInput, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrInput, "br-input", never, { "actionLabel": { "alias": "actionLabel"; "required": false; }; "actionTabIndex": { "alias": "actionTabIndex"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "autocorrect": { "alias": "autocorrect"; "required": false; }; "borderless": { "alias": "borderless"; "required": false; }; "controlWidth": { "alias": "controlWidth"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "helpText": { "alias": "helpText"; "required": false; }; "isHighlight": { "alias": "isHighlight"; "required": false; }; "isInline": { "alias": "isInline"; "required": false; }; "label": { "alias": "label"; "required": false; }; "mask": { "alias": "mask"; "required": false; }; "max": { "alias": "max"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "min": { "alias": "min"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "name": { "alias": "name"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "state": { "alias": "state"; "required": false; }; "step": { "alias": "step"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrInput extends Components.BrInput {
    /**
     * Valor atualizado do input
     */
    valueChange: EventEmitter<CustomEvent<string>>;
}
export declare class BrItem {
    protected z: NgZone;
    protected el: HTMLBrItemElement;
    /**
   * Desativa o item, tornando-o não interativo. @default false
   */
    set disabled(_: Components.BrItem['disabled']);
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-item-${itemId++}`
   */
    set customId(_: Components.BrItem['customId']);
    /**
   * Indica se o item está no estado ativo.
Se definido como verdadeiro, o item será exibido como ativo. @default false
   */
    set isActive(_: Components.BrItem['isActive']);
    /**
   * Indica se o item está no estado selecionado.
Se definido como verdadeiro, o item será exibido como selecionado. @default false
   */
    set isSelected(_: Components.BrItem['isSelected']);
    /**
   * Marca o item como interativo, permitindo que toda a superfície do item seja clicável. @default false
   */
    set isInteractive(_: Components.BrItem['isInteractive']);
    /**
   * URL ou caminho para o qual o usuário será direcionado ao clicar no item. Quando definido, o item será renderizado como um link.
   */
    set href(_: Components.BrItem['href']);
    /**
   * Define o alvo do link quando `href` está presente. Pode ser:
- `_blank` para abrir em uma nova aba,
- `_self` para abrir na mesma aba,
- `_parent` para abrir na aba pai,
- `_top` para abrir na aba superior.
   */
    set target(_: Components.BrItem['target']);
    /**
   * Quando definido como `true`, o item será tratado como um botão. @default false
   */
    set isButton(_: Components.BrItem['isButton']);
    /**
   * Tipo do botão, aplicável apenas se `isButton` for `true`. Pode ser:
- `'submit'` para enviar um formulário,
- `'reset'` para redefinir um formulário,
- `'button'` para um botão padrão.
   */
    set type(_: Components.BrItem['type']);
    /**
   * Define um valor associado ao br-item quando renderizado como um botão, utilizado em contextos de formulário.
   */
    set value(_: Components.BrItem['value']);
    /**
   * Ajusta a densidade, alterando o espaçamento interno para um visual mais compacto ou mais expandido. @default 'medium'
   */
    set density(_: Components.BrItem['density']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrItem, "br-item", never, { "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "href": { "alias": "href"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "isButton": { "alias": "isButton"; "required": false; }; "isInteractive": { "alias": "isInteractive"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "target": { "alias": "target"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrItem extends Components.BrItem {
    /**
     * Evento customizado emitido quando o item é clicado, aplicável apenas se o item for um botão (`<button>`).
  Pode ser utilizado para ações personalizadas, exceto quando o item está desativado.
     */
    brDidClick: EventEmitter<CustomEvent<any>>;
    /**
     * Evento customizado aplicável para todos os tipos de elementos (`div`, `button`, `a`), emitido quando o item é selecionado e desde que a propriedade `isInteractive` esteja presente.
     */
    brDidSelect: EventEmitter<CustomEvent<{
        selected: boolean;
    }>>;
}
export declare class BrList {
    protected z: NgZone;
    protected el: HTMLBrListElement;
    /**
   * Define o cabeçalho para a lista. @default null
   */
    set header(_: Components.BrList['header']);
    /**
   * Indica se a lista será horizontal. Por padrão, a lista é vertical. @default false
   */
    set isHorizontal(_: Components.BrList['isHorizontal']);
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-list-${listId++}`
   */
    set customId(_: Components.BrList['customId']);
    /**
   * Indica que o divider para o título da lista estará oculto. @default false
   */
    set hideHeaderDivider(_: Components.BrList['hideHeaderDivider']);
    /**
   * Indica se a lista possui o comportamento de collapse. @default false
   */
    set collapse(_: Components.BrList['collapse']);
    /**
   * Indica se a lista possui o comportamento de accordion.
O valor da propriedade define o grupo, ou seja, o accordion é aplicado a todas as listas que possuem o mesmo valor para esta propriedade. @default null
   */
    set accordion(_: Components.BrList['accordion']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrList, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrList, "br-list", never, { "accordion": { "alias": "accordion"; "required": false; }; "collapse": { "alias": "collapse"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "header": { "alias": "header"; "required": false; }; "hideHeaderDivider": { "alias": "hideHeaderDivider"; "required": false; }; "isHorizontal": { "alias": "isHorizontal"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrList extends Components.BrList {
}
export declare class BrLoading {
    protected z: NgZone;
    protected el: HTMLBrLoadingElement;
    /**
   * Define a posição da label em relação ao loading. @default 'bottom'
   */
    set labelPosition(_: Components.BrLoading['labelPosition']);
    /**
   * Identificador único do componente, útil para acessibilidade e testes.
Se não for fornecido, um ID único será gerado automaticamente. @default Gerado automaticamente no formato 'loading-xxxx' onde 'xxxx' é uma sequência aleatória.
   */
    set customId(_: Components.BrLoading['customId']);
    /**
   * Define o modo de exibição do componente. @default 'spinner'
   */
    set mode(_: Components.BrLoading['mode']);
    /**
   * Define o tamanho visual nos modos `spinner` e `progress`. @default 'medium'
   */
    set size(_: Components.BrLoading['size']);
    /**
   * Define a velocidade da animação/transição. @default 'normal'
   */
    set speed(_: Components.BrLoading['speed']);
    /**
   * Define o rótulo exibido no modo `spinner`.
No modo `progress`, esta prop não tem efeito. @default undefined
   */
    set label(_: Components.BrLoading['label']);
    /**
   * Define o progresso no modo `progress`.
No modo `spinner`, esta prop não tem efeito.
Valores inválidos são normalizados para `0`. @default 0
   */
    set value(_: Components.BrLoading['value']);
    /**
   * Define o comportamento quando o progresso atinge 100.
No modo `spinner`, esta prop não tem efeito. @default 'persist'
   */
    set completion(_: Components.BrLoading['completion']);
    /**
   * Define se o botão de cancelamento será exibido.
Ao pressionar o botão, o evento `brLoadingCancel` é emitido.
No modo `spinner`, esta prop não tem efeito. @default false
   */
    set cancelable(_: Components.BrLoading['cancelable']);
    /**
   * Define o texto do botão de cancelamento.
No modo `spinner`, esta prop não tem efeito. @default 'Cancelar'
   */
    set cancelLabel(_: Components.BrLoading['cancelLabel']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrLoading, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrLoading, "br-loading", never, { "cancelLabel": { "alias": "cancelLabel"; "required": false; }; "cancelable": { "alias": "cancelable"; "required": false; }; "completion": { "alias": "completion"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "size": { "alias": "size"; "required": false; }; "speed": { "alias": "speed"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrLoading extends Components.BrLoading {
    /**
     * Notifica mudança de progresso no modo `progress`. @event brLoadingChange
  Payload (`LoadingChangeDetail`):
  - `value` (`number`): progresso normalizado (0 a 100).
     */
    brLoadingChange: EventEmitter<CustomEvent<IBrLoadingLoadingChangeDetail>>;
    /**
     * Notifica conclusão do progresso no modo `progress`. @event brLoadingComplete
  Payload (`LoadingCompleteDetail`):
  - `value` (`number`): progresso normalizado (0 a 100).
  - `completion` (`LoadingCompletionBehavior`): ação aplicada ao atingir 100%.
  - `persist`: mantém o loading em 100%.
  - `reset`: reinicia o progresso para 0.
  - `hide`: oculta o componente.
     */
    brLoadingComplete: EventEmitter<CustomEvent<IBrLoadingLoadingCompleteDetail>>;
    /**
     * Notifica reinício do progresso no modo `progress`. @event brLoadingReset
  Payload (`LoadingValueDetail`):
  - `value` (`number`): valor do progresso após o reset.
     */
    brLoadingReset: EventEmitter<CustomEvent<IBrLoadingLoadingValueDetail>>;
    /**
     * Notifica clique no botão de cancelamento no modo `progress`.
  Este evento não altera o progresso automaticamente.
  A aplicação consumidora define a ação após o cancelamento (ex.: resetar ou ocultar). @event brLoadingCancel
  Payload (`LoadingValueDetail`):
  - `value` (`number`): valor de progresso no momento do cancelamento.
     */
    brLoadingCancel: EventEmitter<CustomEvent<IBrLoadingLoadingValueDetail>>;
    /**
     * Notifica mudança do estado lógico no modo `spinner`. @event brIndeterminateStateChange
  Payload (`LoadingIndeterminateStateDetail`):
  - `active` (`boolean`): `true` quando ativo; `false` quando inativo.
     */
    brIndeterminateStateChange: EventEmitter<CustomEvent<IBrLoadingLoadingIndeterminateStateDetail>>;
    /**
     * Notifica que o componente foi exibido. @event brDidShow
  Payload: `void`.
     */
    brDidShow: EventEmitter<CustomEvent<void>>;
    /**
     * Notifica que o componente foi ocultado. @event brDidHide
  Payload: `void`.
     */
    brDidHide: EventEmitter<CustomEvent<void>>;
}
export declare class BrMagicButton {
    protected z: NgZone;
    protected el: HTMLBrMagicButtonElement;
    /**
   * Identificador único.
Se não for fornecido, será gerado automaticamente. @default `br-magic-button-${MagicButtonId++}`
   */
    set customId(_: Components.BrMagicButton['customId']);
    /**
   * Texto do rótulo do botão.
Utilizado como conteúdo principal quando presente. @default ''
   */
    set label(_: Components.BrMagicButton['label']);
    /**
   * Nome do ícone a ser exibido.
Deve corresponder a um ícone disponível no sistema de ícones. @default ''
   */
    set icon(_: Components.BrMagicButton['icon']);
    /**
   * Densidade do botão.
Define o tamanho do componente:
- `large` para grande
- `medium` para médio
- `small` para pequeno @default 'medium'
   */
    set density(_: Components.BrMagicButton['density']);
    /**
   * Define se o botão terá formato circular.
Aplica contorno arredondado completo quando `true` e não houver `label`. @default false
   */
    set circle(_: Components.BrMagicButton['circle']);
    /**
   * Texto de acessibilidade (ARIA label).
Deve ser fornecido para ícones sem texto para garantir acessibilidade. @default ''
   */
    set ariaLabel(_: Components.BrMagicButton['ariaLabel']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrMagicButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrMagicButton, "br-magic-button", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "circle": { "alias": "circle"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrMagicButton extends Components.BrMagicButton {
}
export declare class BrMenu {
    protected z: NgZone;
    protected el: HTMLBrMenuElement;
    /**
   * Classes CSS para definir breakpoints responsivos do menu.
Utilize esta propriedade para controlar a largura do menu em diferentes tamanhos de tela. @default ''
   */
    set breakpoints(_: Components.BrMenu['breakpoints']);
    /**
   * 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
   */
    set push(_: Components.BrMenu['push']);
    /**
   * 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
   */
    set contextual(_: Components.BrMenu['contextual']);
    /**
   * 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'
   */
    set density(_: Components.BrMenu['density']);
    /**
   * 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'
   */
    set socialTitle(_: Components.BrMenu['socialTitle']);
    /**
   * Rótulo do botão trigger do menu contextual.
Exibido apenas em modo contextual e em telas menores (mobile). @default 'Menu Contextual'
   */
    set contextualLabel(_: Components.BrMenu['contextualLabel']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrMenu, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrMenu, "br-menu", never, { "breakpoints": { "alias": "breakpoints"; "required": false; }; "contextual": { "alias": "contextual"; "required": false; }; "contextualLabel": { "alias": "contextualLabel"; "required": false; }; "density": { "alias": "density"; "required": false; }; "push": { "alias": "push"; "required": false; }; "socialTitle": { "alias": "socialTitle"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrMenu extends Components.BrMenu {
}
export declare class BrMenuHeader {
    protected z: NgZone;
    protected el: HTMLBrMenuHeaderElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-menu-${MenuHeaderId++}`
   */
    set customId(_: Components.BrMenuHeader['customId']);
    /**
   * URL da imagem do logo no cabeçalho do menu
   */
    set logoSrc(_: Components.BrMenuHeader['logoSrc']);
    /**
   * Texto alternativo para a imagem do logo @default 'Logo'
   */
    set logoAlt(_: Components.BrMenuHeader['logoAlt']);
    /**
   * Texto de identificação do site ou sistema
   */
    set signature(_: Components.BrMenuHeader['signature']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrMenuHeader, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrMenuHeader, "br-menu-header", never, { "customId": { "alias": "customId"; "required": false; }; "logoAlt": { "alias": "logoAlt"; "required": false; }; "logoSrc": { "alias": "logoSrc"; "required": false; }; "signature": { "alias": "signature"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrMenuHeader extends Components.BrMenuHeader {
    /**
     * Evento emitido quando o botão de fechar é clicado
     */
    brMenuHeaderClose: EventEmitter<CustomEvent<void>>;
}
export declare class BrMenuInfo {
    protected z: NgZone;
    protected el: HTMLBrMenuInfoElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-menu-info-${MenuInfoId++}`
   */
    set customId(_: Components.BrMenuInfo['customId']);
    /**
   * Informações adicionais em formato de texto
   */
    set info(_: Components.BrMenuInfo['info']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrMenuInfo, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrMenuInfo, "br-menu-info", never, { "customId": { "alias": "customId"; "required": false; }; "info": { "alias": "info"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrMenuInfo extends Components.BrMenuInfo {
}
export declare class BrMenuItem {
    protected z: NgZone;
    protected el: HTMLBrMenuItemElement;
    /**
   * Ícone exibido no item do menu.
Utilize esta propriedade para definir o ícone que será mostrado ao lado do conteúdo do item.
   */
    set icon(_: Components.BrMenuItem['icon']);
    /**
   * URL de destino do link do item do menu.
Utilize esta propriedade para definir o endereço para onde o usuário será direcionado ao clicar no item. @default '#'
   */
    set href(_: Components.BrMenuItem['href']);
    /**
   * Define como o link será aberto.
- `_self`: abre no mesmo contexto de navegação (padrão)
- `_blank`: abre em nova aba ou janela
- `_parent`: abre no contexto pai
- `_top`: abre no contexto de nível superior @default '_blank'
   */
    set target(_: Components.BrMenuItem['target']);
    /**
   * Define se o item deve exibir um divisor visual.
Quando ativado, adiciona uma linha separadora para organizar visualmente os itens do menu. @default false
   */
    set divider(_: Components.BrMenuItem['divider']);
    /**
   * Define se o item do menu está ativo/selecionado.
Quando ativado, aplica estilos visuais para destacar o item como atual ou selecionado. @default false
   */
    set active(_: Components.BrMenuItem['active']);
    /**
   * Define o modo de exibição do item, controlando os ícones de expansão.
- `accordion`: exibe setas para cima/baixo (usado em menus de nível 0).
- `drill-down`: exibe seta para a direita (usado em menus de níveis 1+).
- `none`: não exibe ícones de expansão. @default 'none'
   */
    set displayMode(_: Components.BrMenuItem['displayMode']);
    /**
   * Indica se o item está expandido para fins de acessibilidade (ARIA).
Este estado é controlado externamente (por exemplo, por br-menu-list).
Não altera o estado visual de "active". @default false
   */
    set expanded(_: Components.BrMenuItem['expanded']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrMenuItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrMenuItem, "br-menu-item", never, { "active": { "alias": "active"; "required": false; }; "displayMode": { "alias": "displayMode"; "required": false; }; "divider": { "alias": "divider"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "href": { "alias": "href"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrMenuItem extends Components.BrMenuItem {
}
export declare class BrMenuLink {
    protected z: NgZone;
    protected el: HTMLBrMenuLinkElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-menu-link-${MenuLinkId++}`
   */
    set customId(_: Components.BrMenuLink['customId']);
    /**
   * URL do link
   */
    set url(_: Components.BrMenuLink['url']);
    /**
   * Título do link
   */
    set titulo(_: Components.BrMenuLink['titulo']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrMenuLink, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrMenuLink, "br-menu-link", never, { "customId": { "alias": "customId"; "required": false; }; "titulo": { "alias": "titulo"; "required": false; }; "url": { "alias": "url"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrMenuLink extends Components.BrMenuLink {
    /**
     * Evento emitido quando o link externo é clicado
     */
    brLinkClick: EventEmitter<CustomEvent<void>>;
}
export declare class BrMenuList {
    protected z: NgZone;
    protected el: HTMLBrMenuListElement;
    /**
   * Ícone exibido no item do menu.
Utilize esta propriedade para definir o ícone que será mostrado ao lado do label.
   */
    set icon(_: Components.BrMenuList['icon']);
    /**
   * Texto do label do item do menu.
Utilize esta propriedade para definir o texto que será exibido no item do menu.
   */
    set label(_: Components.BrMenuList['label']);
    /**
   * Nível do menu na hierarquia de navegação.
Utilizado para determinar o comportamento do menu (acordeão para nível 0, drill-down para níveis superiores). @default 0
   */
    set menuLevel(_: Components.BrMenuList['menuLevel']);
    /**
   * Define se o item deve exibir um divisor visual.
Quando ativado, adiciona uma linha separadora para organizar visualmente os itens do menu. @default false
   */
    set divider(_: Components.BrMenuList['divider']);
    /**
   * Define se o menu-list inicia expandido.
Útil para manter agrupamentos abertos por padrão no menu contextual. @default false
   */
    set expanded(_: Components.BrMenuList['expanded']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrMenuList, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrMenuList, "br-menu-list", never, { "divider": { "alias": "divider"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "label": { "alias": "label"; "required": false; }; "menuLevel": { "alias": "menuLevel"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrMenuList extends Components.BrMenuList {
    /**
     * Emitido quando um folder é expandido ou recolhido no nível 0 (comportamento acordeão).
     */
    folderToggled: EventEmitter<CustomEvent<boolean>>;
    /**
     * Emitido quando navegando para um submenu nos níveis 1+ (comportamento drill-down).
     */
    navigateToSubmenu: EventEmitter<CustomEvent<{
        element: HTMLElement;
        label: string;
    }>>;
}
export declare class BrMenuLogo {
    protected z: NgZone;
    protected 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. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrMenuLogo['customId']);
    /**
   * URL da imagem
   */
    set src(_: Components.BrMenuLogo['src']);
    /**
   * Texto alternativo da imagem
   */
    set alt(_: Components.BrMenuLogo['alt']);
    /**
   * Largura da imagem (com unidade, ex: '100px', '50%')
   */
    set width(_: Components.BrMenuLogo['width']);
    /**
   * Altura da imagem (com unidade, ex: '80px', 'auto')
   */
    set height(_: Components.BrMenuLogo['height']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrMenuLogo, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrMenuLogo, "br-menu-logo", never, { "alt": { "alias": "alt"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "height": { "alias": "height"; "required": false; }; "src": { "alias": "src"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrMenuLogo extends Components.BrMenuLogo {
}
export declare class BrMenuSocial {
    protected z: NgZone;
    protected el: HTMLBrMenuSocialElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrMenuSocial['customId']);
    /**
   * URL do link
   */
    set url(_: Components.BrMenuSocial['url']);
    /**
   * Rótulo para acessibilidade
   */
    set ariaLabel(_: Components.BrMenuSocial['ariaLabel']);
    /**
   * Ícone da rede social
   */
    set icon(_: Components.BrMenuSocial['icon']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrMenuSocial, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrMenuSocial, "br-menu-social", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "url": { "alias": "url"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrMenuSocial extends Components.BrMenuSocial {
    /**
     * Evento emitido quando o link de rede social é clicado
     */
    brSocialClick: EventEmitter<CustomEvent<void>>;
}
export declare class BrMessage {
    protected z: NgZone;
    protected el: HTMLBrMessageElement;
    /**
   * Define o título da mensagem, que é exibido no início, acima da mensagem principal.
Este título serve para destacar a mensagem textual. Não é aplicável para mensagens do tipo feedback.
   */
    set messageTitle(_: Components.BrMessage['messageTitle']);
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-message-${messageId++}`
   */
    set customId(_: Components.BrMessage['customId']);
    /**
   * Define o texto da mensagem que será exibido.
Este é o conteúdo principal da mensagem. A propriedade `message` é obrigatória e deve ser fornecida para que a mensagem apareça.
   */
    set message(_: Components.BrMessage['message']);
    /**
   * Se definido como verdadeiro, o título da mensagem será exibido na mesma linha que a mensagem principal.
Isso pode ser útil para criar um layout onde o título e a mensagem estão alinhados horizontalmente. @default false
   */
    set isInline(_: Components.BrMessage['isInline']);
    /**
   * Se definido como verdadeiro, um botão de fechar será exibido para permitir que o usuário feche a mensagem.
O fechamento emitirá o evento `brDidClose`, mas não removerá automaticamente o componente do DOM, a menos que a propriedade `autoRemove` também esteja definida como `true`.
Este recurso não está disponível para mensagens do tipo feedback. @default false
   */
    set isClosable(_: Components.BrMessage['isClosable']);
    /**
   * Controla o comportamento do fechamento do componente quando `isClosable` é verdadeiro.
- Se definido como `true`, o componente será automaticamente removido do DOM ao clicar no botão de fechar.
- Se definido como `false`, o componente permanecerá no DOM e apenas emitirá o evento `brDidClose`.

Esta propriedade não tem efeito se `isClosable` for `false`.
O valor padrão é `false`. @default false
   */
    set autoRemove(_: Components.BrMessage['autoRemove']);
    /**
   * Se definido como verdadeiro, um ícone associado à mensagem será exibido.
Use esta propriedade para mostrar ou ocultar o ícone da mensagem conforme necessário. @default false
   */
    set showIcon(_: Components.BrMessage['showIcon']);
    /**
   * Define se a mensagem é do tipo feedback, geralmente usada para fornecer contexto adicional sobre ações do usuário.
Exemplos incluem mensagens de validação em campos de formulário. Não disponível para mensagens que não sejam de feedback. @default false
   */
    set isFeedback(_: Components.BrMessage['isFeedback']);
    /**
   * Define o estado do message.
Os possíveis valores são:
- 'info': Mensagem informativa.
- 'warning': Mensagem de aviso.
- 'danger': Mensagem de erro ou alerta.
- 'success': Mensagem de sucesso.
O valor padrão é 'info'. @default 'info'
   */
    set state(_: Components.BrMessage['state']);
    /**
   * Define um rótulo customizado para leitores de tela.
Se não fornecido, será gerado automaticamente baseado no estado da mensagem.
Exemplo: "Mensagem de sucesso", "Mensagem de erro", etc. @default ''
   */
    set ariaLabel(_: Components.BrMessage['ariaLabel']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrMessage, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrMessage, "br-message", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "autoRemove": { "alias": "autoRemove"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "isClosable": { "alias": "isClosable"; "required": false; }; "isFeedback": { "alias": "isFeedback"; "required": false; }; "isInline": { "alias": "isInline"; "required": false; }; "message": { "alias": "message"; "required": false; }; "messageTitle": { "alias": "messageTitle"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrMessage extends Components.BrMessage {
    /**
     * Evento emitido quando o usuário fecha a mensagem, se closable for true.
     */
    brDidClose: EventEmitter<CustomEvent<any>>;
}
export declare class BrModal {
    protected z: NgZone;
    protected el: HTMLBrModalElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId('modal')
   */
    set customId(_: Components.BrModal['customId']);
    /**
   * O texto do título a ser exibido no cabeçalho do modal. Usado quando o slot `header` não é fornecido.
   */
    set titleText(_: Components.BrModal['titleText']);
    /**
   * Controla a visibilidade do modal. @default false
   */
    set show(_: Components.BrModal['show']);
    /**
   * Define o comportamento de fechamento do modal.

- `true`: O modal fecha automaticamente ao clicar no botão fechar.
- `false`: O modal emite `brModalBeforeClose` mas não fecha, permitindo a implementação de lógica customizada (validação, confirmação, etc.) antes do fechamento. O desenvolvedor deve
  controlar manualmente o fechamento. @default false
   */
    set autoClose(_: Components.BrModal['autoClose']);
    /**
   * Seletor CSS do elemento que deve receber foco quando o modal é aberto (ex: `"#meu-elemento"`).
   */
    set initialFocusSelector(_: Components.BrModal['initialFocusSelector']);
    /**
   * Define o tamanho (largura) do modal. @default 'medium'
   */
    set size(_: Components.BrModal['size']);
    /**
   * Se `true`, habilita a rolagem interna do conteúdo do modal. @default false
   */
    set scrollable(_: Components.BrModal['scrollable']);
    /**
   * Define o alinhamento do conteúdo do rodapé (slot="footer"). @default 'center'
   */
    set alignFooter(_: Components.BrModal['alignFooter']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrModal, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrModal, "br-modal", never, { "alignFooter": { "alias": "alignFooter"; "required": false; }; "autoClose": { "alias": "autoClose"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "initialFocusSelector": { "alias": "initialFocusSelector"; "required": false; }; "scrollable": { "alias": "scrollable"; "required": false; }; "show": { "alias": "show"; "required": false; }; "size": { "alias": "size"; "required": false; }; "titleText": { "alias": "titleText"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrModal extends Components.BrModal {
    /**
     * Evento emitido quando o modal é aberto (quando `show` muda de `false` para `true`).
     */
    brModalOpen: EventEmitter<CustomEvent<void>>;
    /**
     * Evento emitido após o modal ser fechado (quando `show` muda de `true` para `false`).
     */
    brModalClose: EventEmitter<CustomEvent<void>>;
    /**
     * Evento emitido antes do fechamento do modal (quando o botão X é clicado).
  Se autoClose está desativado, o desenvolvedor deve fechar manualmente o modal após este evento.
  Se autoClose está ativado, o modal fecha automaticamente após este evento.
     */
    brModalBeforeClose: EventEmitter<CustomEvent<void>>;
    /**
     * Evento emitido após o modal estar completamente aberto e com o foco estabilizado
  dentro dele. Complementa `brModalOpen` (que dispara imediatamente ao abrir):
  use `brModalOpened` quando precisar interagir com o modal já pronto.
     */
    brModalOpened: EventEmitter<CustomEvent<void>>;
}
export declare class BrPagination {
    protected z: NgZone;
    protected el: HTMLBrPaginationElement;
    /**
   * Define se a paginação usará um esquema de cores escuro.
Quando definido como `dark`, aplica a classe `dark-mode` ao container principal.
   */
    set colorMode(_: Components.BrPagination['colorMode']);
    /**
   * Identificador único; gerado automaticamente quando omitido. @default Helpers.generateUniqueId('br-pagination')
   */
    set customId(_: Components.BrPagination['customId']);
    /**
   * Quantidade total de páginas (mínimo 1). @default 1
   */
    set total(_: Components.BrPagination['total']);
    /**
   * Página atual (1-indexada). Valores fora do intervalo serão ajustados. @default 1
   */
    set current(_: Components.BrPagination['current']);
    /**
   * Rótulo acessível do container `nav`.
Se não fornecido, será gerado automaticamente um rótulo descritivo e único
no momento da renderização (ex.: "Paginação: página 2 de 10").
   */
    set ariaLabel(_: Components.BrPagination['ariaLabel']);
    /**
   * Rótulo acessível do botão de página anterior. @default 'Voltar página'
   */
    set previousLabel(_: Components.BrPagination['previousLabel']);
    /**
   * Rótulo acessível do botão de próxima página. @default 'Página seguinte'
   */
    set nextLabel(_: Components.BrPagination['nextLabel']);
    /**
   * Rótulo acessível do botão de reticências que abre a lista de páginas ocultas. @default 'Abrir ou fechar a lista de paginação'
   */
    set ellipsisLabel(_: Components.BrPagination['ellipsisLabel']);
    /**
   * Ajusta a densidade da paginação, alterando o espaçamento interno para um visual mais compacto ou mais expandido. @default 'medium'
   */
    set density(_: Components.BrPagination['density']);
    /**
   * Variante de renderização do componente.
- `default`: paginação numérica (padrão)
- `contextual`: paginação contextual com seletores e informação de itens @default 'default'
   */
    set variant(_: Components.BrPagination['variant']);
    /**
   * Total de itens (aplicável na variante contextual).
   */
    set totalItems(_: Components.BrPagination['totalItems']);
    /**
   * Itens por página (aplicável na variante contextual). @default 10
   */
    set perPage(_: Components.BrPagination['perPage']);
    /**
   * Opções disponíveis de itens por página (variante contextual). @default [10, 20, 30]
   */
    set perPageOptions(_: Components.BrPagination['perPageOptions']);
    /**
   * Rótulo do seletor de itens por página (variante contextual). @default 'Exibir'
   */
    set perPageLabel(_: Components.BrPagination['perPageLabel']);
    /**
   * Rótulo do seletor "ir para página" (variante contextual). @default 'Página'
   */
    set goToPageLabel(_: Components.BrPagination['goToPageLabel']);
    /**
   * Sufixo textual para a informação de quantidade de itens (variante contextual). @default 'itens'
   */
    set itemsText(_: Components.BrPagination['itemsText']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrPagination, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrPagination, "br-pagination", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "colorMode": { "alias": "colorMode"; "required": false; }; "current": { "alias": "current"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "ellipsisLabel": { "alias": "ellipsisLabel"; "required": false; }; "goToPageLabel": { "alias": "goToPageLabel"; "required": false; }; "itemsText": { "alias": "itemsText"; "required": false; }; "nextLabel": { "alias": "nextLabel"; "required": false; }; "perPage": { "alias": "perPage"; "required": false; }; "perPageLabel": { "alias": "perPageLabel"; "required": false; }; "perPageOptions": { "alias": "perPageOptions"; "required": false; }; "previousLabel": { "alias": "previousLabel"; "required": false; }; "total": { "alias": "total"; "required": false; }; "totalItems": { "alias": "totalItems"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrPagination extends Components.BrPagination {
    /**
     * Emite quando a página muda por interação do usuário.
     */
    pageChange: EventEmitter<CustomEvent<{
        page: number;
    }>>;
    /**
     * Emite quando o valor de itens por página é alterado (variante contextual).
     */
    perPageChange: EventEmitter<CustomEvent<{
        perPage: number;
    }>>;
}
export declare class BrRadio {
    protected z: NgZone;
    protected el: HTMLBrRadioElement;
    /**
   * Define o estado de seleção do radio.
Se definido como verdadeiro, o radio estará marcado. Caso contrário, estará desmarcado. @default false
   */
    set checked(_: Components.BrRadio['checked']);
    /**
   * Desativa o radio, tornando-o não interativo. @default false
   */
    set disabled(_: Components.BrRadio['disabled']);
    /**
   * Indica a validade do radio.
Se não for especificado, o valor padrão é `null`, indicando que a validade não foi definida.
   */
    set state(_: Components.BrRadio['state']);
    /**
   * Define se o label associado ao radio deve ser oculto.
Se definido como verdadeiro, o texto do label será oculto, mas o radio ainda estará visível e funcional. @default false
   */
    set hasHiddenLabel(_: Components.BrRadio['hasHiddenLabel']);
    /**
   * Identificador único; gerado automaticamente quando omitido. @default Helpers.generateUniqueId('br-radio')
   */
    set customId(_: Components.BrRadio['customId']);
    /**
   * Define o nome do radio, que é utilizado para agrupar radios em formulários e identificar o campo.
O valor é obrigatório e deve ser fornecido para garantir o correto funcionamento em formulários.
   */
    set name(_: Components.BrRadio['name']);
    /**
   * Texto descritivo exibido à direita do radio.
Caso um slot seja utilizado para fornecer um texto alternativo, o valor desta propriedade será ignorado.
   */
    set label(_: Components.BrRadio['label']);
    /**
   * Define o valor associado ao radio quando ele faz parte de um formulário nativo (`<form>`).
Esse valor é enviado com o formulário quando o radio está selecionado.
**Nota:** Esta propriedade não deve ser utilizada para determinar se o radio está selecionado; para verificar o estado de seleção, use a propriedade `checked`.
   */
    set value(_: Components.BrRadio['value']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrRadio, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrRadio, "br-radio", never, { "checked": { "alias": "checked"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hasHiddenLabel": { "alias": "hasHiddenLabel"; "required": false; }; "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "state": { "alias": "state"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrRadio extends Components.BrRadio {
    /**
     * Disparado depois que o valor do `checked` foi alterado
     */
    checkedChange: EventEmitter<CustomEvent<boolean>>;
}
export declare class BrScrim {
    protected z: NgZone;
    protected el: HTMLBrScrimElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrScrim['customId']);
    /**
   * Ativa/desativa o scrim @default false
   */
    set isOpen(_: Components.BrScrim['isOpen']);
    /**
   * Posiciona o conteúdo no topo, centro, direita, esquerda, abaixo dentro do scrim
   */
    set positionContent(_: Components.BrScrim['positionContent']);
    /**
   * Desativa o fechamento do scrim ao ser clicado @default false
   */
    set disableCloseOnClick(_: Components.BrScrim['disableCloseOnClick']);
    /**
   * Define o valor de z-index do scrim @default null
   */
    set zIndex(_: Components.BrScrim['zIndex']);
    /**
   * Cor de fundo personalizada para o scrim.
Aceita os seguintes formatos de cor:
- Cores nomeadas do CSS: 'red', 'blue', 'green', 'yellow', etc.
- Códigos hexadecimais: '#ff0000', '#00ff00', '#0000ff', etc.
- Valores RGB: 'rgb(255, 0, 0)', 'rgb(0, 255, 0)', etc.
- Valores RGBA: 'rgba(255, 0, 0, 0.5)', 'rgba(0, 255, 0, 0.8)', etc.
- Valores HSL: 'hsl(0, 100%, 50%)', 'hsl(120, 100%, 50%)', etc.
- Valores HSLA: 'hsla(0, 100%, 50%, 0.5)', 'hsla(240, 100%, 50%, 0.7)', etc.
Se não especificada, usa a cor padrão do tema. @default null
   */
    set bgColor(_: Components.BrScrim['bgColor']);
    /**
   * Define a opacidade personalizada do scrim @default null
   */
    set customOpacity(_: Components.BrScrim['customOpacity']);
    /**
   * Define o modo de exibição do scrim:
- `'fullscreen'`: Ocupa toda a tela (`position: fixed`). (_padrão_)
- `'parent'`: Ocupa apenas o elemento pai (`position: absolute`).
  O elemento pai deve ter `position: relative` ou outro valor diferente de `static`.

Para a variante `'legibility'`, este atributo é ignorado: o posicionamento é sempre
calculado automaticamente a partir das coordenadas do elemento pai. @default 'fullscreen'
   */
    set displayMode(_: Components.BrScrim['displayMode']);
    /**
   * Define a estratégia de manipulação de rolagem quando scrim está aberto
- 'block': Impede a rolagem completamente
- 'close': Fecha o scrim quando ocorre rolagem
   */
    set scrollStrategy(_: Components.BrScrim['scrollStrategy']);
    /**
   * Determina quanto de rolagem (em pixels) é necessário para acionar a ação de fechamento automático do scrim. @default 50
   */
    set scrollThreshold(_: Components.BrScrim['scrollThreshold']);
    /**
   * Define o seletor para o elemento activator.
Nota: O slot 'activator' tem prioridade sobre esta propriedade. @default null
   */
    set activator(_: Components.BrScrim['activator']);
    /**
   * Define um rótulo acessível personalizado para o diálogo.
Se não fornecido, será usado "Conteúdo do diálogo" como padrão. @default null
   */
    set ariaLabel(_: Components.BrScrim['ariaLabel']);
    /**
   * Define a variante semântica do scrim
- `'focus'`: Redireciona o foco hierárquico do usuário. Cor #000000 com opacidade 40%. (_padrão_)
- `'spotlight'`: Scrim vazado — destaca um elemento específico criando uma fresta no overlay.
  Aplica as mesmas cores da variante `'focus'`. Use `spotlightTargetId` para indicar o elemento a ser destacado.
- `'legibility'`: Melhora o contraste e leitura de texto sobre superfícies. Cor #000000 com opacidade 64%.
  Para cobertura parcial, use `legibilityAnchor` + `legibilitySize`.
  Para gradiente suave, use `bgColor` com um valor de gradiente CSS e `customOpacity="1"`,
  ex.: `bg-color="linear-gradient(to top, rgba(0,0,0,0.64), transparent)"`..

Quando definida, aplica automaticamente as especificações de cor e opacidade do Design System.
As propriedades `bgColor` e `customOpacity` têm prioridade e sobrepõem os valores da variante. @default 'focus'
   */
    set variant(_: Components.BrScrim['variant']);
    /**
   * Define a borda de ancoragem da faixa de cobertura da variante `legibility`.

Controla de qual borda (ou centro) do elemento a máscara de overlay cresce,
tendo seu tamanho determinado por `legibilitySize`.

- `'top'`: faixa ancorada na borda superior, cresce para baixo.
- `'bottom'`: faixa ancorada na borda inferior, cresce para cima.
- `'left'`: faixa ancorada na borda esquerda, cresce para a direita.
- `'right'`: faixa ancorada na borda direita, cresce para a esquerda.
- `'center'`: faixa centralizada verticalmente no elemento.

Quando `legibilitySize` é `null`, a máscara ocupa 100% independentemente
da âncora definida, equivalendo a uma cobertura total.

Só tem efeito quando `variant="legibility"`. @default 'bottom'
   */
    set legibilityAnchor(_: Components.BrScrim['legibilityAnchor']);
    /**
   * Define o tamanho da faixa de cobertura da variante `legibility`, usado em
conjunto com `legibilityAnchor`.

Aceita qualquer valor CSS de comprimento válido:
- Percentual relativo ao elemento pai: `'40%'`, `'75%'`
- Comprimento absoluto: `'120px'`, `'8rem'`, `'6em'`
- Função CSS: `'calc(100% - 2rem)'`

Quando `null` (padrão), a máscara ocupa **100%** da dimensão relevante:
- **altura** para âncoras `top`, `bottom` e `center`
- **largura** para âncoras `left` e `right`

Só tem efeito quando `variant="legibility"` está definido. @default null
   */
    set legibilitySize(_: Components.BrScrim['legibilitySize']);
    /**
   * Ativa o modo de scrim vazado (variante 'spotlight'), criando uma área de fresta no overlay
que destaca o elemento referenciado pelo seletor CSS fornecido. @default null
   */
    set spotlightTargetId(_: Components.BrScrim['spotlightTargetId']);
    /**
   * Espaçamento interno (em pixels) ao redor da área de fresta no scrim vazado. @default 8
   */
    set spotlightPadding(_: Components.BrScrim['spotlightPadding']);
    /**
   * Define a forma da área de fresta no scrim vazado.
- 'rect': Retangular com bordas retas.
- 'rounded': Retangular com bordas arredondadas (border-radius de 8px).
- 'circle': Elipse inscrita na área do elemento alvo. @default 'rect'
   */
    set spotlightShape(_: Components.BrScrim['spotlightShape']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrScrim, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrScrim, "br-scrim", never, { "activator": { "alias": "activator"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "bgColor": { "alias": "bgColor"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "customOpacity": { "alias": "customOpacity"; "required": false; }; "disableCloseOnClick": { "alias": "disableCloseOnClick"; "required": false; }; "displayMode": { "alias": "displayMode"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "legibilityAnchor": { "alias": "legibilityAnchor"; "required": false; }; "legibilitySize": { "alias": "legibilitySize"; "required": false; }; "positionContent": { "alias": "positionContent"; "required": false; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; }; "scrollThreshold": { "alias": "scrollThreshold"; "required": false; }; "spotlightPadding": { "alias": "spotlightPadding"; "required": false; }; "spotlightShape": { "alias": "spotlightShape"; "required": false; }; "spotlightTargetId": { "alias": "spotlightTargetId"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrScrim extends Components.BrScrim {
    /**
     * Indica que o scrim foi aberto.
     */
    brScrimOpen: EventEmitter<CustomEvent<void>>;
    /**
     * Indica que o scrim foi fechado
     */
    brScrimClose: EventEmitter<CustomEvent<void>>;
}
export declare class BrSelect {
    protected z: NgZone;
    protected el: HTMLBrSelectElement;
    /**
   * Rótulo que indica o tipo de informação que deve ser selecionada.
   */
    set label(_: Components.BrSelect['label']);
    /**
   * Texto auxiliar exibido antes de uma seleção. @default ''
   */
    set placeholder(_: Components.BrSelect['placeholder']);
    /**
   * Habilita o modo múltiplo para selecionar várias opções. @default false
   */
    set isMultiple(_: Components.BrSelect['isMultiple']);
    /**
   * Controla se o dropdown permanece aberto após selecionar opções.
Quando `true`, permite seleção sequencial sem reabrir a lista. @default false
   */
    set keepOpenOnSelect(_: Components.BrSelect['keepOpenOnSelect']);
    /**
   * Define as opções disponíveis no componente de seleção.
Se uma string for fornecida, ela será convertida internamente para um array via `JSON.parse`. Caso o formato seja inválido, um erro será registrado e as opções serão definidas como um array vazio.
Exemplo de uso:
```typescript
options='[{"label": "Sim", "value": "1"}, {"label": "Não", "value": "0"}]'
// ou
options=[{ label: "Sim", value: "1" }, { label: "Não", value: "0" }]
``` @default []
   */
    set options(_: Components.BrSelect['options']);
    /**
   * Rótulo para selecionar todas as opções. @default 'Selecionar todos'
   */
    set selectAllLabel(_: Components.BrSelect['selectAllLabel']);
    /**
   * Rótulo para desmarcar todas as opções. @default 'Desselecionar todos'
   */
    set unselectAllLabel(_: Components.BrSelect['unselectAllLabel']);
    /**
   * Exibe o ícone de busca no campo de entrada. @default false
   */
    set showSearchIcon(_: Components.BrSelect['showSearchIcon']);
    /**
   * Indica se a listagem de itens do select está expandida @default false
   */
    set isOpen(_: Components.BrSelect['isOpen']);
    /**
   * Exibe o rótulo e o controle em linha (ao lado), ao invés de empilhados.
Útil para casos contextuais como paginação. @default false
   */
    set isInline(_: Components.BrSelect['isInline']);
    /**
   * Largura do campo de entrada interno (por exemplo, '88px').
Quando definido, sobrescreve a largura padrão de 100% do input.
   */
    set inputWidth(_: Components.BrSelect['inputWidth']);
    /**
   * Desabilita a interação com o componente `br-select`.
Quando `true`, o input e as opções ficam desabilitados e não respondem a cliques ou teclas. @default false
   */
    set disabled(_: Components.BrSelect['disabled']);
    /**
   * Propaga para o input interno a remoção da borda quando desfocado. @default false
   */
    set borderless(_: Components.BrSelect['borderless']);
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-select-${selectId++}`
   */
    set customId(_: Components.BrSelect['customId']);
    /**
   * Valor selecionado (string para single, string[] para multiple)
   */
    set value(_: Components.BrSelect['value']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrSelect, "br-select", never, { "borderless": { "alias": "borderless"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "inputWidth": { "alias": "inputWidth"; "required": false; }; "isInline": { "alias": "isInline"; "required": false; }; "isMultiple": { "alias": "isMultiple"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "keepOpenOnSelect": { "alias": "keepOpenOnSelect"; "required": false; }; "label": { "alias": "label"; "required": false; }; "options": { "alias": "options"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "selectAllLabel": { "alias": "selectAllLabel"; "required": false; }; "showSearchIcon": { "alias": "showSearchIcon"; "required": false; }; "unselectAllLabel": { "alias": "unselectAllLabel"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrSelect extends Components.BrSelect {
    /**
     * Evento emitido sempre que houver atualização nos itens selecionados.
  RENOMEADO PARA valueChange para compatibilidade com ngModel.
     */
    valueChange: EventEmitter<CustomEvent<any>>;
    /**
     * Emite os dados da opção quando ela recebe foco/hover (antes da seleção).
     */
    optionHover: EventEmitter<CustomEvent<{
        label: string;
        value: string;
    }>>;
    /**
     * Dispara quando o dropdown é aberto.
     */
    opened: EventEmitter<CustomEvent<void>>;
    /**
     * Dispara quando o dropdown é fechado.
     */
    closed: EventEmitter<CustomEvent<void>>;
}
export declare class BrSelectOption {
    protected z: NgZone;
    protected el: HTMLBrSelectOptionElement;
    /**
   * Rótulo da opção. Quando omitido, o texto do slot é usado.
   */
    set label(_: Components.BrSelectOption['label']);
    /**
   * Valor da opção.
   */
    set value(_: Components.BrSelectOption['value']);
    /**
   * Indica se a opção está selecionada. @default false
   */
    set selected(_: Components.BrSelectOption['selected']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrSelectOption, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrSelectOption, "br-select-option", never, { "label": { "alias": "label"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrSelectOption extends Components.BrSelectOption {
    /**
     * Notifica o componente pai sobre mudanças de props ou conteúdo.
     */
    brSelectOptionPropsChange: EventEmitter<CustomEvent<void>>;
}
export declare class BrSignIn {
    protected z: NgZone;
    protected el: HTMLBrSignInElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrSignIn['customId']);
    /**
   * Define se o sign-in usará um esquema de cores escuro.
   */
    set colorMode(_: Components.BrSignIn['colorMode']);
    /**
   * Ajusta a densidade, alterando o espaçamento interno para um visual mais compacto ou mais expandido. @default 'medium'
   */
    set density(_: Components.BrSignIn['density']);
    /**
   * Desativa o sign-in, tornando-o não interativo. @default false
   */
    set disabled(_: Components.BrSignIn['disabled']);
    /**
   * Define a ênfase do sign-in, alterando sua aparência para criar hierarquia visual. @default 'secondary'
   */
    set emphasis(_: Components.BrSignIn['emphasis']);
    /**
   * Define o formato do sign-in. @default 'pill'
   */
    set shape(_: Components.BrSignIn['shape']);
    /**
   * URL para onde o usuário será redirecionado ao clicar. Use para login com provedores externos ou em sites tradicionais.
   */
    set href(_: Components.BrSignIn['href']);
    /**
   * Define onde abrir o link quando href é fornecido. @default '_self'
   */
    set target(_: Components.BrSignIn['target']);
    /**
   * Define o rótulo acessível do sign-in, especialmente importante para formatos circulares.
   */
    set ariaLabel(_: Components.BrSignIn['ariaLabel']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrSignIn, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrSignIn, "br-sign-in", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "colorMode": { "alias": "colorMode"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "emphasis": { "alias": "emphasis"; "required": false; }; "href": { "alias": "href"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrSignIn extends Components.BrSignIn {
}
export declare class BrSkipLink {
    protected z: NgZone;
    protected el: HTMLBrSkipLinkElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrSkipLink['customId']);
    /**
   * 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. @default 'compound'
   */
    set variant(_: Components.BrSkipLink['variant']);
    /**
   * 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. @default 'top-left'
   */
    set position(_: Components.BrSkipLink['position']);
    /**
   * Define o z-index do componente.
Controla a ordem de empilhamento do componente na página. @default null
   */
    set zIndex(_: Components.BrSkipLink['zIndex']);
    /**
   * 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.
   */
    set showItemCount(_: Components.BrSkipLink['showItemCount']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrSkipLink, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrSkipLink, "br-skip-link", never, { "customId": { "alias": "customId"; "required": false; }; "position": { "alias": "position"; "required": false; }; "showItemCount": { "alias": "showItemCount"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrSkipLink extends Components.BrSkipLink {
    /**
     * Evento emitido quando um item do skiplink é ativado.
  O evento contém informações sobre o item acionado e o elemento target.
     */
    brSkiplinkNavigation: EventEmitter<CustomEvent<{
        itemId: string;
        target: string;
    }>>;
    /**
     * Evento emitido quando o skiplink se torna visível.
     */
    brDidShow: EventEmitter<CustomEvent<void>>;
    /**
     * Evento emitido quando o skiplink se torna oculto.
     */
    brDidHide: EventEmitter<CustomEvent<void>>;
}
export declare class BrSkiplinkItem {
    protected z: NgZone;
    protected el: HTMLBrSkiplinkItemElement;
    /**
   * ID do elemento de destino ou seletor CSS.
Este é o elemento para o qual o usuário será levado ao ativar este item.
   */
    set target(_: Components.BrSkiplinkItem['target']);
    /**
   * 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.
   */
    set keyNumber(_: Components.BrSkiplinkItem['keyNumber']);
    /**
   * ID personalizado.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrSkiplinkItem['customId']);
    /**
   * 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. @default false
   */
    set hideTag(_: Components.BrSkiplinkItem['hideTag']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrSkiplinkItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrSkiplinkItem, "br-skiplink-item", never, { "customId": { "alias": "customId"; "required": false; }; "hideTag": { "alias": "hideTag"; "required": false; }; "keyNumber": { "alias": "keyNumber"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrSkiplinkItem extends Components.BrSkiplinkItem {
    /**
     * Evento emitido quando o item é clicado/ativado.
  O evento contém informações sobre o item e o target.
     */
    brSkiplinkItemClick: EventEmitter<CustomEvent<{
        itemId: string;
        target: string;
    }>>;
    /**
     * Evento emitido quando o item recebe foco.
     */
    brSkiplinkItemFocus: EventEmitter<CustomEvent<{
        itemId: string;
    }>>;
}
export declare class BrStep {
    protected z: NgZone;
    protected el: HTMLBrStepElement;
    /**
   * propriedade responsável por definir a orientação do componente Step @default 'horizontal'
   */
    set layout(_: Components.BrStep['layout']);
    /**
   *
define o passo que começará destacado @default '0'
   */
    set initialStep(_: Components.BrStep['initialStep']);
    /**
   *
Propriedade que  define a posição onde o texto de destaque,label, ficará localizado no stepItem @default 'bottom'
   */
    set labelPosition(_: Components.BrStep['labelPosition']);
    /**
   *
Propriedade que define o tipo de conteúdo a ser exibido dentro do componente step  e stepItem @default 'default'
   */
    set contentType(_: Components.BrStep['contentType']);
    /**
   *
Propriedade que define o tipo de comportamento que o componente Step deverá seguir @default 'step'
   */
    set mode(_: Components.BrStep['mode']);
    /**
   *
Propriedade que define o tipo de progressão de etapas que o step vai executar @default 'nonlinear'
   */
    set progressionType(_: Components.BrStep['progressionType']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrStep, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrStep, "br-step", never, { "contentType": { "alias": "contentType"; "required": false; }; "initialStep": { "alias": "initialStep"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "progressionType": { "alias": "progressionType"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrStep extends Components.BrStep {
    /**
     * Emite um evento após o componente ter sido carregado pela primeira vez.
  Utilize este evento para realizar ações que devem ocorrer depois que o componente foi totalmente carregado.
  Consulte a documentação do [Stencil](https://stenciljs.com/docs/component-lifecycle#componentdidload) para mais detalhes.
     */
    brDidLoad: EventEmitter<CustomEvent<void>>;
    /**
     * Emite um evento antes do componente ser renderizado pela primeira vez, permitindo a preparação de dados ou inicializações necessárias.
  Utilize este evento para realizar ações que devem ocorrer depois que o componente foi totalmente carregado.
  Consulte a documentação do [Stencil](https://stenciljs.com/docs/component-lifecycle#componentdwillLoad) para mais detalhes.
     */
    brWillLoad: EventEmitter<CustomEvent<void>>;
    /**
     * Emite um evento para indicar se o componente deve ser atualizado ou não.
  Este evento é chamado antes de qualquer atualização do componente para decidir se a atualização deve prosseguir.
  Consulte a documentação do [Stencil](https://stenciljs.com/docs/component-lifecycle#componentshouldupdate) para mais detalhes.
     */
    brShouldUpdate: EventEmitter<CustomEvent<void>>;
    /**
     * Emite um evento quando o step ativo muda.
  O evento carrega o índice do novo step ativo (0-based).
     */
    brStepChange: EventEmitter<CustomEvent<{
        activeStep: number;
    }>>;
}
export declare class BrStepItem {
    protected z: NgZone;
    protected el: HTMLBrStepItemElement;
    /**
   * Propriedade que define o conteúdo do texto auxiliar de realce do item de Step. @default ''
   */
    set label(_: Components.BrStepItem['label']);
    /**
   * Propriedade que define o tipo de ícone de destaque exibido pelo item Step, com quatro opções disponíveis: "success", "info", "danger" e "warning".
   */
    set highlight(_: Components.BrStepItem['highlight']);
    /**
   * Propriedade que define se o item Step está com estado ativo. @default false
   */
    set active(_: Components.BrStepItem['active']);
    /**
   * Propriedade que define se o item Step está com estado desativado. @default false
   */
    set disabled(_: Components.BrStepItem['disabled']);
    /**
   * Propriedade Define o nome do ícone do componente BRIcon que será exibido como conteúdo do step item, propriedade funciona apenas quando o state contentType assume o valor br-icon. @default ''
   */
    set brIconName(_: Components.BrStepItem['brIconName']);
    /**
   * Propriedade Define o nome do ícone o texto de acessibilidade apresentando quando o tipo de conteúdo for o br-icon @default ''
   */
    set brIconAria(_: Components.BrStepItem['brIconAria']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrStepItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrStepItem, "br-step-item", never, { "active": { "alias": "active"; "required": false; }; "brIconAria": { "alias": "brIconAria"; "required": false; }; "brIconName": { "alias": "brIconName"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "highlight": { "alias": "highlight"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrStepItem extends Components.BrStepItem {
    /**
     * Emite um evento após o componente ter sido carregado pela primeira vez.
  Utilize este evento para realizar ações que devem ocorrer antes que o componente seja renderizado ou atualizado.
  Consulte a documentação do [Stencil](https://stenciljs.com/docs/component-lifecycle#componentdidload) para mais detalhes.
     */
    brWillRender: EventEmitter<CustomEvent<void>>;
    /**
     * Emite um evento após o componente ter sido carregado pela primeira vez.
  Utilize este evento para realizar ações que devem ocorrer antes que o componente seja renderizado ou atualizado.
  Consulte a documentação do [Stencil](https://stenciljs.com/docs/component-lifecycle#componentdidload) para mais detalhes.
     */
    brDidRender: EventEmitter<CustomEvent<void>>;
}
export declare class BrSwitch {
    protected z: NgZone;
    protected el: HTMLBrSwitchElement;
    /**
   * Desativa o switch, tornando-o não interativo. @default false
   */
    set disabled(_: Components.BrSwitch['disabled']);
    /**
   * Define o estado de seleção do checkbox.
Se definido como verdadeiro, o checkbox estará marcado. Caso contrário, estará desmarcado. @default false
   */
    set checked(_: Components.BrSwitch['checked']);
    /**
   * Identificador único; gerado automaticamente quando omitido. @default Helpers.generateUniqueId('br-switch')
   */
    set customId(_: Components.BrSwitch['customId']);
    /**
   * Texto descritivo.
Caso um slot seja utilizado para fornecer um texto alternativo, o valor desta propriedade será ignorado.
   */
    set label(_: Components.BrSwitch['label']);
    /**
   * Posição do rótulo em relação ao switch. @default 'left'
   */
    set labelPosition(_: Components.BrSwitch['labelPosition']);
    /**
   * Texto exibido quando o switch está ativado.
   */
    set labelOn(_: Components.BrSwitch['labelOn']);
    /**
   * Texto exibido quando o switch está desativado.
   */
    set labelOff(_: Components.BrSwitch['labelOff']);
    /**
   * Adiciona um ícone ao switch para indicar a mudança de estado. @default false
   */
    set hasIcon(_: Components.BrSwitch['hasIcon']);
    /**
   * Define o nome do switch, que é utilizado para agrupar switches em formulários e identificar o campo.
O valor é obrigatório e deve ser fornecido para garantir o correto funcionamento em formulários.
   */
    set name(_: Components.BrSwitch['name']);
    /**
   * Define o valor associado ao switch quando ele faz parte de um formulário nativo (`<form>`).
Esse valor é enviado com o formulário quando o switch está selecionado.
**Nota:** Esta propriedade não deve ser utilizada para determinar se o switch está selecionado; para verificar o estado de seleção, use a propriedade `checked`.
   */
    set value(_: Components.BrSwitch['value']);
    /**
   * O ajuste da densidade consiste em aumentar ou reduzir a área de interação do switch. Quanto menor for a densidade, maior a área de interação. @default 'medium'
   */
    set density(_: Components.BrSwitch['density']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrSwitch, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrSwitch, "br-switch", never, { "checked": { "alias": "checked"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hasIcon": { "alias": "hasIcon"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelOff": { "alias": "labelOff"; "required": false; }; "labelOn": { "alias": "labelOn"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrSwitch extends Components.BrSwitch {
    /**
     * Disparado depois que o valor do `checked` foi alterado
     */
    checkedChange: EventEmitter<CustomEvent<boolean>>;
}
export declare class BrTab {
    protected z: NgZone;
    protected el: HTMLBrTabElement;
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrTab['customId']);
    /**
   * A propriedade 'density' define a densidade do componente. @default 'medium'
   */
    set density(_: Components.BrTab['density']);
    /**
   * Define se o Tab usará um esquema de cores escuro.
   */
    set colorMode(_: Components.BrTab['colorMode']);
    /**
   * Label de acessibilidade para a navegação das tabs @default 'Abas de Navegação'
   */
    set label(_: Components.BrTab['label']);
    /**
   * Define o alinhamento horizontal dos itens da tab na barra de navegação. @default 'start'
   */
    set alignItemsTab(_: Components.BrTab['alignItemsTab']);
    /**
   * Desabilita o scroll automático da área de conteúdo.
Por padrão, o scroll vertical fica apenas na região de conteúdo. @default false
   */
    set scrollDisabled(_: Components.BrTab['scrollDisabled']);
    /**
   * Define a altura máxima da área de conteúdo, ativando o scroll interno quando o conteúdo ultrapassa essa altura.
   */
    set height(_: Components.BrTab['height']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrTab, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrTab, "br-tab", never, { "alignItemsTab": { "alias": "alignItemsTab"; "required": false; }; "colorMode": { "alias": "colorMode"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "height": { "alias": "height"; "required": false; }; "label": { "alias": "label"; "required": false; }; "scrollDisabled": { "alias": "scrollDisabled"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrTab extends Components.BrTab {
    /**
     * Evento disparado quando um tab é ativado.
     */
    brTabChange: EventEmitter<CustomEvent<{
        tabId: string;
        tabIndex: number;
    }>>;
}
export declare class BrTabItem {
    protected z: NgZone;
    protected el: HTMLBrTabItemElement;
    /**
   * Identificador único do item da tab.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId()
   */
    set tabItemId(_: Components.BrTabItem['tabItemId']);
    /**
   * Define o título do item de tab que aparece no botão de navegação
   */
    set tabItemTitle(_: Components.BrTabItem['tabItemTitle']);
    /**
   * Define ícone do item de tab
   */
    set icon(_: Components.BrTabItem['icon']);
    /**
   * Define se exibe apenas o ícone, sem texto @default false
   */
    set onlyIcon(_: Components.BrTabItem['onlyIcon']);
    /**
   * Define se o item de tab está ativo/visível @default false
   */
    set isActive(_: Components.BrTabItem['isActive']);
    /**
   * Desativa o item de tab, impedindo que seja selecionado pelo usuário.
O conteúdo do painel correspondente permanece inacessível enquanto desativado. @default false
   */
    set disabled(_: Components.BrTabItem['disabled']);
    /**
   * Define contador do item de tab (exibido abaixo do botão)
   */
    set counter(_: Components.BrTabItem['counter']);
    /**
   * Define se o Tab usará um esquema de cores escuro
   */
    set colorMode(_: Components.BrTabItem['colorMode']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrTabItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrTabItem, "br-tab-item", never, { "colorMode": { "alias": "colorMode"; "required": false; }; "counter": { "alias": "counter"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "onlyIcon": { "alias": "onlyIcon"; "required": false; }; "tabItemId": { "alias": "tabItemId"; "required": false; }; "tabItemTitle": { "alias": "tabItemTitle"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrTabItem extends Components.BrTabItem {
    /**
     * Evento disparado quando as propriedades do tab-item mudam.
  O componente pai (br-tab) escuta este evento para atualizar a navegação.
     */
    brTabItemPropsChange: EventEmitter<CustomEvent<void>>;
}
export declare class BrTable {
    protected z: NgZone;
    protected 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
   */
    set columnWidth(_: Components.BrTable['columnWidth']);
    /**
   * Define a densidade da tabela. @remarks Valores aceitos:
- small
- medium
- large,@default medium
   */
    set density(_: Components.BrTable['density']);
    /**
   * Define o estilo visual dos divisores. @remarks Valores aceitos:
- solid
- dashed,@default solid
   */
    set dividerStyle(_: Components.BrTable['dividerStyle']);
    /**
   * Ativa divisores verticais entre colunas. @default false
   */
    set hasColumnDivider(_: Components.BrTable['hasColumnDivider']);
    /**
   * Ativa divisores horizontais entre linhas. @default false
   */
    set hasRowDivider(_: Components.BrTable['hasRowDivider']);
    /**
   * Define o alinhamento horizontal do conteúdo das células. @remarks Valores aceitos:
- start
- center
- end,@default start
   */
    set horizontalAlignment(_: Components.BrTable['horizontalAlignment']);
    /**
   * Define o alinhamento vertical do conteúdo das células. @remarks Valores aceitos:
- start
- center
- end,@default start
   */
    set verticalAlignment(_: Components.BrTable['verticalAlignment']);
    /**
   * 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
   */
    set overflow(_: Components.BrTable['overflow']);
    /**
   * Define o estado semântico do tooltip nas células da tabela. @remarks Valores aceitos:
- info
- warning
- danger
- success,@default info
   */
    set tooltipState(_: Components.BrTable['tooltipState']);
    /**
   * Define o modo de resolução do tooltip nas células da tabela. @remarks Valores aceitos:
- inherit
- enabled
- disabled,@default disabled (valor efetivo)
   */
    set tooltipMode(_: Components.BrTable['tooltipMode']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrTable, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrTable, "br-table", never, { "columnWidth": { "alias": "columnWidth"; "required": false; }; "density": { "alias": "density"; "required": false; }; "dividerStyle": { "alias": "dividerStyle"; "required": false; }; "hasColumnDivider": { "alias": "hasColumnDivider"; "required": false; }; "hasRowDivider": { "alias": "hasRowDivider"; "required": false; }; "horizontalAlignment": { "alias": "horizontalAlignment"; "required": false; }; "overflow": { "alias": "overflow"; "required": false; }; "tooltipMode": { "alias": "tooltipMode"; "required": false; }; "tooltipState": { "alias": "tooltipState"; "required": false; }; "verticalAlignment": { "alias": "verticalAlignment"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrTable extends Components.BrTable {
}
export declare class BrTableBody {
    protected z: NgZone;
    protected el: HTMLBrTableBodyElement;
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrTableBody, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrTableBody, "br-table-body", never, {}, {}, never, ["*"], false, never>;
}
export declare interface BrTableBody extends Components.BrTableBody {
}
export declare class BrTableCell {
    protected z: NgZone;
    protected el: HTMLBrTableCellElement;
    /**
   * Define o alinhamento horizontal do conteúdo dentro da célula.
   */
    set horizontalAlignment(_: Components.BrTableCell['horizontalAlignment']);
    /**
   * Define o alinhamento vertical do conteúdo dentro da célula.
   */
    set verticalAlignment(_: Components.BrTableCell['verticalAlignment']);
    /**
   * Define se o conteúdo dentro da célula deve ser truncado, permitindo a herança dessa configuração para as células filhas com base no valor definido.
   */
    set overflow(_: Components.BrTableCell['overflow']);
    /**
   * Define o estado semântico do tooltip nesta célula.
   */
    set tooltipState(_: Components.BrTableCell['tooltipState']);
    /**
   * Define o modo de resolução do tooltip nesta célula.
   */
    set tooltipMode(_: Components.BrTableCell['tooltipMode']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrTableCell, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrTableCell, "br-table-cell", never, { "horizontalAlignment": { "alias": "horizontalAlignment"; "required": false; }; "overflow": { "alias": "overflow"; "required": false; }; "tooltipMode": { "alias": "tooltipMode"; "required": false; }; "tooltipState": { "alias": "tooltipState"; "required": false; }; "verticalAlignment": { "alias": "verticalAlignment"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrTableCell extends Components.BrTableCell {
    /**
     * Evento customizado emitido quando o alinhamento é alterado, permitindo que a célula reaja dinamicamente a mudanças nos tokens de alinhamento.
     */
    brAlignmentChange: EventEmitter<CustomEvent<void>>;
    /**
     * Evento customizado emitido quando a configuração de overflow é alterada, permitindo que a célula reaja dinamicamente a mudanças no token de overflow.
     */
    brOverflowChange: EventEmitter<CustomEvent<void>>;
}
export declare class BrTableHeader {
    protected z: NgZone;
    protected el: HTMLBrTableHeaderElement;
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrTableHeader, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrTableHeader, "br-table-header", never, {}, {}, never, ["*"], false, never>;
}
export declare interface BrTableHeader extends Components.BrTableHeader {
}
export declare class BrTableHeaderCell {
    protected z: NgZone;
    protected el: HTMLBrTableHeaderCellElement;
    /**
   * Define a largura da coluna.
   */
    set columnWidth(_: Components.BrTableHeaderCell['columnWidth']);
    /**
   * Define o alinhamento horizontal do conteúdo dentro da célula de cabeçalho, permitindo a herança de alinhamento para as células filhas com base no valor definido.
   */
    set horizontalAlignment(_: Components.BrTableHeaderCell['horizontalAlignment']);
    /**
   * Define o alinhamento vertical do conteúdo dentro da célula de cabeçalho, permitindo a herança de alinhamento para as células filhas com base no valor definido.
   */
    set verticalAlignment(_: Components.BrTableHeaderCell['verticalAlignment']);
    /**
   * Define se o conteúdo dentro da célula de cabeçalho deve ser truncado, permitindo a herança dessa configuração para as células filhas com base no valor definido.
   */
    set overflow(_: Components.BrTableHeaderCell['overflow']);
    /**
   * Define o estado semântico do tooltip nesta coluna/célula de cabeçalho.
   */
    set tooltipState(_: Components.BrTableHeaderCell['tooltipState']);
    /**
   * Define o modo de resolução do tooltip nesta coluna/célula de cabeçalho.
   */
    set tooltipMode(_: Components.BrTableHeaderCell['tooltipMode']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrTableHeaderCell, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrTableHeaderCell, "br-table-header-cell", never, { "columnWidth": { "alias": "columnWidth"; "required": false; }; "horizontalAlignment": { "alias": "horizontalAlignment"; "required": false; }; "overflow": { "alias": "overflow"; "required": false; }; "tooltipMode": { "alias": "tooltipMode"; "required": false; }; "tooltipState": { "alias": "tooltipState"; "required": false; }; "verticalAlignment": { "alias": "verticalAlignment"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrTableHeaderCell extends Components.BrTableHeaderCell {
    /**
     * Evento customizado emitido quando a largura da coluna é alterada, permitindo que as células reajam dinamicamente a mudanças no layout.
     */
    brColumnWidthChange: EventEmitter<CustomEvent<void>>;
    /**
     * Evento customizado emitido quando o alinhamento é alterado, permitindo que a célula de cabeçalho reaja dinamicamente a mudanças nos tokens de alinhamento.
     */
    brAlignmentChange: EventEmitter<CustomEvent<void>>;
    /**
     * Evento customizado emitido quando a configuração de overflow é alterada, permitindo que a célula de cabeçalho reaja dinamicamente a mudanças no token de overflow.
     */
    brOverflowChange: EventEmitter<CustomEvent<void>>;
}
export declare class BrTableRow {
    protected z: NgZone;
    protected el: HTMLBrTableRowElement;
    /**
   * Define o alinhamento horizontal das células dentro da linha, permitindo a herança de alinhamento para as células filhas com base no valor definido.
   */
    set horizontalAlignment(_: Components.BrTableRow['horizontalAlignment']);
    /**
   * Define o alinhamento vertical das células dentro da linha, permitindo a herança de alinhamento para as células filhas com base no valor definido.
   */
    set verticalAlignment(_: Components.BrTableRow['verticalAlignment']);
    /**
   * Define se o conteúdo dentro das células da linha deve ser truncado, permitindo a herança dessa configuração para as células filhas com base no valor definido.
   */
    set overflow(_: Components.BrTableRow['overflow']);
    /**
   * Define o estado semântico do tooltip nas células desta linha.
   */
    set tooltipState(_: Components.BrTableRow['tooltipState']);
    /**
   * Define o modo de resolução do tooltip nas células desta linha.
   */
    set tooltipMode(_: Components.BrTableRow['tooltipMode']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrTableRow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrTableRow, "br-table-row", never, { "horizontalAlignment": { "alias": "horizontalAlignment"; "required": false; }; "overflow": { "alias": "overflow"; "required": false; }; "tooltipMode": { "alias": "tooltipMode"; "required": false; }; "tooltipState": { "alias": "tooltipState"; "required": false; }; "verticalAlignment": { "alias": "verticalAlignment"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrTableRow extends Components.BrTableRow {
    /**
     * Evento customizado emitido quando o alinhamento é alterado, permitindo que as células reajam dinamicamente a mudanças nos tokens de alinhamento.
     */
    brAlignmentChange: EventEmitter<CustomEvent<void>>;
    /**
     * Evento customizado emitido quando a configuração de overflow é alterada, permitindo que as células reajam dinamicamente a mudanças no token de overflow.
     */
    brOverflowChange: EventEmitter<CustomEvent<void>>;
}
export declare class BrTag {
    protected z: NgZone;
    protected el: HTMLBrTagElement;
    /**
   * A propriedade 'label' é uma string que representa o texto a ser exibido no componente.
Ela é refletida no DOM, permitindo que alterações no valor sejam refletidas no elemento HTML correspondente. @default ''
   */
    set label(_: Components.BrTag['label']);
    /**
   * A propriedade 'iconName' define o nome do ícone que será exibido ao lado do texto.
O valor padrão é 'fa-solid:car', que corresponde a um ícone de carro da biblioteca Font Awesome. @default ''
   */
    set iconName(_: Components.BrTag['iconName']);
    /**
   * A propriedade 'name' é uma string que representa o nome do grupo da tag para seleção.
Ela é refletida no DOM, permitindo que alterações no valor sejam refletidas no elemento HTML correspondente. @default ''
   */
    set name(_: Components.BrTag['name']);
    /**
   * A tag permite seleção múltipla. @default false
   */
    set multiple(_: Components.BrTag['multiple']);
    /**
   * A tag está selecionada. @default false
   */
    set selected(_: Components.BrTag['selected']);
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default `br-tag-${tagId++}`
   */
    set customId(_: Components.BrTag['customId']);
    /**
   * A propriedade 'color' permite definir a cor do componente.
Aceita valores como 'red', 'blue', entre outros, e é refletida no DOM. @default ''
   */
    set bgColor(_: Components.BrTag['bgColor']);
    /**
   * A propriedade 'density' permite definir a densidade do componente. @default DENSITY_MEDIUM
   */
    set density(_: Components.BrTag['density']);
    /**
   * A propriedade 'shape' define o formato do componente. @default SHAPE_DEFAULT
   */
    set shape(_: Components.BrTag['shape']);
    /**
   * Transforma a tag em um indicador de status, com aparência circular.
É flexível podendo ser utilizado com label ou apenas a superfície circular (informação é transmitida por meio de cores). @default false
   */
    set status(_: Components.BrTag['status']);
    /**
   * Interação deve ser habilitada. @default false
   */
    set interaction(_: Components.BrTag['interaction']);
    /**
   * Interação de seleção deve ser habilitada. @default false
   */
    set interactionSelect(_: Components.BrTag['interactionSelect']);
    /**
   * Tag deve estar desabilitado. @default false
   */
    set disabled(_: Components.BrTag['disabled']);
    /**
   * Rótulo personalizado para leitores de tela.
Quando fornecido, substitui completamente o texto visível para usuários de leitores de tela.
Útil quando o texto visível não é suficientemente descritivo (ex: ícones, abreviações). @default null
   */
    set ariaLabel(_: Components.BrTag['ariaLabel']);
    /**
   * ID do elemento que fornece descrição adicional da tag.
Referencia um elemento na página que contém informações complementares sobre a tag.
A descrição é lida após o conteúdo principal, fornecendo contexto extra aos usuários de leitores de tela.
Exemplo: aria-describedby="help-status" onde existe <div id="help-status">Aguardando aprovação</div> @default null
   */
    set ariaDescribedby(_: Components.BrTag['ariaDescribedby']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrTag, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrTag, "br-tag", never, { "ariaDescribedby": { "alias": "ariaDescribedby"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "bgColor": { "alias": "bgColor"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "iconName": { "alias": "iconName"; "required": false; }; "interaction": { "alias": "interaction"; "required": false; }; "interactionSelect": { "alias": "interactionSelect"; "required": false; }; "label": { "alias": "label"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "name": { "alias": "name"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "status": { "alias": "status"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrTag extends Components.BrTag {
    /**
     * Evento emitido quando a tag é selecionada.
     */
    radioSelected: EventEmitter<CustomEvent<string>>;
}
export declare class BrTextarea {
    protected z: NgZone;
    protected el: HTMLBrTextareaElement;
    /**
   * Valor exibido no textarea.
Pode ser alterado pelo usuário se a propriedade `readonly` não estiver ativa.
   */
    set value(_: Components.BrTextarea['value']);
    /**
   * Texto exibido como rótulo do input.
   */
    set label(_: Components.BrTextarea['label']);
    /**
   * Texto exibido dentro do input quando está vazio, fornecendo uma dica ou sugestão ao usuário.
   */
    set placeholder(_: Components.BrTextarea['placeholder']);
    /**
   * Texto alternativo para acessibilidade quando não há label visível.
Fornece um rótulo para tecnologias assistivas sem exibir visualmente.
   */
    set ariaLabel(_: Components.BrTextarea['ariaLabel']);
    /**
   * Identificador único.
Caso não seja fornecido, um ID gerado automaticamente será usado. @default Helpers.generateUniqueId('br-textarea')
   */
    set customId(_: Components.BrTextarea['customId']);
    /**
   * Indica se o textarea está desabilitado. Quando verdadeiro, o usuário não pode interagir com o campo. @default false
   */
    set disabled(_: Components.BrTextarea['disabled']);
    /**
   * Número máximo de caracteres permitidos no textarea. Se definido como 0, não há limite. @default 0
   */
    set maxlength(_: Components.BrTextarea['maxlength']);
    /**
   * Mostra o contador com a quantidade máxima de caracteres. @default false
   */
    set showCounter(_: Components.BrTextarea['showCounter']);
    /**
   * Define o estado visual do componente, podendo ser 'danger', 'success' ou 'warning'.
   */
    set state(_: Components.BrTextarea['state']);
    /**
   * Ajusta a densidade do componente, podendo ser 'small', 'medium' ou 'large'. @default 'medium'
   */
    set density(_: Components.BrTextarea['density']);
    /**
   * Se verdadeiro, o rótulo e o input estarão na mesma linha (layout inline). @default false
   */
    set isInline(_: Components.BrTextarea['isInline']);
    /**
   * Número de linhas visíveis no textarea.
Define a altura do componente em relação ao número de linhas de texto exibidas.
   */
    set rows(_: Components.BrTextarea['rows']);
    /**
   * Número de colunas (caracteres) visíveis no textarea.
Define a largura do componente em relação ao número de caracteres por linha.
   */
    set cols(_: Components.BrTextarea['cols']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrTextarea, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrTextarea, "br-textarea", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isInline": { "alias": "isInline"; "required": false; }; "label": { "alias": "label"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "showCounter": { "alias": "showCounter"; "required": false; }; "state": { "alias": "state"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrTextarea extends Components.BrTextarea {
    /**
     * Valor atualizado do textarea
     */
    valueChange: EventEmitter<CustomEvent<string>>;
}
export declare class BrTooltip {
    protected z: NgZone;
    protected el: HTMLBrTooltipElement;
    /**
   * Identificador único do tooltip; gerado automaticamente quando omitido. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrTooltip['customId']);
    /**
   * Posição do tooltip em relação ao acionador. @default 'top'
   */
    set position(_: Components.BrTooltip['position']);
    /**
   * Tipo do tooltip: 'standard' (simples) ou 'popover' (mais rico, com fechamento por interação). @default 'standard'
   */
    set type(_: Components.BrTooltip['type']);
    /**
   * Densidade do tooltip: controla compacidade do conteúdo. @default 'medium'
   */
    set density(_: Components.BrTooltip['density']);
    /**
   * Estado visual do tooltip: 'info', 'warning', 'error', 'danger' ou 'success'. @default 'info'
   */
    set state(_: Components.BrTooltip['state']);
    /**
   * Exibe automaticamente sem interação quando true; caso contrário, depende do acionador. @default false
   */
    set isAutoVisible(_: Components.BrTooltip['isAutoVisible']);
    /**
   * Atraso em milissegundos antes de exibir. @default null
   */
    set showDelay(_: Components.BrTooltip['showDelay']);
    /**
   * Atraso em milissegundos antes de ocultar. @default null
   */
    set hideDelay(_: Components.BrTooltip['hideDelay']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrTooltip, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrTooltip, "br-tooltip", never, { "customId": { "alias": "customId"; "required": false; }; "density": { "alias": "density"; "required": false; }; "hideDelay": { "alias": "hideDelay"; "required": false; }; "isAutoVisible": { "alias": "isAutoVisible"; "required": false; }; "position": { "alias": "position"; "required": false; }; "showDelay": { "alias": "showDelay"; "required": false; }; "state": { "alias": "state"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrTooltip extends Components.BrTooltip {
    /**
     * Emitido quando o tooltip abre.
     */
    brDidOpen: EventEmitter<CustomEvent<{
        id: string;
        visible: boolean;
    }>>;
    /**
     * Emitido quando o tooltip fecha.
     */
    brDidClose: EventEmitter<CustomEvent<{
        id: string;
        visible: boolean;
    }>>;
}
export declare class BrUpload {
    protected z: NgZone;
    protected el: HTMLBrUploadElement;
    /**
   * Identificador único do componente; gerado automaticamente quando omitido. @default Helpers.generateUniqueId('br-upload')
   */
    set customId(_: Components.BrUpload['customId']);
    /**
   * Tipos de arquivo permitidos (ex.: 'image/*'). @default ''
   */
    set accept(_: Components.BrUpload['accept']);
    /**
   * Rótulo exibido acima do botão de upload. @default 'Envio de arquivo'
   */
    set label(_: Components.BrUpload['label']);
    /**
   * Lista de arquivos já enviados (para edição ou pré-visualização).
Pode ser uma string JSON ou um array de objetos IUploadFile. @default []
   */
    set uploadFiles(_: Components.BrUpload['uploadFiles']);
    /**
   * Desativa interação e seleção de arquivos quando true. @default false
   */
    set disabled(_: Components.BrUpload['disabled']);
    /**
   * Estado visual: 'info', 'warning', 'danger' ou 'success'.
   */
    set state(_: Components.BrUpload['state']);
    /**
   * Indica se o componente permite a seleção de múltiplos arquivos.
Quando definido como `true`, o usuário pode selecionar mais de um arquivo para upload. @default false
   */
    set multiple(_: Components.BrUpload['multiple']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrUpload, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrUpload, "br-upload", never, { "accept": { "alias": "accept"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "label": { "alias": "label"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "state": { "alias": "state"; "required": false; }; "uploadFiles": { "alias": "uploadFiles"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrUpload extends Components.BrUpload {
    /**
     * Emitido quando a lista de arquivos selecionados muda.
     */
    selectedFilesChange: EventEmitter<CustomEvent<FileList>>;
    /**
     * Evento emitido quando um arquivo da lista `uploadFiles` (externos) é removido pelo usuário.
  O objeto emitido contém os dados do arquivo removido.
     */
    brRemove: EventEmitter<CustomEvent<IBrUploadIUploadFile>>;
}
export declare class BrWizard {
    protected z: NgZone;
    protected el: HTMLBrWizardElement;
    /**
   * Índice da etapa inicial do wizard.
Define qual etapa será exibida ao carregar o componente.
A numeração começa em 1 (primeira etapa = 1, segunda = 2, etc). @default 1
   */
    set initialStep(_: Components.BrWizard['initialStep']);
    /**
   * Orientação visual do wizard.
Define se os indicadores de progresso serão exibidos horizontalmente ou verticalmente. @default 'horizontal'
   */
    set orientation(_: Components.BrWizard['orientation']);
    /**
   * Tipo de progressão entre etapas.
- `linear`: O usuário deve completar cada etapa sequencialmente. Não é possível pular etapas futuras.
- `nonlinear`: O usuário pode navegar livremente entre qualquer etapa. @default 'nonlinear'
   */
    set progressionType(_: Components.BrWizard['progressionType']);
    /**
   * ID customizado para o componente.
Se não fornecido, um ID único será gerado automaticamente. @default Helpers.generateUniqueId()
   */
    set customId(_: Components.BrWizard['customId']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrWizard, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrWizard, "br-wizard", never, { "customId": { "alias": "customId"; "required": false; }; "initialStep": { "alias": "initialStep"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "progressionType": { "alias": "progressionType"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrWizard extends Components.BrWizard {
    /**
     * Evento emitido APÓS mudar de etapa com sucesso.
  
  Este evento é disparado independente da origem da navegação:
  - Botões "Avançar" ou "Voltar"
  - Click direto em um step do indicador de progresso
  - Chamadas programáticas via métodos públicos (goToStep, nextStep, etc)
     */
    brWizardStepChange: EventEmitter<CustomEvent<number>>;
    /**
     * Evento emitido ANTES de mudar de etapa (permite validação e cancelamento).
  
  Comportamento:
  - Disparado apenas ao AVANÇAR (targetStep > currentStep)
  - Não é disparado ao VOLTAR (targetStep < currentStep)
  - Funciona tanto para cliques nos botões quanto para cliques diretos nos steps
  - Pode ser cancelado com `event.preventDefault()` para bloquear a navegação
     */
    brWizardBeforeStepChange: EventEmitter<CustomEvent<number>>;
    /**
     * Evento emitido ao concluir o wizard (última etapa).
     */
    brWizardComplete: EventEmitter<CustomEvent<void>>;
    /**
     * Evento emitido ao cancelar o wizard.
     */
    brWizardCancel: EventEmitter<CustomEvent<void>>;
    /**
     * Evento emitido quando uma ação é bloqueada (validação falha, progressão linear impedida).
  Emite uma string indicando o motivo: 'linear-progression' ou 'validation-failed'.
  Use getCurrentStepIndex() para obter o contexto da etapa atual.
     */
    brWizardNavigationBlocked: EventEmitter<CustomEvent<string>>;
}
export declare class BrWizardPanel {
    protected z: NgZone;
    protected el: HTMLBrWizardPanelElement;
    /**
   * Label do painel (aparece no indicador de progresso)
   */
    set label(_: Components.BrWizardPanel['label']);
    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrWizardPanel, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrWizardPanel, "br-wizard-panel", never, { "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], false, never>;
}
export declare interface BrWizardPanel extends Components.BrWizardPanel {
}