import { type EventEmitter } from '../../stencil-public-runtime';
import type { ScrimContentLayout, ScrimDisplayMode, ScrimLegibilityAnchor, ScrimPositionContent, ScrimScrollStrategy, ScrimSpotlightShape, ScrimVariant } from './scrim.types';
/**
 * O `br-scrim` cria uma máscara visual escura sobre a tela ou sobre um elemento pai para focar a atenção do usuário.
 *
 * Use os métodos `show()`, `hide()` ou a propriedade `active` para controlar a exibição. Coloque o conteúdo em destaque no slot padrão.
 *
 * ```html
 * <br-scrim active>
 *   <div class="destaque">Conteúdo em evidência</div>
 * </br-scrim>
 * ```
 *
 * ### Quando usar
 *
 * - Destaque visual pontual de um elemento (tutoriais guiados ou máscaras personalizadas).
 *
 * ### Quando evitar
 *
 * - Caixas de diálogo modais padrão: use `br-modal` (que já gerencia seu próprio scrim internamente).
 *
 * Consulte as [diretrizes de design do GovBR](https://www.gov.br/ds/components/scrim?tab=designer).
 *
 * @category Feedback, Sobreposições
 * @status stable
 * @slot default - Slot para o conteúdo principal a ser exibido sobre o fundo escurecido do scrim.
 * @slot activator - Slot para o elemento ativador do scrim, com prioridade sobre a propriedade activator.
 */
