import * as _angular_core from '@angular/core'; import { ElementRef, OnDestroy, InjectionToken, AfterViewInit, AfterContentInit, QueryList, EventEmitter, Renderer2, ChangeDetectorRef, PipeTransform, OnChanges, OnInit, SimpleChanges, TemplateRef, NgZone, ApplicationRef, Injector, RendererFactory2, Type, ComponentRef, AfterContentChecked, Signal } from '@angular/core'; import { SafeHtml } from '@angular/platform-browser'; import * as i2 from '@angular/forms'; import { ControlValueAccessor, NgControl, Validator, FormControl, ValidationErrors, AbstractControl, ValidatorFn } from '@angular/forms'; import * as i2$1 from '@angular/common'; import * as _inchurch_matcha_components from '@inchurch/matcha-components'; import { Observable, Subject } from 'rxjs'; import { HttpClient } from '@angular/common/http'; /** * Test-handle directive attached to every Matcha component via `hostDirectives`. * * Exposes a single `data-qa` input, reflected onto the host as `[attr.data-qa]`. * The value is 100% author-supplied: it renders only when the consumer sets it * (``) and is otherwise absent from the DOM. * * No auto-generated fallback on purpose — any runtime-generated value (module * counter, uuid, label hash) is unstable across construction order / reloads / i18n, * which defeats the whole point of a test handle. The only value that never changes * is the one authored at the usage site, because only the consumer knows the stable * identity of that element. * * Usage (per component decorator): * hostDirectives: [{ directive: MatchaDataQaDirective, inputs: ['data-qa'] }] * * The `inputs: ['data-qa']` re-exposure is required so consumers can set it on the host. */ declare class MatchaDataQaDirective { /** Stable, author-supplied e2e/unit test handle. `null` → no attribute rendered. */ readonly dataQa: _angular_core.InputSignal; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class MatchaOverflowDraggableComponent { dragRef: string; dragToScroll(): void; get classes(): string; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } /** * matcha-accordion-item — disclosure item canônico (Figma DSV3 15808:51). * * Estados: Fechado | Aberto | Disabled. Signals API, native * * * * Múltiplas linhas — passar um array (1 item por linha) ou `\n` na string: * * * Itens vazios são descartados; array sem conteúdo ⇒ tooltip não abre. * matchaTooltipAlign="left|center|right" alinha o texto (default center). * * API imperativa (via ViewChild): * @ViewChild(MatchaTooltipDirective) tooltip!: MatchaTooltipDirective; * this.tooltip.show(); / .hide(); / .toggle(); * * API legada (back-compat com control-panel-v2 — preferir matchaTooltipPosition): * matchaTooltipAbove="true" | matchaTooltipBelow="true" * matchaTooltipLeft="true" | matchaTooltipRight="true" * * Comportamento: * - Hover/focus abrem com delay (showDelay default 300ms · hideDelay 100ms) * - Cursor entrando NO tooltip cancela o hide → permite seleção/cópia de texto * - Focus abre IMEDIATAMENTE (teclado não tem transit, delay seria fricção) * - matchaTooltipEnableClose desliga hover/focus; só click + close button + Esc * - effect() observa disabled/text — fecha se vier disabled OU text vazio * - Texto se atualiza in-place se mudar enquanto aberto (recompute position) * * Acessibilidade: * - role="tooltip" no overlay; aria-describedby no host enquanto visível * - Esc fecha em qualquer modo * - focusin/focusout abrem/fecham (paridade com hover pra teclado) */ declare class MatchaTooltipDirective implements OnDestroy { private readonly el; private readonly renderer; /** * Texto exibido. Aceita `string` ou `string[]` (1 item por linha — itens * vazios são descartados). Sem conteúdo resolvido ⇒ tooltip não abre (e * fecha se já aberto). `\n` numa string também quebra linha. */ readonly text: _angular_core.InputSignal; /** Posição preferida. 'auto' escolhe pelo espaço disponível no viewport. */ readonly position: _angular_core.InputSignal; /** Alinhamento do texto (relevante com múltiplas linhas). Default 'center'. */ readonly align: _angular_core.InputSignal; /** Bloqueia exibição (fecha se já aberto). */ readonly disabled: _angular_core.InputSignalWithTransform; /** Modo click + close button. Hover/focus deixam de abrir. */ readonly enableClose: _angular_core.InputSignalWithTransform; /** Delay (ms) entre mouseenter e abrir. Default 300 (hover-intent). Foco abre instantaneamente. */ readonly showDelay: _angular_core.InputSignalWithTransform; /** Delay (ms) entre mouseleave e fechar. Default 100 (cursor pode entrar no tooltip). */ readonly hideDelay: _angular_core.InputSignalWithTransform; /** @deprecated Use `matchaTooltipPosition="above"`. */ readonly _legacyAbove: _angular_core.InputSignalWithTransform; /** @deprecated Use `matchaTooltipPosition="below"`. */ readonly _legacyBelow: _angular_core.InputSignalWithTransform; /** @deprecated Use `matchaTooltipPosition="left"`. */ readonly _legacyLeft: _angular_core.InputSignalWithTransform; /** @deprecated Use `matchaTooltipPosition="right"`. */ readonly _legacyRight: _angular_core.InputSignalWithTransform; /** Emitido após o overlay ser inserido no DOM e posicionado. */ readonly opened: _angular_core.OutputEmitterRef; /** Emitido após o overlay ser removido do DOM. */ readonly closed: _angular_core.OutputEmitterRef; private readonly tooltipId; private tooltipElement; private textElement; private showTimer; private hideTimer; private documentClickOff; private documentKeyOff; private windowResizeOff; private overlayMouseEnterOff; private overlayMouseLeaveOff; constructor(); /** * Conteúdo efetivo como string única. `string` passa intacta (retrocompat — * comportamento idêntico ao de antes do suporte a array); `string[]` vira 1 * item por linha (`\n`), com itens vazios/whitespace descartados. `''` quando * não há nada a exibir (guarda de abertura e trigger de auto-close do effect). */ private resolvedText; /** Abre o tooltip imediatamente (cancela qualquer delay pendente). No-op se disabled ou text vazio. */ show(): void; /** Fecha o tooltip imediatamente (cancela qualquer delay pendente). */ hide(): void; /** Alterna estado (open ↔ closed). */ toggle(): void; onMouseEnter(): void; onMouseLeave(): void; onFocusIn(): void; onFocusOut(): void; onClick(event: Event): void; private scheduleShow; private scheduleHide; private cancelShowTimer; private cancelHideTimer; private cancelTimers; private renderTooltip; private removeTooltip; private effectivePosition; private computePosition; ngOnDestroy(): void; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class MatchaTooltipModule { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵmod: _angular_core.ɵɵNgModuleDeclaration; static ɵinj: _angular_core.ɵɵInjectorDeclaration; } declare class MatchaIconModule { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵmod: _angular_core.ɵɵNgModuleDeclaration; static ɵinj: _angular_core.ɵɵInjectorDeclaration; } type MatchaDividerDirection = 'horizontal' | 'vertical'; type MatchaDividerInset = 'none' | 'start' | 'end' | 'both'; /** * matcha-divider — separador visual entre grupos de conteúdo. * * Direções: * * * * Com label opcional (M3 — Figma DSV3 description menciona): * OU * Nova seção * * Inset (linha que não vai borda-a-borda — útil em listas com avatar): * * * Render: linha 1px com matcha/color/text/hint @ matcha/opacity/strong (0.3) — canônico Figma DSV3. * Quando há label projetado, a linha quebra em duas com o texto centralizado entre elas. * Detecção de label via CSS `:has(.matcha-divider-label:not(:empty))` — sem runtime overhead. * * Acessibilidade: role="separator" (default) com aria-orientation. `decorative=true` aplica * role="presentation" e remove aria-orientation. * * Compat (legacy): gap/gap-sm/gap-md/gap-lg/gap-xl geram classes utility mx-/my- do matcha-core. * @deprecated Recomendado: usar gap/padding do container pai em vez disso. */ declare class MatchaDividerComponent { private el; private renderer; /** Direção visual do separador. Default 'horizontal'. */ direction: _angular_core.InputSignal; /** * Inset — controla se a linha vai borda-a-borda ou não. Útil em listas * com avatar (Material List): inset="start" deixa a linha começar depois * do avatar. Default 'none' (linha completa). */ inset: _angular_core.InputSignal; /** * Texto opcional centralizado no divider ("OU", "Nova seção"). * Quando preenchido, a linha quebra em duas com o texto entre. Quando vazio * (default), renderiza linha única contínua. Alternativa: usar slot ng-content. */ label: _angular_core.InputSignal; /** Marca como decorativo (role="presentation"). Use quando não separa grupos semânticos. */ decorative: _angular_core.InputSignalWithTransform; /** Indica se o divider deve renderizar com label (prop ou slot). */ hasLabel: _angular_core.Signal; /** * aria-label opcional — sobrescreve o anúncio padrão. Útil quando o label * projetado é abreviação ambígua (ex.: slot "OU" — preferir aria-label="ou continuar com"). */ ariaLabelInput: _angular_core.InputSignal; gap: _angular_core.InputSignal; gapSm: _angular_core.InputSignal; gapMd: _angular_core.InputSignal; gapLg: _angular_core.InputSignal; gapXl: _angular_core.InputSignal; /** role: separator se semântico, presentation se decorativo. */ ariaRole: _angular_core.Signal<"separator" | "presentation">; /** aria-orientation: aplicável só com role=separator. */ ariaOrientation: _angular_core.Signal; /** aria-label efetivo (input override). */ ariaLabel: _angular_core.Signal; constructor(); static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } declare class MatchaDividerModule { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵmod: _angular_core.ɵɵNgModuleDeclaration; static ɵinj: _angular_core.ɵɵInjectorDeclaration; } declare class MatchaAccordionModule { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵmod: _angular_core.ɵɵNgModuleDeclaration; static ɵinj: _angular_core.ɵɵInjectorDeclaration; } /** * Interface que deve ser implementada por componentes que querem usar matcha-option como filho * * Permite que matcha-option seja usado em diferentes contextos: * - matcha-autocomplete * - matcha-select * - matcha-menu * - etc. */ interface MatchaOptionParent { /** * Método chamado quando uma opção é selecionada * @param option - A instância do MatchaOptionComponent selecionado */ selectOption(option: any): void; /** * Registra a option no parent. Chamado por matcha-option.ngOnInit via DOM * traversal — permite que options projetadas por wrappers (matcha-field → * matcha-select) sejam visíveis pro parent, já que `@ContentChildren` não * enxerga através de `` de wrapper. */ registerOption?(option: any): void; unregisterOption?(option: any): void; /** * Quando true, as opções renderizam em modo múltiplo (com matcha-checkbox). * Lido pela matcha-option para decidir a renderização já no primeiro ciclo. * Usado por matcha-select-multiple. Nome próprio (não `multiple`) pra não * colidir com os inputs `multiple` já existentes em matcha-select * (`boolean | string`) e matcha-field (`InputSignal`). */ multipleMode?: boolean; /** * Retorna se um value está selecionado (modo múltiplo). * Permite que a matcha-option reflita o estado "marcado" já no primeiro render, * evitando depender de atualização imperativa posterior. */ isSelected?(value: any): boolean; } /** * Token de injeção para MatchaOptionParent * Usado para injetar o componente pai no matcha-option */ declare const MATCHA_OPTION_PARENT: InjectionToken; declare class MatchaOptionComponent implements AfterViewInit, OnDestroy { private parent; /** Seq global pra `id`s estáveis — permite `aria-activedescendant` no combobox. */ private static uidSeq; value: _angular_core.InputSignal; color: _angular_core.InputSignal<"default" | "danger" | null>; disabled: _angular_core.InputSignalWithTransform; /** * Modo múltiplo: renderiza um matcha-checkbox (puramente visual) à esquerda * do conteúdo. Quando `null` (default), é derivado do componente pai * (matcha-select-multiple via MATCHA_OPTION_PARENT) — assim o checkbox * aparece já no primeiro render, mesmo com opções reprojetadas async. * Usado por matcha-select-multiple. */ multiple: _angular_core.InputSignal; /** Resolve o modo múltiplo: input explícito tem prioridade; senão, deriva do parent. */ protected multipleMode: _angular_core.Signal; /** * Estado "marcado" do checkbox em modo múltiplo. Signal (não getter) pra * disparar CD da option mesmo sob OnPush quando o parent atualiza a seleção. */ protected checkedSig: _angular_core.WritableSignal; /** Id único por option, exposto via `aria-activedescendant` pelo parent combobox. */ readonly optionId: string; optionClick: _angular_core.OutputEmitterRef; optionSelect: _angular_core.OutputEmitterRef; protected isDanger: _angular_core.Signal; get dangerClass(): boolean; get disabledAttr(): "true" | null; get disabledClass(): boolean; get multipleClass(): boolean; /** * Estado "selecionado/highlighted" — mutável pelo parent (matcha-select, * matcha-autocomplete) pra refletir focus/active no dropdown. Não é @Input * porque o parent controla imperativamente; two-way bind não faz sentido. */ selected: boolean; /** * True após ngOnDestroy — usado por matcha-select/autocomplete pra filtrar * options órfãs antes de chamar `.subscribe()` no output (que dispara NG0953 * em OutputRef de componente destroyed). */ isDestroyed: boolean; private elRef; constructor(parent: MatchaOptionParent | null); ngAfterViewInit(): void; ngOnDestroy(): void; /** * Atualiza o estado marcado do checkbox (modo múltiplo). Chamado * imperativamente pelo matcha-select-multiple ao sincronizar a seleção. */ setMultipleChecked(checked: boolean): void; private computeChecked; onClick(): void; onKeydown(ev: KeyboardEvent): void; get nativeElement(): HTMLElement; getTextContent(): string; private findParentAndSelect; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; } interface PanelPosition { top: number; left: number; width: number; maxHeight?: number; actualPlacement: 'top' | 'bottom'; } type PanelPlacement = 'bottom' | 'top' | 'auto' | 'side'; type PanelWidthMode = 'fixed' | 'max-content'; type PanelRole = 'listbox' | 'menu' | 'dialog' | 'group' | 'none'; type PanelAutoFocus = 'none' | 'first'; /** * matcha-panel — Container flutuante genérico (Figma DSV3 14276:67). * * Base para dropdown menu, select, popover e command palette. Posicionamento * automático (top/bottom/auto/side), portal opcional ao body, click-outside, * scroll re-position, ESC fecha, focus management e keyboard navigation. * * Uso típico — sempre via componente envólucro (matcha-select, matcha-menu, etc.). * Para uso direto: * * * Item 1 * * * A11y: o trigger deve declarar [attr.aria-expanded]="panel.open" e * [attr.aria-controls]="panel.panelId". O panel já gerencia ESC, focus * automático no primeiro item e devolução de foco ao trigger ao fechar. */ declare class MatchaPanelComponent { /** ID único — use no aria-controls do trigger. */ readonly panelId: string; /** * Elemento âncora — o painel se posiciona em relação a ele. * Use binding `[triggerElement]="trigger"` ou método `attachTo(el)`. */ triggerElement: _angular_core.ModelSignal; /** Direção preferencial. `auto` escolhe entre top/bottom; `side` abre lateralmente (submenus). */ placement: _angular_core.InputSignal; /** Altura máxima em px — acima disso o conteúdo entra em scroll vertical. */ maxHeight: _angular_core.InputSignalWithTransform; /** Largura mínima em px — limite inferior em ambos os widthModes. */ minWidth: _angular_core.InputSignalWithTransform; /** `fixed` ajusta ao trigger; `max-content` adapta ao conteúdo. */ widthMode: _angular_core.InputSignal; /** Espaço (gap) em px entre o trigger e o painel. */ offset: _angular_core.InputSignalWithTransform; /** Margem mínima em px entre o painel e a borda da viewport. */ viewportMargin: _angular_core.InputSignalWithTransform; /** Move o overlay para o `` ao abrir, escapando overflow:hidden de pais. */ portalToBody: _angular_core.InputSignalWithTransform; /** @deprecated Compat — não tem efeito visual nesta versão (use matcha-modal/matcha-drawer para backdrop). */ hasOverlay: _angular_core.InputSignalWithTransform; /** Elementos considerados "dentro" do painel para click-outside (ex.: triggers de submenus). */ ignoreClickOutsideElements: _angular_core.InputSignal; /** Não dispara o evento global que fecha outros painéis (use em submenus). */ suppressGlobalClose: _angular_core.InputSignalWithTransform; /** Role ARIA do conteúdo. `listbox` para select-like, `menu` para dropdown, `dialog` para popover. */ role: _angular_core.InputSignal; /** Fecha o painel ao pressionar ESC. */ closeOnEscape: _angular_core.InputSignalWithTransform; /** Comportamento de foco automático ao abrir. `first` foca o primeiro item focável. */ autoFocus: _angular_core.InputSignal; opened: _angular_core.OutputEmitterRef; closed: _angular_core.OutputEmitterRef; private readonly panelRef; private readonly paneRef; private readonly overlayRef; /** @internal — exposto pra template binding via class field (não privado por causa do template). */ isOpenSig: _angular_core.WritableSignal; /** @internal */ isPositionedSig: _angular_core.WritableSignal; /** @internal */ panePositionSig: _angular_core.WritableSignal<{ top: number; left: number; width: number; maxHeight: number; }>; /** @internal */ actualPlacementSig: _angular_core.WritableSignal<"top" | "bottom">; readonly isPositioned: _angular_core.Signal; readonly panePosition: _angular_core.Signal<{ top: number; left: number; width: number; maxHeight: number; }>; readonly actualPlacement: _angular_core.Signal<"top" | "bottom">; /** * Estado de abertura. Aceita binding `[open]="value"` para abrir/fechar * declarativamente. Para mutar imperativamente, prefira openPanel/closePanel/togglePanel. */ set _openInput(value: boolean); /** Estado de abertura (boolean) — leitura externa (`panel.open`). */ get open(): boolean; /** Elemento do pane (wrapper de posicionamento) — usado por consumidores como matcha-menu para registrar submenus em ignoreClickOutside. */ get paneElement(): HTMLElement | undefined; /** Elemento do panel interno (conteúdo scrollável) — consumidores que precisam escutar scroll/resize dele. */ get panelElement(): HTMLElement | undefined; private readonly renderer; private readonly ngZone; private originalParent?; private clickListener?; private globalListener?; private triggerForRefocus?; private resizeObserver?; /** Guarda pra nao registrar o listener de scroll duas vezes nem remover o que nao existe. */ private scrollListenerAttached; constructor(); private readonly scrollListener; private readonly resizeListener; /** * Passa a acompanhar a rolagem — so enquanto o painel esta ABERTO. * * Antes isto ficava no construtor, valendo pra toda instancia. Painel fechado nao fazia * trabalho nenhum (o handler sai no `isOpenSig()`), mas o zone.js ja tinha convertido cada * evento de rolagem numa tarefa Angular, e o ciclo de change detection acontecia do mesmo * jeito. Numa tela com muitos menus isso multiplica: 88 paineis mediram 1573ms de pior frame * ao rolar, contra 224ms com 10. * * `capture: true` porque o painel precisa reagir a rolagem de QUALQUER container, nao so da * pagina. Fora da zona porque reposicionar e trabalho de layout — `updatePosition` escreve * signals, e escrita de signal agenda o proprio refresh. */ private attachScrollListener; /** Idempotente: o painel pode ser destruido fechado, sem nunca ter aberto. */ private detachScrollListener; /** * Anexa o painel a um trigger element. Equivalente a `triggerElement.set(el)`. * Mantido para retrocompat com consumidores que calculam o anchor em runtime. */ attachTo(trigger: HTMLElement): void; /** Abre o painel, calcula posição, dispara `opened`. */ openPanel(): void; /** Reposiciona o painel sempre que a altura/largura do conteúdo muda. */ private observeContentResize; /** Fecha o painel, dispara `closed` e devolve foco ao trigger se necessário. */ closePanel(): void; private resetPaneStyles; /** Alterna entre aberto e fechado. */ togglePanel(): void; /** Recalcula e aplica a posição atual — chamado em scroll e mudanças de input. */ updatePosition(): void; onPanelKeydown(event: KeyboardEvent): void; private getFocusableItems; private focusFirstItem; private focusEdge; private focusSibling; private calculatePosition; private calculateSidePosition; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; static ngAcceptInputType__openInput: unknown; } /** * @deprecated Desde a rodada do campo de seleção canônico (2026-08-05). Use * `` — para lista fechada, direto; para lista remota/paginada, * com `searchMode="backend"` + `(search)` + `` como sentinela. * O select cobre tudo que o autocomplete fazia (busca no painel, valor sempre vindo de * option, clearable, loading) sem a composição frágil de input + diretiva + painel. * Este componente será removido quando o painel concluir a migração dos usos existentes. */ declare class MatchaAutocompleteComponent implements AfterContentInit, AfterViewInit, OnDestroy, MatchaOptionParent { elRef: ElementRef; private renderer; private cdr; /** * ContentChildren só pega options projetadas DIRETAMENTE em . * Pra uso via , options são content do field e * reprojetadas por ele — @ContentChildren não atravessa wrapper, fica vazio. * Workaround: options auto-registram via CustomEvent bubble (DOM-based, funciona). * `options` getter abaixo merge os dois caminhos. */ contentOptions: QueryList; panel: MatchaPanelComponent; /** Options registradas via DOM event OU chamada direta (uso via matcha-field). Ordem preservada. */ private registeredOptions; /** * Registro DIRETO (sem DOM event) — chamado pelo matcha-field via forward de * MATCHA_OPTION_PARENT. Necessário pq quando o panel está portalToBody, as * options nascem dentro do panel no `` e o CustomEvent bubble não chega * mais no element do autocomplete (que está noutro lugar do DOM tree). */ registerOption(opt: MatchaOptionComponent): void; unregisterOption(opt: MatchaOptionComponent): void; /** Merge dedup: registered ∪ contentOptions. */ get options(): MatchaOptionComponent[]; /** Seq global pra ids estáveis do listbox (pareados via aria-controls). */ private static listboxUidSeq; readonly listboxId: string; /** Id da option highlighted pelo teclado — consumido via `aria-activedescendant`. */ get activeDescendantId(): string | null; private selectedValue; placement: 'bottom' | 'top' | 'auto'; maxHeight: number; minWidth: number; disabled: boolean; /** * Somente leitura: o valor escolhido continua LEGIVEL e o campo focavel, mas o painel de * sugestoes nao abre. * * Nao e sinonimo de `disabled` — este apaga o contraste, tira o controle da ordem de tabulacao * e o esconde do leitor de tela. `disabled` para ACAO INDISPONIVEL, `readonly` para CONTEUDO * QUE SE LE. * * O `readonly` do que dispara este autocomplete e responsabilidade de quem o projeta * (o `matcha-form-field` aplica nos inputs projetados). O que este componente controla e o * PAINEL: sem esta guarda, o campo em readonly nativo ainda abriria a lista ao receber foco. */ readonly: boolean; /** Reflete no host, para o tema e para a inferencia do matcha-form-field. */ get readonlyAttr(): string | null; /** * HostBinding para adicionar classe disabled no elemento raiz do componente * Isso permite que o matcha-form-field detecte o estado disabled */ get hostDisabledClass(): boolean; /** * HostBinding para adicionar atributo disabled no elemento raiz do componente * Isso permite que o matcha-form-field detecte o estado disabled */ get hostDisabledAttr(): string | null; autoSelectOnBlur: boolean; displayWith: ((value: any) => string | null) | null; displayProperty: string; showClearButton: boolean; clearButtonIcon: string; clearButtonAriaLabel: string; /** Filtra options automaticamente ao digitar no input (normalize + fuzzy). */ autoFilter: boolean; /** Tolera typos via Levenshtein (ex: "saopalo" → "São Paulo"). */ fuzzy: boolean; /** @deprecated NO-OP hoje. `matchaHighlightMatch()` existe e é testada * (matcha-validators/matcha-text-normalize.ts), mas nunca é chamada aqui: envolver o * trecho casado em `` exige um caminho de `[innerHTML]` no `matcha-option`, que * este componente não tem — `applyFilter` só mexe em `display` e na ordem do DOM, nunca * no conteúdo textual da option. O input segue aceito para não quebrar templates, mas * ligar/desligar não muda nada na renderização. */ highlight: boolean; /** Texto quando filtro zera resultados. */ emptyText: string; /** Feedback de async search: quando `true`, o painel renderiza "Carregando..." * em vez das options. Use enquanto o dev busca dados no servidor. */ loading: boolean; /** Texto do estado de loading. */ loadingText: string; opened: EventEmitter; closed: EventEmitter; cleared: EventEmitter; autoSelected: EventEmitter; optionSelected: EventEmitter; openedChange: EventEmitter; open: boolean; triggerElement?: HTMLElement; private activeIndex; constructor(elRef: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef); private attachOptionRegisterListeners; /** Subscriptions vivas dos `optionSelect` outputs das options. Recriadas * quando QueryList muda. Tipado como `{ unsubscribe }` pra aceitar tanto * rxjs `Subscription` quanto Angular `OutputRefSubscription` (signal outputs). */ private optionSubs; ngAfterContentInit(): void; /** * Escuta `optionSelect` de cada option diretamente via QueryList — pattern * canon idêntico ao matcha-select. Antes: matcha-autocomplete só ouvia o * CustomEvent `matcha-option-selected` que é o FALLBACK (só fired quando * option NÃO tem parent DI). Como autocomplete PROVIDES MATCHA_OPTION_PARENT, * o fallback nunca fired, e o `optionSelect` output ficava órfão → click no * mouse não preenchia o input (bug reportado em add-family modal e outros). */ private subscribeToOptionOutputs; private isDestroyed; ngOnDestroy(): void; ngAfterViewInit(): void; attachTo(input: HTMLElement): void; private notifyDirectiveOfSelection; openPanel(): void; closePanel(): void; togglePanel(): void; resetActive(): void; private updateSelectedStates; highlightNext(): void; highlightPrevious(): void; private scrollToActive; selectActive(): void; selectOption(option: MatchaOptionComponent): void; getSelectedValue(): any; hasSelection(): boolean; clearSelection(): void; /** * Obtém o texto de exibição de um valor * Usa displayWith se fornecido, senão displayProperty, senão retorna o valor como string */ getDisplayValue(value: any): string; /** * Busca uma opção que corresponda ao texto digitado (match EXATO normalizado — * ignora acento, case, pontuação/espaço). Usado por autoSelectOnBlur. */ findOptionByText(text: string): MatchaOptionComponent | null; /** * Aplica filtro textual às options: esconde as que não casam e ordena por relevância. * Chamado pelo MatchaAutocompleteTriggerDirective quando `autoFilter` está ligado. * * query vazia → mostra todas as options na ordem original * query normalize → score por matchaFuzzyScore (prefix > substring > subseq > Levenshtein) * * Retorna nº de options visíveis (0 → renderizar empty state). */ /** * Busca o container `.matcha-autocomplete-content` via id global. * Necessário porque matcha-panel usa `portalToBody=true` — depois de aberto, * o conteúdo migra pro body e `this.elRef.querySelector` não enxerga mais. * Usando `document.getElementById(listboxId)` o lookup é imune ao portal. */ private getContentContainer; applyFilter(query: string): number; private emptyEl; private setEmptyState; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵcmp: _angular_core.ɵɵComponentDeclaration; static ngAcceptInputType_disabled: unknown; static ngAcceptInputType_readonly: unknown; static ngAcceptInputType_autoSelectOnBlur: unknown; static ngAcceptInputType_showClearButton: unknown; static ngAcceptInputType_autoFilter: unknown; static ngAcceptInputType_fuzzy: unknown; static ngAcceptInputType_highlight: unknown; static ngAcceptInputType_loading: unknown; } /** * @deprecated Desde a rodada do campo de seleção canônico (2026-08-05). Use * `` (com `searchMode="backend"` para lista remota/paginada) — * ver a nota completa em MatchaAutocompleteComponent. Será removida junto com o componente * quando o painel concluir a migração. */ declare class MatchaAutocompleteTriggerDirective implements AfterViewInit, OnDestroy { private el; private renderer; private cdr; panel: MatchaAutocompleteComponent; disabled: boolean; private ngControl; private subs; private clearButton?; private chevronIcon?; constructor(el: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef); get hostDisabled(): boolean; get autocompleteOff(): string; get roleAttr(): string; get ariaAutocomplete(): string; get ariaExpanded(): "true" | "false"; get ariaHasPopup(): string; /** Amarra o input ao listbox do painel enquanto ele está aberto. */ get ariaControls(): string | null; /** Id da option highlighted pelo teclado — screen reader "foca" a option virtualmente. */ get ariaActiveDescendant(): string | null; ngAfterViewInit(): void; ngOnDestroy(): void; private writeValueToInput; private clearInput; /** * Inerte = nao aceita mudanca de selecao. * * `readOnly` entra junto de `disabled` porque e o modo que as telas de leitura usam de * proposito — `disabled` apagaria o texto e o tiraria da ordem de foco. O * `matcha-form-field` ja sincroniza `readonly` no input projetado; faltava a trigger * olhar para ele, entao o painel abria e a opcao era selecionavel numa tela de detalhe. */ private get isInert(); onClick(): void; onFocus(): void; onInput(e: Event): void; onBlur(): void; onKeydown(ev: KeyboardEvent): void; onDocClick(ev: MouseEvent): void; private createClearButton; private updateClearButtonVisibility; /** * Cria chevron decorativo dentro do matcha-form-field, sinalizando que o * campo é um seletor com lista (UX-canon de combobox). Sem click handler — * o input parent já abre o panel no click (após fix 2026-05-25). * Esconde quando clearButton aparece (selection feita) ou disabled. * * EM FLUXO, não absolute: o .matcha-form-field é uma flex row — como último * filho, o chevron ocupa a borda direita naturalmente, DEPOIS de qualquer * matcha-suffix (contador, ícone de erro/sucesso). Antes era * position:absolute; right:12px, e o ícone de erro do matcha-field * renderizava por cima dele (mesma coordenada, camadas diferentes) — é o * mesmo layout que o matcha-select já usa (seta em fluxo no trigger). */ private createChevronIcon; /** * Visibilidade do chevron: * - some quando clearButton aparece (mesma posição) ou disabled * - mostra quando idle/empty/sem-seleção * Rotação 180° quando panel aberto (feedback visual de toggle). */ private updateChevronVisibility; static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵdir: _angular_core.ɵɵDirectiveDeclaration; } declare class MatchaOptionModule { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵmod: _angular_core.ɵɵNgModuleDeclaration; static ɵinj: _angular_core.ɵɵInjectorDeclaration; } declare class MatchaPanelModule { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵmod: _angular_core.ɵɵNgModuleDeclaration; static ɵinj: _angular_core.ɵɵInjectorDeclaration; } declare class MatchaAutocompleteModule { static ɵfac: _angular_core.ɵɵFactoryDeclaration; static ɵmod: _angular_core.ɵɵNgModuleDeclaration; static ɵinj: _angular_core.ɵɵInjectorDeclaration; } /** * Textos do select, em pt-BR. Ficam num lugar SO porque o matcha-field tambem os repassa — * duplicar a lista nos dois componentes seria garantir que um dia divergem. */ declare const MATCHA_SELECT_TEXTS: { readonly countSuffix: "selecionado"; readonly countSuffixPlural: "selecionados"; readonly selectAllLabel: "Selecionar todos"; readonly deselectAllLabel: "Desmarcar todos"; readonly clearLabel: "Limpar"; readonly clearSelectionLabel: "Limpar seleção"; readonly clearSearchLabel: "Limpar busca"; readonly noResultsText: "Nenhuma opção corresponde a \"{term}\""; readonly bulkActionsLabel: "Ações em lote"; }; /** Forma dos textos do select, para o consumidor sobrescrever o que precisar. */ type MatchaSelectTexts = Partial>; declare class MatchaSelectComponent implements AfterContentInit, AfterViewInit, OnDestroy, MatchaOptionParent, ControlValueAccessor { /** * Options via content projection direta (sem wrapper componente). * `@ContentChildren` NÃO atravessa `` de wrapper, então pra * casos via matcha-field as options se auto-registram via CustomEvent bubble * em ngOnInit/ngOnDestroy. `options` combina ambos os caminhos. */ contentOptions: QueryList; panel: MatchaPanelComponent; /** Options auto-registradas via DOM event (ordem de registro preservada). */ private registeredOptions; /** Notifica mudanças na lista unificada de options (registered ∪ contentOptions). */ private optionsChange$; /** Merge dedup: registered (prioridade) ∪ contentOptions. */ get options(): MatchaOptionComponent[]; /** * Registro DIRETO (sem DOM event) — chamado pelo matcha-field via forward de * MATCHA_OPTION_PARENT. Necessário pq quando o panel está portalToBody, as * options nascem dentro do panel no `` e o CustomEvent bubble não chega * mais no element do select. */ registerOption(opt: MatchaOptionComponent): void; unregisterOption(opt: MatchaOptionComponent): void; /** Auto-register listeners — attached via addEventListener em vez de * @HostListener pra garantir que estão ativos ANTES do ngOnInit das options * projetadas (timing). */ private attachOptionRegisterListeners; private onOptionsListChanged; /** Modo single: valor único (undefined quando vazio). */ selectedValue: any; /** Modo single: label do valor atual. */ selectedLabel: string; /** Modo multi: array de valores selecionados. */ selectedValues: any[]; /** Modo multi: chips renderizados no trigger (mantido em sincronia com selectedValues). */ selectedChips: Array<{ value: any; label: string; }>; placement: 'bottom' | 'top' | 'auto'; maxHeight: number; minWidth: number; placeholder: string; disabled: boolean; /** * Somente leitura: a opção escolhida continua LEGÍVEL e o combobox focável, mas o painel não * abre e nada muda. * * Não é sinônimo de `disabled`, e a diferença decide se uma tela de leitura funciona: * `disabled` apaga o contraste, tira o controle da ordem de tabulação e o esconde do leitor * de tela. `disabled` para AÇÃO INDISPONÍVEL, `readonly` para CONTEÚDO QUE SE LÊ. * * ``, é um * `div role="combobox"`. Então a inércia é comportamento: as portas de abertura do painel * checam este flag, e o botão de limpar desaparece. * * Deliberadamente FORA de `isCurrentlyDisabled`: aquele getter alimenta a classe * `matcha-select-disabled` e o `attr.disabled` do host, que é exatamente o cinza que * `readonly` existe para evitar. */ readonly: boolean; /** Nome acessível do combobox (a11y). Sem label visível associado ao trigger * (que é um div role="combobox", não um ligado a