export declare class Scrim {
    private readonly legibilityBatch;
    /**
     * Referência ao elemento host do componente.
     */
    el: HTMLBrScrimElement;
    hasActivatorSlot: boolean;
    /** Rect do elemento alvo do scrim vazado. */
    spotlightRect: DOMRect | null;
    /**
     * Identificador único.
     * Caso não seja fornecido, um ID gerado automaticamente será usado.
     */
    readonly customId: string;
    /**
     * Ativa/desativa o scrim
     */
    isOpen: boolean;
    private get isActive();
    private get effectiveCustomOpacity();
    private get effectiveScrollThreshold();
    private get effectiveSpotlightPadding();
    private get effectiveZIndex();
    /**
     * Posiciona o conteúdo no topo, centro, direita, esquerda, abaixo dentro do scrim
     */
    positionContent: ScrimPositionContent;
    /**
     * Desativa o fechamento do scrim ao ser clicado
     */
    disableCloseOnClick: boolean;
    /**
     * Define o valor de z-index do scrim. Deve ser um inteiro entre 0 e Number.MAX_SAFE_INTEGER; valores inválidos usam 0.
     */
    zIndex: number | null;
    /**
     * 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.
     */
    bgColor: string | null;
    /**
     * Define a opacidade personalizada do scrim. O valor é limitado ao intervalo `0`–`1`; entradas inválidas usam `0.4`.
     */
    customOpacity: number | null;
    /**
     * 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.
     */
    displayMode: ScrimDisplayMode;
    /**
     * 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
     */
    scrollStrategy: ScrimScrollStrategy;
    /**
     * Determina quanto de rolagem (em pixels) é necessário para acionar a ação de fechamento automático do scrim. Valores negativos usam `0`.
     */
    scrollThreshold: number;
    /**
     * Define o seletor para o elemento activator.
     * Nota: O slot 'activator' tem prioridade sobre esta propriedade.
     *
     * @example
     * ```html
     * <button id="abrir-ajuda" type="button">Abrir ajuda</button>
     * <br-scrim activator="#abrir-ajuda">Conteúdo</br-scrim>
     * ```
     */
    activator: string | null;
    /**
     * 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.
     */
    ariaLabel: string | null;
    /**
     * 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.
     */
    variant: ScrimVariant;
    /**
     * 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"`.
     */
    legibilityAnchor: ScrimLegibilityAnchor;
    /**
     * 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.
     *
     * @example
     * ```html
     * <br-scrim variant="legibility" legibility-anchor="bottom" legibility-size="40%">
     *   Texto sobre a imagem
     * </br-scrim>
     * ```
     */
    legibilitySize: string | null;
    /**
     * Seletor CSS do elemento que deve receber o posicionamento da variante
     * `legibility`. Quando não informado (padrão), o alvo é o elemento pai
     * direto do `<br-scrim>`.
     */
    legibilityTargetId: string | null;
    /**
     * Ativa o modo de scrim vazado (variante 'spotlight'), criando uma área de fresta no overlay
     * que destaca o elemento referenciado pelo seletor CSS fornecido.
     *
     * @example
     * ```html
     * <button id="acao-principal" type="button">Continuar</button>
     * <br-scrim variant="spotlight" spotlight-target-id="#acao-principal"></br-scrim>
     * ```
     */
    spotlightTargetId: string | null;
    /**
     * Espaçamento interno (em pixels) ao redor da área de fresta no scrim vazado. Valores negativos usam `0`.
     */
    spotlightPadding: number;
    /**
     * 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.
     */
    spotlightShape: ScrimSpotlightShape;
    /**
     * Define como o scrim aplica estilos de layout ao elemento filho (slot padrão).
     *
     * - `'default'`: O scrim gerencia o layout do conteúdo, centralizando, animando e aplicando transformações e opacidade automaticamente.
     *
     * - `'none'`: o scrim age como um componente controlado pelo pai. O filho recebe apenas a máscara visual, sem interferência de posicionamento, transformação ou opacidade.
     * Adequado para componentes que gerenciam seu próprio layout e estado de abertura. Além disso:
     *
     *   - Foco e eventos globais** não são interceptados pelo scrim — o componente filho gerencia seu próprio foco, navegação por teclado e fechamento via ESC.
     *   - Clique no scrim emite `brScrimClose` sem fechar o scrim internamente, delegando o controle de estado ao pai (quem define `isOpen`).
     *   - Use `zIndex` apenas para sobrescrever a camada bloqueadora no fallback CSS. Máscara e painel devem usar subcamadas locais, sem aritmética entre camadas globais.
     *
     */
    contentLayout: ScrimContentLayout;
    private get effectivePositionContent();
    private get effectiveScrollStrategy();
    private get effectiveVariant();
    private get effectiveLegibilityAnchor();
    private get effectiveSpotlightShape();
    private get effectiveContentLayout();
    handleOpenChange(newValue: boolean): void;
    updateStyles(): void;
    handleVariantChange(): void;
    handleLayerModeChange(): void;
    handleSpotlightChange(): void;
    handleLegibilityTargetChange(): void;
    handleActivatorChange(): void;
    /** Indica que o scrim foi aberto. */
    brScrimOpen: EventEmitter<void>;
    /** Indica que o scrim foi fechado */
    brScrimClose: EventEmitter<void>;
    connectedCallback(): void;
    disconnectedCallback(): void;
    componentWillLoad(): void;
    componentDidLoad(): void;
    componentDidRender(): void;
    /**
     * Define o limite de rolagem para o fechamento automático do scrim.
     */
    setScrollThreshold(threshold: number): Promise<void>;
    /**
     * Método público para exibir o scrim
     */
    open(): Promise<void>;
    /**
     * Método público para esconder o scrim
     */
    close(): Promise<void>;
    /**
     * Método público para alternar o estado de exibição do scrim
     */
    toggle(): Promise<void>;
    /**
     * Recalcula manualmente a posição e dimensões da fresta do scrim vazado.
     * Útil quando o elemento alvo muda de posição sem disparar resize ou scroll.
     */
    updateSpotlight(): Promise<void>;
    /** Indica se o atributo `display-mode` foi explicitamente informado pelo usuário */
    private displayModeExplicit;
    private contentRef;
    private activatorElement;
    private lastScrollTop;
    private scrollOrigin;
    private previouslyFocusedElement;
    private focusTimeoutId;
    private restoreFocusTimeoutId;
    /** ResizeObserver que monitora o elemento alvo do spotlight para recalcular a posição. */
    private spotlightResizeObserver;
    /** Elemento atualmente sendo destacado pelo scrim vazado. */
    private spotlightTargetElement;
    /** Referência ao container interno para estilos locais e fallback sem `<dialog>`. */
    private scrimDivRef;
    private nativeDialogRef;
    /** ResizeObserver que monitora o elemento pai para recalcular a posição da variante legibility. */
    private legibilityResizeObserver;
    private globalInterceptionAttached;
    /**
     * Flag que suprime handleGlobalFocus enquanto a modal filha está
     * gerenciando ativamente sua própria sequência de foco (moveFocusIntoModal).
     */
    private isModalFocusing;
    private modalFocusSuppressId;
    private static readonly FOCUSABLE_SELECTORS;
    /**
     * Adiciona event listener ao contentRef para capturar eventos de teclado
     * e gerenciar a navegação por teclado dentro do scrim.
     */
    private addContentEventListener;
    /**
     * Ativa o guard que suprime `handleGlobalFocus` enquanto a modal filha executa
     * sua sequência assíncrona de foco (`moveFocusIntoModal`).
     *
     * O guard é desativado assim que o evento `brModalFocusReady` chega (via
     * `handleModalFocusReady`). O timeout é apenas um safety net para o caso de
     * o evento nunca chegar (ex: erro interno na modal).
     */
    private suppressFocusGuard;
    /**
     * Handler para o evento `brModalFocusReady` emitido pela modal filha.
     * Desativa o guard imediatamente assim que o foco está estabilizado,
     * cancelando o timeout de segurança do `suppressFocusGuard`.
     */
    private handleModalFocusReady;
    /**
     * Handler para evento brModalOpen emitido por modal filha
     */
    private handleModalOpen;
    /**
     * Handler para evento brModalClose emitido por modal filha
     */
    private handleModalClose;
    /**
     * Verifica se um elemento é filho direto deste scrim (não nested)
     */
    private isDirectChild;
    /**
     * Adiciona listeners para eventos brModalOpen, brModalClose e brModalFocusReady das modais filhas
     */
    private listenToModalEvents;
    /**
     * Remove listeners dos eventos da modal
     */
    private removeModalEventListener;
    /**
     * Retorna os elementos filhos diretos do scrim via slot padrão
     */
    private getDirectChildren;
    /**
     * Busca uma modal filha direta do scrim
     */
    private findModalChild;
    /**
     * Verifica se há uma modal filha com autoClose=false (padrão ou explícito)
     * Retorna true se:
     * - Existe modal filha E autoClose não é explicitamente true
     */
    private hasModalWithAutoClose;
    /**
     * Fecha a modal filha direta, se existir e estiver aberta.
     * Chamado quando o scrim é fechado (ex: via ESC) para garantir sincronização de estado.
     */
    private closeModalChild;
    private checkActivatorSlot;
    private setupActivatorSlotClick;
    private setupActivator;
    private handleActivatorClick;
    private addActivatorClickListener;
    private removeActivatorClickListener;
    private cleanupActivatorSlotClick;
    private applyScrollStrategy;
    private getScrollPosition;
    private enableScrollBlock;
    private enableScrollWatcher;
    private resetScrolling;
    private handleScrollClose;
    private focusFirstElement;
    private restoreFocus;
    private getFocusableElements;
    private filterVisibleElements;
    private handleKeyDown;
    /**
     * Intercepta todos os eventos de teclado globalmente quando o scrim está ativo.
     *
     * Usa `composedPath()[0]` para obter o elemento real com foco, mesmo dentro de shadow roots.
     * `event.target` é redirecionado ao cruzar shadow boundaries e não reflete o elemento concreto
     * quando o foco está dentro do shadow DOM de componentes filhos como `br-modal`.
     */
    handleDocumentKeyDown(event: KeyboardEvent): void;
    private handleGlobalKeyDown;
    private handleGlobalClick;
    /**
     * Intercepta eventos de foco globalmente
     */
    private handleGlobalFocus;
    private shouldHandleEscape;
    private handleTabNavigation;
    private shouldTrapFocus;
    private wrapFocus;
    /**
     * Verifica se um elemento está dentro do scrim.
     * Funciona com shadow DOM: aceita tanto o host (br-modal) quanto elementos
     * dentro de shadow roots filhos — verifica o host mais próximo via getRootNode.
     */
    private isElementInsideScrim;
    /**
     * Adiciona interceptação global de eventos
     */
    private addGlobalEventInterception;
    /**
     * Remove interceptação global de eventos
     */
    private removeGlobalEventInterception;
    /**
     * Handler para clique na máscara do scrim.
     * Fecha o scrim se disableCloseOnClick for false e não houver modal filha com autoClose=false.
     * Não afeta o comportamento de ESC, que sempre fecha (W3C Dialog Pattern).
     */
    private handleMaskClick;
    /**
     * Retorna true quando a variante é 'legibility'.
     * Nesse modo o scrim é puramente decorativo: nunca fecha, nunca intercepta
     * eventos de teclado/foco/clique e nunca bloqueia rolagem.
     */
    private get isLegibilityVariant();
    /**
     * Resolve o display-mode efetivo.
     * Para a variante 'legibility', usa 'parent' por padrão — a menos que o
     * atributo `display-mode` tenha sido explicitamente definido pelo usuário.
     */
    private get effectiveDisplayMode();
    private get usesNativeDialog();
    private get usesNativeTopLayer();
    private handleNativeCancel;
    /**
     * Aplica as especificações de cor e opacidade conforme a variante selecionada.
     */
    private applyVariantDefaults;
    /**
     * Inicializa o modo de scrim vazado: resolve o elemento alvo, calcula o rect
     * inicial e instala um ResizeObserver para atualizar automaticamente.
     * Só opera quando `variant === 'spotlight'`.
     */
    private setupSpotlight;
    /**
     * Desmonta o modo de scrim vazado, removendo observers e limpando o estado.
     */
    private cleanupSpotlight;
    /**
     * Resolve o elemento alvo do spotlight via prop `spotlightTargetId` (seletor CSS).
     */
    private resolveSpotlightTarget;
    /**
     * Recalcula as coordenadas da fresta com base no bounding rect do elemento alvo.
     * Coordenadas são relativas ao viewport (mode-fullscreen) ou ao elemento pai (mode-parent).
     */
    private computeSpotlightRect;
    /**
     * Inicializa o posicionamento da variante legibility.
     *
     * Aplica `position: fixed` com as coordenadas exatas do alvo via
     * `getBoundingClientRect`, sem exigir CSS adicional no alvo. O alvo é
     * resolvido por `legibilityTargetId` ou, por padrão, pelo pai direto.
     *
     * Com `ResizeObserver`, observa o alvo **e todos os seus ancestrais**: quando um
     * elemento irmão muda de tamanho (ex: menu abrindo), o ancestral comum redimensiona
     * e o callback reposiciona o scrim automaticamente.
     */
    private setupLegibility;
    /**
     * Desmonta o posicionamento da variante legibility, removendo observers e listeners
     * e limpando os estilos inline aplicados ao div interno do scrim.
     */
    private cleanupLegibility;
    /**
     * Recalcula as coordenadas do alvo via getBoundingClientRect e aplica
     * como estilos inline no div interno, sobrepondo o `inset: 0` do mode-fullscreen.
     */
    private computeLegibilityRect;
    private scheduleLegibilityRect;
    /**
     * Resolve o alvo da variante legibility. O pai direto permanece como
     * fallback para preservar o comportamento anterior e a compatibilidade.
     */
    private resolveLegibilityTarget;
    /**
     * Remove os estilos inline de posicionamento aplicados pelo computeLegibilityRect.
     */
    private resetLegibilityStyles;
    /**
     * Renderiza o SVG de overlay do scrim vazado (spotlight).
     * Retorna null quando não há elemento alvo resolvido.
     */
    private renderSpotlightOverlay;
    private getCssClassMap;
    render(): any;
}