structra-ui 0.1.20 → 0.1.22

package/types/structra-ui.d.ts

@@ -0,0 +1,2984 @@
+import * as i0 from '@angular/core';
+import { ChangeDetectorRef, Injector, DestroyRef, EventEmitter, OnChanges, OnInit, SimpleChanges, DoCheck, TemplateRef, OnDestroy, AfterContentInit, QueryList, AfterViewInit, ElementRef } from '@angular/core';
+import { ControlValueAccessor, AbstractControl, NgControl, ValidatorFn } from '@angular/forms';
+import { MatDatepicker } from '@angular/material/datepicker';
+import * as _angular_cdk_overlay from '@angular/cdk/overlay';
+import { ConnectedPosition, ScrollStrategy, OverlayRef } from '@angular/cdk/overlay';
+import { ICellRendererParams, ColDef, GetRowIdParams, GridReadyEvent } from 'ag-grid-community';
+import { ICellRendererAngularComp } from 'ag-grid-angular';
+import { DialogRef } from '@angular/cdk/dialog';
+import { Observable } from 'rxjs';
+import * as structra_ui from 'structra-ui';
+
+/** Marcador de pacote publicado como `structra-ui`. */
+declare const STRUCTRA_UI: "structra-ui";
+
+declare enum BaseButtonVariant {
+    Primary = "primary",
+    Secondary = "secondary",
+    /** Texto/ícone sem caixa — navegação secundária, “link” com aparência de botão acessível. */
+    Ghost = "ghost"
+}
+declare enum BaseButtonType {
+    Button = "button",
+    Submit = "submit",
+    Reset = "reset"
+}
+declare class BaseButtonComponent {
+    private nativeBtn?;
+    /** `submit` envia o `<form>` ancestral; use `button` para ações sem submit. */
+    type: BaseButtonType;
+    disabled: boolean;
+    /**
+     * Não interage (como `disabled`), mas com aparência em cinza (tema somente leitura),
+     * distinta do estado desabilitado genérico.
+     */
+    readonly: boolean;
+    /**
+     * `true` (por defeito): estica à largura do contentor (útil em `app-layout-stack` com `fill`).
+     * `false`: largura só ao conteúdo (texto + padding).
+     */
+    fullWidth: boolean;
+    /** Placeholder de carregamento (skeleton no lugar do rótulo). */
+    loading: boolean;
+    /** Estilo visual base; pode ser estendido no SCSS do projeto. */
+    variant: BaseButtonVariant;
+    /** Alias de {@link variant} (nome comum em design systems). */
+    set appearance(value: BaseButtonVariant);
+    get hostClasses(): string;
+    /** Foca o `<button>` nativo (o host do componente não é focável). */
+    focusNative(options?: FocusOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseButtonComponent, "app-base-button", never, { "type": { "alias": "type"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_readonly: unknown;
+    static ngAcceptInputType_fullWidth: unknown;
+    static ngAcceptInputType_loading: unknown;
+}
+
+/**
+ * Itens de menu partilhados por dropdown, context menu, action-menu e campos (`mostrarMenuContexto`).
+ * Discriminação por `kind` para renderização e navegação por teclado.
+ */
+type MenuItemKind = 'item' | 'divider' | 'group' | 'submenu';
+interface MenuItemAction<T = string> {
+    kind: 'item';
+    /** Identificador estável para o evento de selecção. */
+    id: T;
+    label: string;
+    description?: string;
+    /** Classes de ícone (ex.: Font Awesome), opcional. */
+    icon?: string;
+    disabled?: boolean;
+    /** Bloqueia interação e mostra indicador de carregamento (o pai atualiza o modelo). */
+    loading?: boolean;
+    /** Acção destrutiva (ex.: eliminar) — realce semântico sem quebrar o tema. */
+    danger?: boolean;
+}
+interface MenuItemDivider {
+    kind: 'divider';
+}
+/**
+ * Submenu aninhado (qualquer profundidade em `items`).
+ * A navegação e o posicionamento são tratados em `menu-list` (lista recursiva + overlay CDK).
+ */
+interface MenuItemSubmenu<T = string> {
+    kind: 'submenu';
+    /** Identificador estável (acessibilidade, rastreio). */
+    id: T;
+    label: string;
+    description?: string;
+    icon?: string;
+    disabled?: boolean;
+    items: readonly MenuNodeItem<T>[];
+}
+interface MenuItemGroup<T = string> {
+    kind: 'group';
+    /** Rótulo da seção (opcional). */
+    label?: string;
+    /** Itens e submenus aninhados dentro do grupo. */
+    items: readonly MenuNodeItem<T>[];
+}
+/** Folha: ação ou divisor. */
+type MenuLeafItem<T = string> = MenuItemAction<T> | MenuItemDivider;
+/** Nó de primeiro nível ou dentro de grupos (inclui submenus). */
+type MenuNodeItem<T = string> = MenuLeafItem<T> | MenuItemGroup<T> | MenuItemSubmenu<T>;
+
+/**
+ * Diretiva base abstrata: CVA, valor interno, disabled, touched e inputs comuns.
+ * Sem UI; os campos concretos envolvem o input com `BaseFieldComponent`.
+ */
+declare abstract class BaseFieldDirective<T> implements ControlValueAccessor {
+    protected readonly cdr: ChangeDetectorRef;
+    protected readonly injector: Injector;
+    protected readonly destroyRef: DestroyRef;
+    private formGroupDir;
+    private ngFormDir;
+    /** Identificador estável para a11y quando `id` não é informado */
+    protected readonly autoId: string;
+    id: string;
+    name: string;
+    label: string;
+    placeholder: string;
+    errorMessage: string;
+    /** Se `true`, exibe o parágrafo de erro; por defeito `false` (só estado inválido na borda/label). */
+    showErrorMessage: boolean;
+    required: boolean;
+    /** Se `true` e `required`, exibe o asterisco no label (`BaseFieldComponent`); por defeito `false`. */
+    showRequiredMark: boolean;
+    readonly: boolean;
+    /** Exibe ícone à esquerda (classes Font Awesome, ex.: `fa-solid fa-user`). */
+    showPrefixIcon: boolean;
+    prefixIcon: string;
+    /** Alias de {@link prefixIcon} (API alinhada a “ícone à esquerda”). */
+    set iconLeft(value: string);
+    /** Exibe botão à direita para limpar o valor quando houver texto. */
+    clearable: boolean;
+    clearAriaLabel: string;
+    /**
+     * Se `true`, o navegador pode exibir sugestões de preenchimento automático.
+     * Padrão `false` (`autocomplete="off"` em todos os campos).
+     */
+    autocomplete: boolean;
+    /** Placeholder de carregamento no `app-base-field` (skeleton). */
+    loading: boolean;
+    /**
+     * Mostra botão «…» no sufixo que abre menu de ações (dropdown com os itens em {@link contextMenuItems}).
+     * Por defeito `false`.
+     */
+    mostrarMenuContexto: boolean;
+    /** Itens do menu de contexto (rótulos, divisores, grupos); só o botão é mostrado se a lista não for vazia. */
+    contextMenuItems: readonly MenuNodeItem<string>[];
+    /** `id` do menu (acessibilidade); por defeito `{id do campo}-ctx`. */
+    contextMenuId: string;
+    readonly contextMenuSelect: EventEmitter<string>;
+    protected internalValue: T | null;
+    protected disabled: boolean;
+    private onChange;
+    private onTouched;
+    get controlId(): string;
+    /** Valor do atributo HTML `autocomplete` derivado de {@link autocomplete}. */
+    get autocompleteAttr(): 'on' | 'off';
+    /**
+     * Mensagem exibida quando inválido: `errorMessage` se preenchido;
+     * senão, se obrigatório, o padrão "Campo obrigatório".
+     * Campos não obrigatórios não exibem mensagem de erro da lib.
+     */
+    getErrorMessage(): string;
+    /**
+     * Obrigatório efetivo para UI: {@link required} ou `Validators.required` no `FormControl`.
+     * Usado no asterisco do label e no atributo HTML `required`.
+     */
+    get requiredEffective(): boolean;
+    /**
+     * `true` se `[required]="true"` **ou** o control tiver `Validators.required`.
+     */
+    protected isEffectiveRequired(control: AbstractControl | null | undefined): boolean;
+    /** Sobrescrito em campos com `NgControl` para ler o `FormControl`. */
+    protected resolveControlForRequired(): AbstractControl | null | undefined;
+    /**
+     * Estado visual de erro (borda/label): obrigatório efetivo + control inválido +
+     * só após interação com o valor (`dirty`) ou envio do formulário (`submitted`).
+     * Não usar `touched` sozinho: blur/tab marca touched sem alterar o valor e não deve mostrar erro.
+     */
+    protected controlInvalidUi(control: AbstractControl | null | undefined): boolean;
+    /** Reactive: `FormGroupDirective` no `<form [formGroup]>`; template-driven: `NgForm`. */
+    protected isParentFormSubmitted(): boolean;
+    /**
+     * Campos OnPush precisam reavaliar `baseInvalid` após o submit do form
+     * (mudança de `submitted` não passa por `statusChanges`).
+     */
+    protected registerFormSubmitRecheck(): void;
+    writeValue(value: T | null): void;
+    /** Sincroniza exibição/DOM após writeValue ou reset do form. */
+    protected afterWriteValue(_value: T | null): void;
+    registerOnChange(fn: (value: T | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected emitModelValue(value: T | null): void;
+    protected notifyTouched(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFieldDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseFieldDirective<any>, never, never, { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "showErrorMessage": { "alias": "showErrorMessage"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showRequiredMark": { "alias": "showRequiredMark"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showPrefixIcon": { "alias": "showPrefixIcon"; "required": false; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; }; "iconLeft": { "alias": "iconLeft"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "mostrarMenuContexto": { "alias": "mostrarMenuContexto"; "required": false; }; "contextMenuItems": { "alias": "contextMenuItems"; "required": false; }; "contextMenuId": { "alias": "contextMenuId"; "required": false; }; }, { "contextMenuSelect": "contextMenuSelect"; }, never, never, true, never>;
+    static ngAcceptInputType_loading: unknown;
+    static ngAcceptInputType_mostrarMenuContexto: unknown;
+}
+
+/** Bloco genérico de skeleton (linhas, caixas, células). */
+declare class SkeletonBlockComponent {
+    /** Largura CSS (ex.: `100%`, `6rem`, `40%`). */
+    width: string;
+    /** Altura CSS. */
+    height: string;
+    /** Raio de canto. */
+    radius: string;
+    animate: boolean;
+    get hostClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonBlockComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonBlockComponent, "app-skeleton-block", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_animate: unknown;
+}
+
+/** Várias linhas de texto placeholder. */
+declare class SkeletonTextComponent {
+    lines: number;
+    /** Largura da última linha em % (1–100). */
+    lastLineWidthPct: number;
+    lineHeight: string;
+    gap: string;
+    animate: boolean;
+    lineIndexes(): number[];
+    widthForLine(i: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonTextComponent, "app-skeleton-text", never, { "lines": { "alias": "lines"; "required": false; }; "lastLineWidthPct": { "alias": "lastLineWidthPct"; "required": false; }; "lineHeight": { "alias": "lineHeight"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_lines: unknown;
+    static ngAcceptInputType_lastLineWidthPct: unknown;
+    static ngAcceptInputType_animate: unknown;
+}
+
+/** Lista vertical de linhas (ex.: opções de dropdown). */
+declare class SkeletonListComponent {
+    rows: number;
+    /** Mostra um “leading” à esquerda (círculo pequeno). */
+    leading: boolean;
+    rowGap: string;
+    /** Altura da barra por linha (alinhada às opções de select ~0,95rem / lh 1,35). */
+    lineHeight: string;
+    animate: boolean;
+    rowIndexes(): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonListComponent, "app-skeleton-list", never, { "rows": { "alias": "rows"; "required": false; }; "leading": { "alias": "leading"; "required": false; }; "rowGap": { "alias": "rowGap"; "required": false; }; "lineHeight": { "alias": "lineHeight"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_rows: unknown;
+    static ngAcceptInputType_leading: unknown;
+    static ngAcceptInputType_animate: unknown;
+}
+
+/** Placeholder de cartão (avatar + texto + ações). */
+declare class SkeletonCardComponent {
+    showActions: boolean;
+    animate: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonCardComponent, "app-skeleton-card", never, { "showActions": { "alias": "showActions"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_showActions: unknown;
+    static ngAcceptInputType_animate: unknown;
+}
+
+/** Placeholder tabular (cabeçalho + linhas + faixa de paginação). */
+declare class SkeletonTableComponent {
+    columnCount: number;
+    rowCount: number;
+    showPager: boolean;
+    animate: boolean;
+    colIndexes(): number[];
+    rowIndexes(): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonTableComponent, "app-skeleton-table", never, { "columnCount": { "alias": "columnCount"; "required": false; }; "rowCount": { "alias": "rowCount"; "required": false; }; "showPager": { "alias": "showPager"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_columnCount: unknown;
+    static ngAcceptInputType_rowCount: unknown;
+    static ngAcceptInputType_showPager: unknown;
+    static ngAcceptInputType_animate: unknown;
+}
+
+/** Mantido por compatibilidade; o layout do skeleton é único para todos os campos. */
+type SkeletonFieldShellVariant = 'text' | 'select';
+/**
+ * Placeholder de campo: barra de valor e, opcionalmente, quadrado à esquerda quando não há
+ * ícone Font Awesome na coluna de prefixo do `app-base-field`.
+ */
+declare class SkeletonFieldShellComponent {
+    /** @deprecated Ignorado: todos os campos usam o mesmo layout. */
+    variant: SkeletonFieldShellVariant;
+    animate: boolean;
+    /**
+     * Quando `false`, não renderiza o quadrado à esquerda (o `app-base-field` já mostra o ícone
+     * de prefixo inerte na coluna correcta durante `loading`).
+     */
+    showLeadingIcon: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonFieldShellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonFieldShellComponent, "app-skeleton-field-shell", never, { "variant": { "alias": "variant"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "showLeadingIcon": { "alias": "showLeadingIcon"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_animate: unknown;
+    static ngAcceptInputType_showLeadingIcon: unknown;
+}
+
+/**
+ * Base visual do campo: caixa com label flutuante, prefixo opcional e erro.
+ * Usada dentro dos componentes de campo (texto, inteiro, decimal).
+ */
+declare class BaseFieldComponent implements OnChanges, OnInit {
+    label: string;
+    errorMessage: string;
+    required: boolean;
+    /** Asterisco visual do obrigatório no label (validação HTML `required` inalterada); por defeito `false`. */
+    showRequiredMark: boolean;
+    invalid: boolean;
+    filled: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    inputId: string;
+    errorId: string;
+    showPrefixIcon: boolean;
+    /** Classes Font Awesome (ex.: `fa-solid fa-user`). Usado com `showPrefixIcon`. */
+    prefixIcon: string;
+    clearable: boolean;
+    clearAriaLabel: string;
+    /**
+     * Quando `true`, renderiza `ng-content` com `[appFieldSuffix]` à direita do input
+     * (antes do botão limpar, se houver).
+     */
+    showSuffixSlot: boolean;
+    /** Alinha o texto do valor à direita no input projetado. */
+    valueAlignEnd: boolean;
+    loading: boolean;
+    /** Variante do skeleton quando {@link loading} é `true`. */
+    skeletonVariant: SkeletonFieldShellVariant;
+    mostrarMenuContexto: boolean;
+    contextMenuItems: readonly MenuNodeItem<string>[];
+    /** Sufixo do `id` do menu (ex.: `meuCampo-ctx`); por defeito deriva-se de {@link inputId}. */
+    contextMenuId: string;
+    clear: EventEmitter<void>;
+    contextMenuSelect: EventEmitter<string>;
+    /** Derivados do template (actualizados em `ngOnChanges`, não getters por CD). */
+    showErrorTpl: boolean;
+    showFloatTpl: boolean;
+    showFaTpl: boolean;
+    prefixIconClassTpl: string;
+    showClearTpl: boolean;
+    showCtxMenuTpl: boolean;
+    showSuffixTpl: boolean;
+    get resolvedContextMenuId(): string;
+    ngOnInit(): void;
+    ngOnChanges(_changes: SimpleChanges): void;
+    private refreshTplFlags;
+    onClearClick(): void;
+    onContextMenuItemSelect(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseFieldComponent, "app-base-field", never, { "label": { "alias": "label"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showRequiredMark": { "alias": "showRequiredMark"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "filled": { "alias": "filled"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "errorId": { "alias": "errorId"; "required": false; }; "showPrefixIcon": { "alias": "showPrefixIcon"; "required": false; }; "prefixIcon": { "alias": "prefixIcon"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "clearAriaLabel": { "alias": "clearAriaLabel"; "required": false; }; "showSuffixSlot": { "alias": "showSuffixSlot"; "required": false; }; "valueAlignEnd": { "alias": "valueAlignEnd"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "skeletonVariant": { "alias": "skeletonVariant"; "required": false; }; "mostrarMenuContexto": { "alias": "mostrarMenuContexto"; "required": false; }; "contextMenuItems": { "alias": "contextMenuItems"; "required": false; }; "contextMenuId": { "alias": "contextMenuId"; "required": false; }; }, { "clear": "clear"; "contextMenuSelect": "contextMenuSelect"; }, never, ["[appFieldPrefix]", "*", "[appFieldSuffix]"], true, never>;
+    static ngAcceptInputType_loading: unknown;
+    static ngAcceptInputType_mostrarMenuContexto: unknown;
+}
+
+/**
+ * Campos com `NgControl` + CVA: injeta o control e expõe estado de erro/a11y comuns.
+ */
+declare abstract class NgControlFieldDirective<T> extends BaseFieldDirective<T> implements OnInit, OnChanges, DoCheck {
+    protected ngControl: NgControl | null;
+    /** `FormGroupDirective.submitted` muda com `resetForm()` sem `ngSubmit` — OnPush precisa disto para a borda/erro. */
+    private lastParentSubmitted;
+    /**
+     * Texto do label flutuante em `app-base-field` (`label` ou `placeholder`).
+     * Mantido em campo (não getter) para reduzir trabalho por ciclo de deteção.
+     */
+    floatLabelCaption: string;
+    /** Cache para o template (evita `getErrorMessage()` / getters a cada CD). */
+    uiErrorMessage: string;
+    uiRequiredEffective: boolean;
+    uiInvalid: boolean;
+    uiAriaDescribedBy: string | null;
+    protected resolveControlForRequired(): AbstractControl | null | undefined;
+    ngOnChanges(_changes: SimpleChanges): void;
+    private refreshFloatLabelCaption;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    writeValue(value: T | null): void;
+    /**
+     * Após propagar o valor ao `FormControl`, reavalia já `uiInvalid` / a11y.
+     * Só confiar em `valueChanges` pode deixar o estado visual desfasado (ex.: select após escolha).
+     */
+    protected emitModelValue(value: T | null): void;
+    protected registerFormSubmitRecheck(): void;
+    /**
+     * Actualiza caches usados no template após mudança de valor/estado do control
+     * ou de inputs que afectam mensagem / obrigatório.
+     */
+    protected syncControlUi(): void;
+    get baseInvalid(): boolean;
+    get errorElementId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgControlFieldDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgControlFieldDirective<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class TextFieldComponent extends NgControlFieldDirective<string | null> {
+    /** Limite de caracteres no valor do campo. */
+    maxLength: number;
+    inputText: string;
+    filledUi: boolean;
+    private refreshFilledUi;
+    protected afterWriteValue(value: string | null): void;
+    onNativeInput(event: Event): void;
+    onBlur(): void;
+    onClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextFieldComponent, "app-text-field", never, { "maxLength": { "alias": "maxLength"; "required": false; }; }, {}, never, ["[appFieldPrefix]"], true, never>;
+    static ngAcceptInputType_maxLength: unknown;
+}
+
+declare class PasswordFieldComponent extends NgControlFieldDirective<string | null> implements OnInit {
+    get hostInvalidClass(): boolean;
+    /** Por defeito `false`: o botão de limpar compete com o toggle de visibilidade. */
+    clearable: boolean;
+    maxLength: number;
+    /** Atributo HTML `autocomplete` (senha actual vs. nova senha). */
+    autoComplete: 'off' | 'current-password' | 'new-password';
+    /** `false` = caracteres ocultos (ícone olho aberto para revelar). */
+    passwordVisible: boolean;
+    inputText: string;
+    filledUi: boolean;
+    inputTypeUi: 'password' | 'text';
+    toggleAriaLabelUi: string;
+    toggleIconClassUi: string;
+    ngOnInit(): void;
+    private refreshFilledUi;
+    private refreshPasswordToggleUi;
+    protected afterWriteValue(value: string | null): void;
+    onNativeInput(event: Event): void;
+    onBlur(): void;
+    onClear(): void;
+    togglePasswordVisible(ev: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PasswordFieldComponent, "app-password-field", never, { "clearable": { "alias": "clearable"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "autoComplete": { "alias": "autoComplete"; "required": false; }; }, {}, never, ["[appFieldPrefix]"], true, never>;
+    static ngAcceptInputType_clearable: unknown;
+    static ngAcceptInputType_maxLength: unknown;
+}
+
+declare class TextareaFieldComponent extends NgControlFieldDirective<string | null> implements OnChanges, OnInit {
+    get hostInvalidClass(): boolean;
+    /** Limite de caracteres no valor do campo. `0` = sem limite explícito no DOM. */
+    maxLength: number;
+    rows: number;
+    /**
+     * Limite de altura em linhas (mesma lógica de `rows`). Por omissão igual a {@link rows}.
+     * O campo não é redimensionável pelo usuário (`resize: none`).
+     */
+    maxResizeRows: number;
+    inputText: string;
+    filledUi: boolean;
+    /** Altura CSS (evita getter chamado a cada CD). */
+    textareaMaxHeightCss: string;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateTextareaHeight;
+    private refreshFilledUi;
+    protected afterWriteValue(value: string | null): void;
+    onNativeInput(event: Event): void;
+    onBlur(): void;
+    onClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextareaFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextareaFieldComponent, "app-textarea-field", never, { "maxLength": { "alias": "maxLength"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "maxResizeRows": { "alias": "maxResizeRows"; "required": false; }; }, {}, never, ["[appFieldPrefix]"], true, never>;
+    static ngAcceptInputType_maxLength: unknown;
+    static ngAcceptInputType_rows: unknown;
+    static ngAcceptInputType_maxResizeRows: unknown;
+}
+
+declare class IntegerFieldComponent extends NgControlFieldDirective<number | null> {
+    /** Valor máximo permitido (inclusive). */
+    max: number;
+    inputText: string;
+    filledUi: boolean;
+    private refreshFilledUi;
+    protected afterWriteValue(value: number | null): void;
+    onBeforeInput(event: Event): void;
+    onNativeInput(event: Event): void;
+    onBlur(): void;
+    onClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntegerFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IntegerFieldComponent, "app-integer-field", never, { "max": { "alias": "max"; "required": false; }; }, {}, never, ["[appFieldPrefix]"], true, never>;
+    static ngAcceptInputType_max: unknown;
+}
+
+declare class DecimalFieldComponent extends NgControlFieldDirective<number | null> {
+    /** Valor máximo permitido (inclusive), com até 2 casas decimais. */
+    max: number;
+    inputText: string;
+    filledUi: boolean;
+    private refreshFilledUi;
+    protected afterWriteValue(value: number | null): void;
+    onBeforeInput(event: Event): void;
+    onNativeInput(event: Event): void;
+    onBlur(): void;
+    onClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DecimalFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DecimalFieldComponent, "app-decimal-field", never, { "max": { "alias": "max"; "required": false; }; }, {}, never, ["[appFieldPrefix]"], true, never>;
+    static ngAcceptInputType_max: unknown;
+}
+
+declare class DateFieldComponent extends NgControlFieldDirective<string | null> implements OnChanges {
+    picker?: MatDatepicker<Date>;
+    /**
+     * Se `true`, a formatação inclui hh:mm (24h) e, ao escolher no calendário,
+     * usa a hora actual local no momento da selecção.
+     */
+    showTimeHours: boolean;
+    minDate: Date | null;
+    maxDate: Date | null;
+    innerDate: Date | null;
+    filledUi: boolean;
+    /** Texto da data no span (evita getter no template). */
+    displayTextUi: string;
+    ngOnChanges(changes: SimpleChanges): void;
+    private refreshFilledUi;
+    private refreshDateDisplay;
+    protected afterWriteValue(value: string | null): void;
+    openPicker(): void;
+    onGhostInputKeydown(ev: KeyboardEvent): void;
+    onPickedDate(next: Date | null): void;
+    onBlur(): void;
+    onClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateFieldComponent, "app-date-field", never, { "showTimeHours": { "alias": "showTimeHours"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, {}, never, ["[appFieldPrefix]"], true, never>;
+    static ngAcceptInputType_showTimeHours: unknown;
+}
+
+/**
+ * Campo de texto com máscara visual; valor do modelo = **apenas dígitos** (string), sem máscara.
+ */
+declare abstract class MaskedTextFieldBase extends NgControlFieldDirective<string | null> {
+    /** Padrão com `#` para cada dígito (ex.: `#####-###`). Subclasses podem sobrescrever {@link pattern}. */
+    maskPattern: string;
+    inputText: string;
+    /** Preenchido (só dígitos) para o label flutuante; actualizado com o texto mascarado. */
+    filledUi: boolean;
+    /** Padrão efetivo (permite CEP/telefone fixarem máscaras em subclasses). */
+    protected get pattern(): string;
+    /**
+     * Padrão de formatação para o valor digitado (só dígitos).
+     * Sobrescrever para máscara dinâmica (ex.: CPF até 11 dígitos, CNPJ depois).
+     */
+    protected maskPatternFromDigits(digitsOnly: string): string;
+    protected refreshMaskFilledUi(): void;
+    protected afterWriteValue(value: string | null): void;
+    /**
+     * Dígitos abaixo do tamanho da máscara actual (fixa ou dinâmica, ex. CPF/CNPJ), com valor parcial.
+     * Aplica-se também sem obrigatório: máscara incompleta deve mostrar erro na UI (alinhado a `maskIncomplete`).
+     * Mesma regra temporal que {@link BaseFieldDirective.controlInvalidUi}: `dirty` ou submit (não só `touched`).
+     */
+    protected isMaskIncompleteForUi(): boolean;
+    get baseInvalid(): boolean;
+    getErrorMessage(): string;
+    protected onMaskedInput(event: Event): void;
+    protected onMaskedBlur(): void;
+    protected onMaskedClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaskedTextFieldBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MaskedTextFieldBase, never, never, { "maskPattern": { "alias": "maskPattern"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Campo de texto com máscara configurável (`#` = dígito).
+ * Valor do formulário: apenas dígitos, sem máscara.
+ */
+declare class InputMaskFieldComponent extends MaskedTextFieldBase {
+    get hostInvalidClass(): boolean;
+    /** Ex.: `#####-###`, `(##) #####-####`. */
+    maskPattern: string;
+    onNativeInput(event: Event): void;
+    onBlur(): void;
+    onClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputMaskFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputMaskFieldComponent, "app-input-mask-field", never, { "maskPattern": { "alias": "maskPattern"; "required": false; }; }, {}, never, ["[appFieldPrefix]"], true, never>;
+}
+
+/** CEP brasileiro (8 dígitos). Valor do modelo: só dígitos, ex. `01310100`. */
+declare class CepFieldComponent extends MaskedTextFieldBase {
+    get hostInvalidClass(): boolean;
+    maskPattern: string;
+    onNativeInput(event: Event): void;
+    onBlur(): void;
+    onClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CepFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CepFieldComponent, "app-cep-field", never, { "maskPattern": { "alias": "maskPattern"; "required": false; }; }, {}, never, ["[appFieldPrefix]"], true, never>;
+}
+
+/**
+ * Telefone BR: celular 11 dígitos `(##) #####-####` ou fixo 10 `(##) ####-####`.
+ * Valor do modelo: só dígitos (DDD + número), ex. `11999999999` ou `1133334444`.
+ */
+declare class PhoneFieldComponent extends MaskedTextFieldBase {
+    get hostInvalidClass(): boolean;
+    /** Se `true`, máscara de fixo (10 dígitos). Se `false`, celular (11). */
+    landline: boolean;
+    /**
+     * Máscara manual (com `#`). Se vazio, usa celular ou fixo conforme {@link landline}.
+     */
+    maskPattern: string;
+    protected get pattern(): string;
+    onNativeInput(event: Event): void;
+    onBlur(): void;
+    onClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PhoneFieldComponent, "app-phone-field", never, { "landline": { "alias": "landline"; "required": false; }; "maskPattern": { "alias": "maskPattern"; "required": false; }; }, {}, never, ["[appFieldPrefix]"], true, never>;
+    static ngAcceptInputType_landline: unknown;
+}
+
+/**
+ * CPF (11 dígitos) ou CNPJ (14 dígitos) no mesmo campo.
+ * Até 11 dígitos: `###.###.###-##`; a partir do 12º: `##.###.###/####-##`.
+ * Valor do modelo: só dígitos, ex. `12345678901` ou `12345678000190`.
+ */
+declare class CpfCnpjFieldComponent extends MaskedTextFieldBase {
+    private static readonly CPF_MASK;
+    private static readonly CNPJ_MASK;
+    get hostInvalidClass(): boolean;
+    /** Ignorado: a máscara é definida dinamicamente por {@link maskPatternFromDigits}. */
+    maskPattern: string;
+    protected maskPatternFromDigits(digitsOnly: string): string;
+    onNativeInput(event: Event): void;
+    onBlur(): void;
+    onClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CpfCnpjFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CpfCnpjFieldComponent, "app-cpf-cnpj-field", never, { "maskPattern": { "alias": "maskPattern"; "required": false; }; }, {}, never, ["[appFieldPrefix]"], true, never>;
+}
+
+/**
+ * Máscara com `#` como placeholder de um dígito (0–9); restantes caracteres são literais.
+ * Ex.: `#####-###` (CEP), `(##) #####-####` (celular BR 11 dígitos).
+ */
+/** Remove tudo que não é dígito. */
+declare function stripToDigits(s: string): string;
+/** Conta quantos `#` existem no padrão (= número máximo de dígitos). */
+declare function maskDigitCount(pattern: string): number;
+/**
+ * Formata apenas dígitos segundo o padrão. Não adiciona literais à direita sem dígitos
+ * correspondentes (ex.: não fica "12345-" com 5 dígitos).
+ */
+declare function formatMaskDigits(digitsOnly: string, pattern: string): string;
+
+/**
+ * Validação alinhada às máscaras dinâmicas CPF/CNPJ: só dígitos; 11 ou 14 completos.
+ * Vazio fica para `Validators.required`; com dígitos a menos devolve `maskIncomplete`.
+ */
+declare function cpfCnpjMaskCompleteValidator(): ValidatorFn;
+/**
+ * Telefone BR só dígitos (DDD + número): 10 fixo ou 11 celular, conforme {@link landline}.
+ * Usar com `app-phone-field` para que `FormControl.invalid` e ícones de grupo/aba coincidam com a UI.
+ */
+declare function phoneBrMaskCompleteValidator(landline: boolean): ValidatorFn;
+/**
+ * Máscara com número fixo de dígitos (valor do modelo só dígitos, como CEP/telefone).
+ * Valor vazio: `null` (delega em `Validators.required`); com dígitos a menos: `maskIncomplete`.
+ */
+declare function fixedDigitsMaskCompleteValidator(expectedDigits: number): ValidatorFn;
+/** CEP brasileiro (`app-cep-field`): 8 dígitos. Usar com `Validators.required`. */
+declare function cepMaskCompleteValidator(): ValidatorFn;
+
+/**
+ * Contrato documental de entradas visuais comuns (campos com `BaseFieldDirective`).
+ * Nem todos os membros existem em todos os componentes; use como referência de API.
+ *
+ * **Aliases estáveis:** `iconLeft` → `prefixIcon` (mesmo valor).
+ */
+interface FieldCommonInputs {
+    label: string;
+    placeholder: string;
+    /** Mensagem de erro sob o campo; vazia usa o texto padrão quando inválido. */
+    errorMessage: string;
+    /** Por defeito `false` na `BaseFieldDirective`. */
+    showErrorMessage?: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    /** Asterisco no label quando obrigatório; padrão `false` na `BaseFieldDirective`. */
+    showRequiredMark?: boolean;
+    id: string;
+    name: string;
+    /** Ícone Font Awesome à esquerda; use com `showPrefixIcon`. */
+    showPrefixIcon?: boolean;
+    prefixIcon?: string;
+    /** Alias de `prefixIcon`. */
+    iconLeft?: string;
+    clearable?: boolean;
+    clearAriaLabel?: string;
+    /** `true` = sugestões do navegador; padrão nos componentes é `false`. */
+    autocomplete?: boolean;
+    /** Skeleton no `app-base-field` enquanto dados externos carregam. */
+    loading?: boolean;
+    /** Botão «…» no sufixo com menu de ações; padrão `false` na `BaseFieldDirective`. */
+    mostrarMenuContexto?: boolean;
+    /** Itens do menu do sufixo; só mostra o botão se a lista tiver entradas. */
+    contextMenuItems?: readonly MenuNodeItem<string>[];
+    /** `id` ARIA do menu do sufixo; por defeito `{id do campo}-ctx`. */
+    contextMenuId?: string;
+    /** Texto: limite de caracteres (padrão no componente). */
+    maxLength?: number;
+    /** Inteiro/decimal: valor máximo numérico (padrão no componente). */
+    max?: number;
+    /** Data: formatação com hh:mm e hora atual ao escolher no calendário. */
+    showTimeHours?: boolean;
+    /** Data: limite inferior do calendário. */
+    minDate?: Date | null;
+    /** Data: limite superior do calendário. */
+    maxDate?: Date | null;
+}
+
+interface UiSelectOption<T = unknown> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+}
+
+/** Unidades federativas do Brasil (nome + sigla). Ordem alfabética por nome. */
+declare const BR_ESTADOS_NOME_SIGLA: ReadonlyArray<{
+    nome: string;
+    sigla: string;
+}>;
+declare function mapEstadosToOptions(slice: ReadonlyArray<{
+    nome: string;
+    sigla: string;
+}>): UiSelectOption<string>[];
+
+/**
+ * Mantém apenas dígitos (0–9). Primeira versão sem sinal negativo.
+ */
+declare function sanitizeIntegerDigits(raw: string): string;
+declare function parseIntegerString(digits: string): number | null;
+
+/**
+ * Formatação pt-BR para inteiros: apenas separador de milhar com ponto.
+ * Usado pelo campo inteiro e pela parte inteira do decimal.
+ */
+/**
+ * Formata sequência de dígitos com pontos de milhar (ex.: 1234567 → 1.234.567).
+ * Aceita string vazia; não normaliza zeros à esquerda.
+ */
+declare function formatIntegerThousandsBr(intDigits: string): string;
+/**
+ * Quantidade de dígitos à esquerda do caret na máscara (pontos ignorados).
+ */
+declare function semanticIntegerDigitCountLeft(display: string, caret: number): number;
+/**
+ * Índice do caret após o enésimo dígito na string formatada (fim se não houver tantos).
+ */
+declare function caretIndexFromIntegerDigitCount(display: string, digitCount: number): number;
+
+/**
+ * Utilitários pt-BR fixo: vírgula decimal, ponto milhar, duas casas na formatação final.
+ */
+
+declare function sanitizeDecimalBrInput(raw: string): string;
+/**
+ * Remove pontos e interpreta a última vírgula como separador decimal.
+ * Retorna apenas dígitos na parte inteira e até 2 na fracionária.
+ */
+declare function extractDecimalBrParts(rawDisplay: string): {
+    intDigits: string;
+    fracDigits: string;
+    hasComma: boolean;
+};
+/**
+ * Monta o texto exibido durante a digitação (milhares com ponto, vírgula decimal).
+ */
+declare function buildDecimalBrDisplay(parts: {
+    intDigits: string;
+    fracDigits: string;
+    hasComma: boolean;
+}): string;
+/**
+ * Posição semântica do cursor para remapear após reformatar.
+ */
+declare function semanticCaretAt(value: string, caret: number): {
+    intCount: number;
+    afterComma: boolean;
+    fracCount: number;
+};
+/**
+ * Índice do caret no texto formatado a partir da posição semântica.
+ */
+declare function caretIndexFromSemantic(display: string, target: {
+    intCount: number;
+    afterComma: boolean;
+    fracCount: number;
+}): number;
+/**
+ * String passível de parseDecimalBr a partir das partes editáveis.
+ */
+declare function buildDecimalBrParseString(parts: {
+    intDigits: string;
+    fracDigits: string;
+    hasComma: boolean;
+}): string;
+/**
+ * Interpreta string já sanitizada e retorna número com até 2 casas decimais (arredondamento).
+ * Vazio → null. Vírgula como separador decimal; pontos são removidos da parte inteira.
+ */
+declare function parseDecimalBr(sanitized: string): number | null;
+declare function formatDecimalBr(value: number): string;
+
+/**
+ * Formatação e normalização de data/hora no padrão pt-BR (lib ui-fields).
+ */
+/**
+ * Exibe data como dd/mm/aaaa; com `showTimeHours`, dd/mm/aaaa hh:mm:ss (24h).
+ */
+declare function formatDateTimePtBr(date: Date, showTimeHours: boolean): string;
+/**
+ * Interpreta valor vindo do formulário / API.
+ * Aceita data local sem fuso (`YYYY-MM-DD` ou `YYYY-MM-DDTHH:mm:ss`), `Date`, número ou ISO com `Z`.
+ */
+declare function parseUiFieldDateValue(value: unknown): Date | null;
+/**
+ * Valor persistido no `FormControl`: horário de parede local, sem `Z`
+ * (evita 14:59 no input virar 17:59 no `JSON.stringify` de `Date`).
+ */
+declare function formatUiFieldDateValue(d: Date, showTimeHours: boolean): string;
+/** @deprecated use {@link parseUiFieldDateValue} */
+declare function normalizeFormDateValue(value: unknown): Date | null;
+/**
+ * Data escolhida no calendário: meia-noite local, ou com `showTimeHours` a hora completa
+ * (h, min, s, ms) do instante da seleção.
+ */
+declare function applyPickedCalendarDate(picked: Date, showTimeHours: boolean): Date;
+
+declare abstract class BooleanFieldDirective extends BaseFieldDirective<boolean | null> implements OnInit, OnChanges, DoCheck {
+    protected ngControl: NgControl | null;
+    /** Ver {@link NgControlFieldDirective.ngDoCheck} — `resetForm()` sem `ngSubmit`. */
+    private lastParentSubmitted;
+    checked: boolean;
+    /** Cache para templates OnPush (evita getters a cada CD). */
+    uiInvalid: boolean;
+    uiErrorMessage: string;
+    uiAriaDescribedBy: string | null;
+    uiRequiredEffective: boolean;
+    /** Por omissão não mostra o parágrafo de erro (checkbox/switch); alinhado à base dos campos. */
+    showErrorMessage: boolean;
+    protected resolveControlForRequired(): AbstractControl | null | undefined;
+    ngOnChanges(_changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    /**
+     * Checkbox/switch: mostrar erro após alterar o valor (`dirty`), após foco (`touched`)
+     * ou após envio do formulário — ao contrário dos inputs de texto, não há “valor intermédio”
+     * e o utilizador espera feedback imediato ao marcar/desmarcar.
+     */
+    protected boolInvalidShownAfterInteraction(control: AbstractControl | null | undefined): boolean;
+    protected controlInvalidUi(control: AbstractControl | null | undefined): boolean;
+    protected syncBoolUi(): void;
+    private registerFormSubmitRecheckBool;
+    protected afterWriteValue(value: boolean | null): void;
+    protected setChecked(next: boolean): void;
+    get baseInvalid(): boolean;
+    /**
+     * A classe base só devolvia texto quando `isEffectiveRequired` batia com o mesmo instante
+     * do `NgControl`; com `requiredTrue` + submit, o estado vermelho aparecia sem mensagem.
+     */
+    getErrorMessage(): string;
+    get errorElementId(): string;
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BooleanFieldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BooleanFieldDirective, never, never, { "showErrorMessage": { "alias": "showErrorMessage"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CheckboxFieldComponent extends BooleanFieldDirective {
+    onCheckboxClick(ev: MouseEvent): void;
+    onNativeChange(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxFieldComponent, "app-checkbox-field", never, {}, {}, never, never, true, never>;
+}
+
+declare class SwitchFieldComponent extends BooleanFieldDirective {
+    get labelId(): string;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SwitchFieldComponent, "app-switch-field", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Base de overlay para **listas ligadas a campos** (select, dropdown-menu, etc.).
+ * Para tooltips/popovers genéricos ver `AnchoredOverlayComponent` em `overlay/` — mesma stack CDK e tema,
+ * API de fecho semelhante (`open`/`openChange`, Escape), mas defaults diferentes (ex.: backdrop em dropdowns).
+ */
+declare class DropdownBaseComponent {
+    private readonly appTheme;
+    /**
+     * O overlay do CDK fica sob `body`; sem estas classes, `var(--app-color-*)` cai no `:root`.
+     * Tem de ser **array**: uma única string com espaço quebra `classList.add` e as classes não aplicam.
+     */
+    readonly overlayPanelClasses: i0.Signal<string[]>;
+    /**
+     * O CDK não reaplica `cdkConnectedOverlayPanelClass` quando o overlay já existe.
+     * As classes de tema no painel interno seguem o tema activo sempre.
+     */
+    readonly panelThemeNgClass: i0.Signal<{
+        [x: string]: boolean;
+        'app-library-theme': boolean;
+    }>;
+    open: boolean;
+    readonly openChange: EventEmitter<boolean>;
+    /** Conteúdo do painel (lista, etc.) renderizado no overlay. */
+    panelTemplate: TemplateRef<unknown>;
+    /** Largura do painel em px (ex.: largura total do campo). */
+    panelWidthPx: number | null;
+    closeOnEscape: boolean;
+    hasBackdrop: boolean;
+    /**
+     * Posições do overlay ligadas ao trigger (ex.: menu com flip vertical).
+     * Por omissão mantém o alinhamento clássico «por baixo» dos campos.
+     */
+    connectedPositions: ConnectedPosition[] | undefined;
+    /** Empurra o overlay para caber no viewport quando há espaço insuficiente. */
+    pushConnectedOverlay: boolean;
+    /**
+     * `true`: painel sem fundo/borda/sombra próprios — o conteúdo (ex.: `app-menu-list`) define o chrome.
+     * Evita dupla moldura com `menu-surface-shell` nos menus de acção.
+     */
+    bareOverlayPanel: boolean;
+    get overlayWidthPx(): number;
+    get effectiveConnectedPositions(): ConnectedPosition[];
+    onBackdropClick(): void;
+    /**
+     * Cliques noutros controlos (fora do painel e fora do trigger) nem sempre passam pelo backdrop;
+     * o CDK expõe `overlayOutsideClick` para o mesmo efeito de fechar.
+     */
+    onOverlayOutsideClick(): void;
+    onOverlayKeydown(ev: KeyboardEvent): void;
+    setOpen(next: boolean): void;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownBaseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownBaseComponent, "app-dropdown-base", never, { "open": { "alias": "open"; "required": false; }; "panelTemplate": { "alias": "panelTemplate"; "required": true; }; "panelWidthPx": { "alias": "panelWidthPx"; "required": false; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "connectedPositions": { "alias": "connectedPositions"; "required": false; }; "pushConnectedOverlay": { "alias": "pushConnectedOverlay"; "required": false; }; "bareOverlayPanel": { "alias": "bareOverlayPanel"; "required": false; }; }, { "openChange": "openChange"; }, never, ["[appDropdownTrigger]"], true, never>;
+    static ngAcceptInputType_open: unknown;
+    static ngAcceptInputType_closeOnEscape: unknown;
+    static ngAcceptInputType_hasBackdrop: unknown;
+    static ngAcceptInputType_pushConnectedOverlay: unknown;
+    static ngAcceptInputType_bareOverlayPanel: unknown;
+}
+
+/**
+ * Lógica comum de select / combobox: opções, índice ativo, comparação e
+ * `notifyTouched` após seleção (evita flicker vermelho → válido no frame em que o valor ainda não atualizou o `FormControl`).
+ */
+declare abstract class DropdownOptionFieldBase extends NgControlFieldDirective<unknown | null> {
+    /** Estado “tem valor” para o label flutuante (evita getter no template). */
+    filledUi: boolean;
+    private _options;
+    get options(): ReadonlyArray<UiSelectOption<unknown>>;
+    set options(value: ReadonlyArray<UiSelectOption<unknown>>);
+    /** Alias de {@link options}. */
+    set itemsInput(value: ReadonlyArray<UiSelectOption<unknown>>);
+    private _compareWith;
+    get compareWith(): (a: unknown, b: unknown) => boolean;
+    set compareWith(fn: (a: unknown, b: unknown) => boolean);
+    /** Alias de {@link compareWith}. */
+    set compareBy(fn: (a: unknown, b: unknown) => boolean);
+    /** Lista de opções ainda a carregar (painel aberto ou primeiro fetch). */
+    optionsLoading: boolean;
+    activeIndex: number;
+    protected refreshFilledUi(): void;
+    writeValue(value: unknown | null): void;
+    protected emitModelValue(value: unknown | null): void;
+    /**
+     * Opções na ordem de exibição no painel: valor atual (se existir em `options`) em primeiro lugar.
+     */
+    get listOptions(): ReadonlyArray<UiSelectOption<unknown>>;
+    /**
+     * Chamar após `emitModelValue` + fechar painel ao **escolher** um item.
+     * Adia `notifyTouched` para o próximo microtask para o validador já ver o valor novo.
+     */
+    protected finishSelectionTouch(): void;
+    trackOption(_index: number, opt: UiSelectOption<unknown>): unknown;
+    isSelected(opt: UiSelectOption<unknown>): boolean;
+    protected findOptionByValue(value: unknown | null): UiSelectOption<unknown> | undefined;
+    protected matches(a: unknown, b: unknown): boolean;
+    protected syncActiveIndexFromValue(value: unknown | null): void;
+    protected firstEnabledIndex(): number;
+    protected lastEnabledIndex(): number;
+    protected stepActive(delta: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownOptionFieldBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownOptionFieldBase, never, never, { "options": { "alias": "options"; "required": false; }; "itemsInput": { "alias": "items"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "compareBy": { "alias": "compareBy"; "required": false; }; "optionsLoading": { "alias": "optionsLoading"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_optionsLoading: unknown;
+}
+
+/**
+ * Base para multiselect: valor `unknown[]`, opções, índice ativo (teclado) e comparação.
+ */
+declare abstract class DropdownMultiOptionFieldBase extends NgControlFieldDirective<unknown[]> {
+    filledUi: boolean;
+    private _options;
+    get options(): ReadonlyArray<UiSelectOption<unknown>>;
+    set options(value: ReadonlyArray<UiSelectOption<unknown>>);
+    /** Alias de {@link options}. */
+    set itemsInput(value: ReadonlyArray<UiSelectOption<unknown>>);
+    private _compareWith;
+    get compareWith(): (a: unknown, b: unknown) => boolean;
+    set compareWith(fn: (a: unknown, b: unknown) => boolean);
+    /** Alias de {@link compareWith}. */
+    set compareBy(fn: (a: unknown, b: unknown) => boolean);
+    /** Lista de opções ainda a carregar. */
+    optionsLoading: boolean;
+    activeIndex: number;
+    protected refreshMultiFilledUi(): void;
+    protected emitModelValue(value: unknown[] | null): void;
+    /**
+     * Opções com as selecionadas primeiro (mesma ordem relativa que em `options`).
+     */
+    get listOptions(): ReadonlyArray<UiSelectOption<unknown>>;
+    protected finishMultiTouch(): void;
+    trackOption(_index: number, opt: UiSelectOption<unknown>): unknown;
+    isSelected(opt: UiSelectOption<unknown>): boolean;
+    protected findOptionByValue(value: unknown | null): UiSelectOption<unknown> | undefined;
+    protected matches(a: unknown, b: unknown): boolean;
+    protected syncActiveIndexToFirstEnabled(): void;
+    protected firstEnabledIndex(): number;
+    protected lastEnabledIndex(): number;
+    protected stepActive(delta: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownMultiOptionFieldBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownMultiOptionFieldBase, never, never, { "options": { "alias": "options"; "required": false; }; "itemsInput": { "alias": "items"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "compareBy": { "alias": "compareBy"; "required": false; }; "optionsLoading": { "alias": "optionsLoading"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_optionsLoading: unknown;
+}
+
+/** Evento emitido pelo select paginado ao precisar de mais dados (ex.: backend / combobox). */
+interface SelectPageRequested {
+    /** Página 0-based (0 = primeiros `pageSize` itens). */
+    page: number;
+    pageSize: number;
+}
+
+declare class SelectFieldComponent extends DropdownOptionFieldBase implements OnDestroy, OnChanges {
+    private readonly hostRef;
+    get hostInvalidClass(): boolean;
+    pagination: boolean;
+    /** Alias de {@link pagination} (listas paginadas / infinitas). */
+    set pageableInput(value: boolean);
+    pageSize: number;
+    hasMore: boolean;
+    loadingMore: boolean;
+    readonly pageRequested: EventEmitter<SelectPageRequested>;
+    optionsPanelTpl: TemplateRef<unknown>;
+    private readonly dropdownTriggerRootRef;
+    panelOpen: boolean;
+    panelOverlayWidth: number;
+    private scrollLoadTimer;
+    protected afterWriteValue(value: unknown | null): void;
+    get displayValue(): string;
+    get optionsListId(): string;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onDropdownOpenChange(next: boolean): void;
+    /**
+     * Com painel aberto, o foco permanece no botão (como no combobox no input):
+     * setas / Home / End / Enter / Espaço tratados aqui; Escape fecha.
+     */
+    onTriggerKeydown(ev: KeyboardEvent): void;
+    private focusValueButtonIfFocusLost;
+    onOptionsListScroll(ev: Event): void;
+    private emitNextPageRequest;
+    private tryEmitIfShortList;
+    openToggle(): void;
+    /** Enter/Espaço com foco na linha da opção (tabindex). */
+    onOptionRowKeydown(ev: KeyboardEvent, opt: UiSelectOption<unknown>): void;
+    onListKeydown(ev: KeyboardEvent): void;
+    selectOption(opt: UiSelectOption<unknown>): void;
+    onClear(): void;
+    /**
+     * Blur no valor/chevron ou na lista: fecha o painel se o foco saiu do campo e do overlay CDK.
+     */
+    onDropdownBlur(ev?: FocusEvent): void;
+    /** Escape com foco no limpar/prefixo do `base-field` (não passa pelo div da origem do overlay). */
+    onDropdownHostEscape(ev: KeyboardEvent): void;
+    private commitActiveOption;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectFieldComponent, "app-select-field", never, { "pagination": { "alias": "pagination"; "required": false; }; "pageableInput": { "alias": "pageable"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "hasMore": { "alias": "hasMore"; "required": false; }; "loadingMore": { "alias": "loadingMore"; "required": false; }; }, { "pageRequested": "pageRequested"; }, never, ["[appFieldPrefix]"], true, never>;
+    static ngAcceptInputType_pagination: unknown;
+    static ngAcceptInputType_pageableInput: unknown;
+    static ngAcceptInputType_pageSize: unknown;
+}
+
+declare class MultiselectFieldComponent extends DropdownMultiOptionFieldBase implements OnDestroy, OnChanges {
+    private readonly hostRef;
+    get hostInvalidClass(): boolean;
+    /** Por omissão `true`: mesmo padrão do select com lista longa (`pageRequested` + scroll). */
+    pagination: boolean;
+    /** Alias de {@link pagination}. */
+    set pageableInput(value: boolean);
+    pageSize: number;
+    hasMore: boolean;
+    loadingMore: boolean;
+    readonly pageRequested: EventEmitter<SelectPageRequested>;
+    optionsPanelTpl: TemplateRef<unknown>;
+    private readonly dropdownTriggerRootRef;
+    panelOpen: boolean;
+    panelOverlayWidth: number;
+    private scrollLoadTimer;
+    writeValue(value: unknown[] | null): void;
+    protected afterWriteValue(_value: unknown[]): void;
+    /** Texto numa linha: rótulos separados por vírgula + ellipsis no CSS. */
+    get displaySummary(): string;
+    get optionsListId(): string;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onDropdownOpenChange(next: boolean): void;
+    onTriggerKeydown(ev: KeyboardEvent): void;
+    private focusValueButtonIfFocusLost;
+    onOptionsListScroll(ev: Event): void;
+    private emitNextPageRequest;
+    private tryEmitIfShortList;
+    openToggle(): void;
+    toggleOption(opt: UiSelectOption<unknown>): void;
+    private toggleActiveOption;
+    onOptionRowKeydown(ev: KeyboardEvent, opt: UiSelectOption<unknown>): void;
+    onListKeydown(ev: KeyboardEvent): void;
+    onClear(): void;
+    onDropdownBlur(ev?: FocusEvent): void;
+    /** Escape com foco no limpar/prefixo do `base-field` (não passa pelo div da origem do overlay). */
+    onDropdownHostEscape(ev: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiselectFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultiselectFieldComponent, "app-multiselect-field", never, { "pagination": { "alias": "pagination"; "required": false; }; "pageableInput": { "alias": "pageable"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "hasMore": { "alias": "hasMore"; "required": false; }; "loadingMore": { "alias": "loadingMore"; "required": false; }; }, { "pageRequested": "pageRequested"; }, never, ["[appFieldPrefix]"], true, never>;
+    static ngAcceptInputType_pagination: unknown;
+    static ngAcceptInputType_pageableInput: unknown;
+    static ngAcceptInputType_pageSize: unknown;
+}
+
+/** Pedido de página para o campo com busca + scroll infinito. */
+interface DropdownSearchPageRequested {
+    page: number;
+    pageSize: number;
+    /** Filtro atual (após Enter). Vazio = listar tudo paginado. */
+    query: string;
+}
+
+declare enum DropdownSearchOpenMode {
+    Default = "default",
+    KeepInput = "keepInput"
+}
+declare class DropdownSearchFieldComponent extends DropdownOptionFieldBase implements OnDestroy, OnChanges {
+    private readonly hostRef;
+    get hostInvalidClass(): boolean;
+    pageSize: number;
+    hasMore: boolean;
+    loadingMore: boolean;
+    /**
+     * Após parar de digitar, dispara a mesma pesquisa que Enter (`pageRequested` com `query`).
+     * `0` desativa (só Enter pesquisa).
+     */
+    searchDebounceMs: number;
+    readonly pageRequested: EventEmitter<DropdownSearchPageRequested>;
+    optionsPanelTpl: TemplateRef<unknown>;
+    private readonly dropdownTriggerRootRef;
+    searchQuery: string;
+    committedQuery: string;
+    panelOpen: boolean;
+    panelOverlayWidth: number;
+    private scrollLoadTimer;
+    private searchDebounceTimer;
+    protected afterWriteValue(value: unknown | null): void;
+    get displayValue(): string;
+    get optionsListId(): string;
+    /**
+     * Com valor selecionado e painel fechado, o texto é só exibição do rótulo;
+     * edição só com o painel aberto (pesquisa).
+     */
+    get isLockedSelectionDisplay(): boolean;
+    /** `readonly` nativo: prop do campo ou bloqueio de exibição da seleção. */
+    get isNativeInputReadonly(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onDropdownOpenChange(next: boolean, openMode?: DropdownSearchOpenMode): void;
+    onMainInput(ev: Event): void;
+    onMainKeydown(ev: KeyboardEvent): void;
+    /**
+     * Ao reabrir, `committedQuery` é '' (lista sem filtro) e o texto do input é o rótulo do valor —
+     * `q !== committedQuery` seria true sem o usuário ter pesquisado; Enter deve confirmar opção.
+     */
+    private isDisplayingSelectedLabelWithUnfilteredList;
+    onMainBlur(ev?: FocusEvent): void;
+    /**
+     * Sem valor no modelo: remove texto livre deixado no input (ex.: pesquisa sem escolha válida).
+     * Não altera o `FormControl` — mantém-se `null`/vazio e o estado inválido (ex.: obrigatório) continua visível.
+     */
+    private clearOrphanSearchTextAfterBlur;
+    /** Escape com foco no limpar/prefixo do `base-field` (fora do input da origem). */
+    onDropdownHostEscape(ev: KeyboardEvent): void;
+    onTriggerKeydown(ev: KeyboardEvent): void;
+    /** Enter/Espaço com foco na linha da opção (tabindex). */
+    onOptionRowKeydown(ev: KeyboardEvent, opt: UiSelectOption<unknown>): void;
+    /** Foco na lista (ex.: Tab): Delete/Backspace limpam a seleção. */
+    onSearchListKeydown(ev: KeyboardEvent): void;
+    private focusMainInputIfFocusLost;
+    private scheduleDebouncedSearch;
+    private clearSearchDebounce;
+    /**
+     * Alinha-se ao Enter: só dispara se `query` mudou em relação a `committedQuery`;
+     * com painel fechado, só se houver texto pesquisável (como Enter sem abrir vazio).
+     */
+    private applyDebouncedSearch;
+    runSearch(): void;
+    onOptionsListScroll(ev: Event): void;
+    private emitNextPageRequest;
+    private tryEmitIfShortList;
+    openToggle(): void;
+    private commitActiveOption;
+    selectOption(opt: UiSelectOption<unknown>): void;
+    onClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownSearchFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownSearchFieldComponent, "app-dropdown-search-field", never, { "pageSize": { "alias": "pageSize"; "required": false; }; "hasMore": { "alias": "hasMore"; "required": false; }; "loadingMore": { "alias": "loadingMore"; "required": false; }; "searchDebounceMs": { "alias": "searchDebounceMs"; "required": false; }; }, { "pageRequested": "pageRequested"; }, never, ["[appFieldPrefix]"], true, never>;
+    static ngAcceptInputType_pageSize: unknown;
+    static ngAcceptInputType_searchDebounceMs: unknown;
+}
+
+/**
+ * Contrato documental para campos com lista de opções (`select`, `multiselect`, `dropdown-search`).
+ *
+ * **Canónicos / aliases**
+ * - `options` | `items` — mesma lista
+ * - `compareWith` | `compareBy` — mesma função
+ * - `pagination` | `pageable` — só em `select` e `multiselect`
+ */
+interface DropdownListBindings<T = unknown> {
+    options: ReadonlyArray<UiSelectOption<T>>;
+    compareWith: (a: unknown, b: unknown) => boolean;
+}
+
+/** Espaçamento horizontal/vertical entre itens da linha. */
+declare enum FormRowGap {
+    Xs = "xs",
+    Sm = "sm",
+    Md = "md",
+    Lg = "lg"
+}
+/** Alinhamento no eixo cruzado (itens da linha). */
+declare enum FormRowAlign {
+    Start = "start",
+    Center = "center",
+    End = "end",
+    Stretch = "stretch"
+}
+/** Distribuição no eixo principal. */
+declare enum FormRowJustify {
+    Start = "start",
+    Center = "center",
+    End = "end",
+    Between = "between"
+}
+/** Variante visual do grupo. */
+declare enum FormGroupVariant {
+    Default = "default",
+    Outlined = "outlined",
+    Subtle = "subtle"
+}
+/** Alinhamento horizontal no eixo principal (`justify-content`) em `app-layout-stack`. */
+declare enum LayoutStackAlign {
+    Start = "start",
+    Center = "center",
+    End = "end",
+    SpaceBetween = "space-between"
+}
+/** Alinhamento em `app-form-actions` (barra de ações de formulário). */
+declare enum FormActionsAlign {
+    Start = "start",
+    Center = "center",
+    End = "end",
+    SpaceBetween = "space-between"
+}
+
+/** Faixa flexível com projeção de conteúdo (ex.: botões alinhados). */
+declare class LayoutStackComponent {
+    /** Distribuição horizontal dos filhos (`justify-content`). */
+    align: LayoutStackAlign;
+    /**
+     * Em ecrãs estreitos, aplica ajustes leves (ex.: `gap`) mantendo fila + `wrap`.
+     * Por defeito `true`; não é necessário passar no template na maioria dos casos.
+     */
+    stackOnMobile: boolean;
+    /** Linha separadora acima da faixa. Nome explícito para evitar colisão com o esquema DOM em templates aninhados. */
+    stackDivider: boolean;
+    /**
+     * Quando `true` (por defeito), os filhos repartem a largura da faixa (ex.: um botão a 100%;
+     * vários com `flex` igual). Use `false` para faixas compactas (largura intrínseca).
+     */
+    stackFill: boolean;
+    get hostClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutStackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutStackComponent, "app-layout-stack", never, { "align": { "alias": "align"; "required": false; }; "stackOnMobile": { "alias": "stackOnMobile"; "required": false; }; "stackDivider": { "alias": "stackDivider"; "required": false; }; "stackFill": { "alias": "stackFill"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_stackOnMobile: unknown;
+    static ngAcceptInputType_stackDivider: unknown;
+    static ngAcceptInputType_stackFill: unknown;
+}
+
+/** Barra de ações de formulário (Salvar, Cancelar, Adicionar, …). Projeção de conteúdo. */
+declare class FormActionsComponent {
+    align: FormActionsAlign;
+    stackOnMobile: boolean;
+    /**
+     * Por omissão `true`: os botões repartem a largura da faixa (um botão ≈ 100%; vários repartem por igual).
+     * Use `false` para faixa compacta (largura intrínseca, ex.: várias ações alinhadas à direita).
+     */
+    fill: boolean;
+    divider: boolean;
+    /** `FormActionsAlign` e `LayoutStackAlign` partilham os mesmos valores; delegação ao `app-layout-stack`. */
+    get layoutAlign(): LayoutStackAlign;
+    get hostClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormActionsComponent, "app-form-actions", never, { "align": { "alias": "align"; "required": false; }; "stackOnMobile": { "alias": "stackOnMobile"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "divider": { "alias": "divider"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_stackOnMobile: unknown;
+    static ngAcceptInputType_fill: unknown;
+    static ngAcceptInputType_divider: unknown;
+}
+
+/**
+ * Coluna no sistema de 12 trilhos da {@link FormRowComponent}.
+ * Em viewports menores que `sm`, usa `xs` (por defeito largura total).
+ */
+declare class FormColComponent {
+    /** Colunas ocupadas em &lt; `sm` (por defeito 12 = linha inteira). */
+    xs: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+    order?: number;
+    /** Quando `true`, a coluna pode crescer para ocupar espaço livre na linha (flex futuro / composição). */
+    grow: boolean;
+    get hostClass(): string;
+    get hostVars(): string;
+    private clampSpan;
+    private normalizeOptionalSpan;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormColComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormColComponent, "app-form-col", never, { "xs": { "alias": "xs"; "required": false; }; "sm": { "alias": "sm"; "required": false; }; "md": { "alias": "md"; "required": false; }; "lg": { "alias": "lg"; "required": false; }; "xl": { "alias": "xl"; "required": false; }; "order": { "alias": "order"; "required": false; }; "grow": { "alias": "grow"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_xs: unknown;
+    static ngAcceptInputType_order: unknown;
+    static ngAcceptInputType_grow: unknown;
+}
+
+declare class FormGroupComponent implements OnChanges, OnInit, DoCheck {
+    private readonly cdr;
+    private readonly destroyRef;
+    private readonly hostRef;
+    private readonly rootFormDir;
+    titulo: string;
+    subtitulo: string;
+    collapsible: boolean;
+    /**
+     * Quando `true` (padrão), o cabeçalho alterna aberto/fechado (respeita {@link collapsed}).
+     * Quando `false`, o grupo permanece **sempre expandido** (não recolhe), a seta fica só indicativa **em cinza**
+     * e o cabeçalho deixa de ser clicável — útil para seções obrigatórias sempre visíveis.
+     */
+    foldable: boolean;
+    /**
+     * Com `collapsible`: `true` = grupo **fechado** (só cabeçalho visível), `false` = **aberto**.
+     * O pai pode fixar o estado inicial e manter com `(collapsedChange)` ou `[collapsed]` ligado a uma variável.
+     * Se {@link foldable} for `false`, o estado efectivo é sempre **aberto** (ignora-se `collapsed` para o corpo).
+     */
+    collapsed: boolean;
+    disabled: boolean;
+    dense: boolean;
+    canMoveUp: boolean;
+    canMoveDown: boolean;
+    showHeader: boolean;
+    showDivider: boolean;
+    variant: FormGroupVariant;
+    /**
+     * Com `collapsible` e `collapsed`: se `true`, o corpo **não** é criado no DOM enquanto o
+     * grupo está fechado (após a primeira expansão pode voltar a fechar e voltar a desmontar).
+     * Útil para blocos pesados inicialmente fechados; o `FormGroup` reactivo no ascendente
+     * conserva valores — os `FormControlName` religam ao reabrir.
+     */
+    destroyOnCollapse: boolean;
+    /**
+     * Quando `true`, o corpo não força `flex-direction: column` nos filhos projetados (ex.: conteúdo
+     * próprio com grade ou `flex` em linha). O padrão `false` mantém o espaçamento vertical entre
+     * várias `app-form-row` / wrapper com `formGroupName`.
+     */
+    skipBodyChildStacking: boolean;
+    /**
+     * Quando `true`, mostra o ícone de aviso no cabeçalho. O pai deve refletir inválido **e** critério
+     * de UX (ex. `dirty` ou formulário já submetido), não só `touched` — Tab/foco não deve acender sozinho.
+     * Ignorado quando {@link formGroupPath} está definido (usa-se só o cálculo automático).
+     */
+    groupInvalid: boolean;
+    /**
+     * Caminho no `FormGroup` raiz do `<form [formGroup]>` (ex.: `identificacao`, `endereco.morada`).
+     * Quando preenchido, o ícone de aviso é calculado automaticamente a partir do estado reativo,
+     * sem precisar de `[groupInvalid]` manual.
+     */
+    formGroupPath: string;
+    /**
+     * Quando `true`, o critério “já houve tentativa de envio” para o ícone automático (`formGroupPath`)
+     * inclui este sinal (ex.: alinhar a `app-form-tabs` `[warning]` com `markAllAsTouched()` sem `submitted`
+     * no `FormGroupDirective`, ou validação disparada por `(click)` em vez de `submit`).
+     */
+    uxSubmittedPass: boolean;
+    readonly collapsedChange: EventEmitter<boolean>;
+    readonly moveUp: EventEmitter<void>;
+    readonly moveDown: EventEmitter<void>;
+    /** Estado interno espelha o input (OnPush + alterações externas). */
+    private collapsedInternal;
+    /** Evita `scrollIntoView` duplo no mesmo ciclo (clique + `[collapsed]` do pai). */
+    private scrollIntoViewCoalesce;
+    /**
+     * `FormGroupDirective.submitted` nem sempre fica `true` no ciclo do ícone com `[formGroup]` reactivo;
+     * o `submit` nativo do `<form>` garante aviso nos filhos após «Salvar» + `markAllAsTouched()`.
+     * Repõe-se quando o `FormGroup` raiz volta a `VALID`.
+     */
+    private formSubmitPassActive;
+    /** Rastreia `rootFormDir.submitted` para repor {@link formSubmitPassActive} após `resetForm` com raiz ainda inválida. */
+    private prevRootFormSubmitted;
+    ngOnInit(): void;
+    /**
+     * Permite expandir o grupo a partir do exterior (ex.: resumo de validação antes de focar um campo).
+     * `CustomEvent` no host: `ui-request-expand` (sem bubbles).
+     */
+    private setupExpandRequestListener;
+    /** Ícone de aviso: automático com `formGroupPath`, senão `groupInvalid` manual. */
+    get invalidFlagVisible(): boolean;
+    /**
+     * `markAllAsTouched()` / `submitted` não passam sempre por `valueChanges`; com OnPush o getter
+     * do ícone precisa do `submit` do `<form>` ancestral (após um tick) para atualizar.
+     */
+    private setupFormPathInvalidTracking;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** Estado interno de colapso: com `foldable === false` força sempre expandido. */
+    private applyCollapsedFromInputs;
+    get hostClass(): string;
+    get showHeaderBar(): boolean;
+    get isCollapsed(): boolean;
+    get renderBodyInDom(): boolean;
+    get bodyVisuallyHidden(): boolean;
+    get headerIsInteractive(): boolean;
+    onHeaderClick(): void;
+    onHeaderKeydown(ev: KeyboardEvent): void;
+    onMoveUpClick(ev: Event): void;
+    onMoveDownClick(ev: Event): void;
+    private setCollapsed;
+    /**
+     * Após expandir, desloca a vista até ao grupo com scroll nativo suave, só o necessário
+     * (`block: 'nearest'`). Executa após pintar o corpo expandido.
+     */
+    private scheduleScrollIntoView;
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormGroupComponent, "app-form-group", never, { "titulo": { "alias": "titulo"; "required": true; }; "subtitulo": { "alias": "subtitulo"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "foldable": { "alias": "foldable"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "dense": { "alias": "dense"; "required": false; }; "canMoveUp": { "alias": "canMoveUp"; "required": false; }; "canMoveDown": { "alias": "canMoveDown"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "showDivider": { "alias": "showDivider"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "destroyOnCollapse": { "alias": "destroyOnCollapse"; "required": false; }; "skipBodyChildStacking": { "alias": "skipBodyChildStacking"; "required": false; }; "groupInvalid": { "alias": "groupInvalid"; "required": false; }; "formGroupPath": { "alias": "formGroupPath"; "required": false; }; "uxSubmittedPass": { "alias": "uxSubmittedPass"; "required": false; }; }, { "collapsedChange": "collapsedChange"; "moveUp": "moveUp"; "moveDown": "moveDown"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_collapsible: unknown;
+    static ngAcceptInputType_foldable: unknown;
+    static ngAcceptInputType_collapsed: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_dense: unknown;
+    static ngAcceptInputType_canMoveUp: unknown;
+    static ngAcceptInputType_canMoveDown: unknown;
+    static ngAcceptInputType_showHeader: unknown;
+    static ngAcceptInputType_showDivider: unknown;
+    static ngAcceptInputType_destroyOnCollapse: unknown;
+    static ngAcceptInputType_skipBodyChildStacking: unknown;
+    static ngAcceptInputType_groupInvalid: unknown;
+    static ngAcceptInputType_uxSubmittedPass: unknown;
+}
+
+declare class FormRowComponent {
+    gap: FormRowGap;
+    align: FormRowAlign;
+    justify: FormRowJustify;
+    wrap: boolean;
+    stackOnMobile: boolean;
+    get hostClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormRowComponent, "app-form-row", never, { "gap": { "alias": "gap"; "required": false; }; "align": { "alias": "align"; "required": false; }; "justify": { "alias": "justify"; "required": false; }; "wrap": { "alias": "wrap"; "required": false; }; "stackOnMobile": { "alias": "stackOnMobile"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_wrap: unknown;
+    static ngAcceptInputType_stackOnMobile: unknown;
+}
+
+declare class FormSectionComponent {
+    titulo: string;
+    subtitulo: string;
+    dense: boolean;
+    withDivider: boolean;
+    get hostClass(): string;
+    get showHeader(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormSectionComponent, "app-form-section", never, { "titulo": { "alias": "titulo"; "required": true; }; "subtitulo": { "alias": "subtitulo"; "required": false; }; "dense": { "alias": "dense"; "required": false; }; "withDivider": { "alias": "withDivider"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_dense: unknown;
+    static ngAcceptInputType_withDivider: unknown;
+}
+
+/** Variante visual do resumo de validação. */
+type ValidationSummaryVariant = 'error' | 'warning' | 'info';
+/** Item do resumo: mensagem e destino opcional para foco / scroll / destaque. */
+interface ValidationSummaryItem {
+    message: string;
+    /** `id` HTML do controle focável (ex.: o mesmo `[id]` dos campos da lib). */
+    fieldId?: string;
+}
+
+declare class ValidationSummaryComponent implements OnChanges {
+    private static nextTitleUid;
+    private static nextListRegionUid;
+    /** Troca de aba (`beforeItemActivate`) + `queueMicrotask` no `app-form-tabs` — o alvo pode ficar em `[hidden]` até o próximo CD. */
+    private readonly navigateToFieldMaxAttempts;
+    private readonly appRef;
+    private readonly cdr;
+    private readonly injector;
+    private readonly hostRef;
+    /** `id` único para `aria-labelledby` quando há vários resumos na página. */
+    readonly titleElementId: string;
+    /** `id` da região da lista (acessibilidade do botão recolher / expandir). */
+    readonly listRegionId: string;
+    /** Lista simples (retrocompatível). Ignorada se {@link items} tiver entradas. */
+    messages: string[] | null;
+    /** Lista rica com `fieldId` opcional para navegação até o controle. */
+    items: ValidationSummaryItem[] | null;
+    /**
+     * Título do cabeçalho (`title="…"` no template).
+     * Não usar a propriedade `title` na classe: colide com `HTMLElement.title` no host e o
+     * browser pode desenhar tooltip nativo / comportamentos estranhos.
+     */
+    summaryHeading: string;
+    visible: boolean;
+    /**
+     * `false` (padrão): fluxo em documento (ex.: no topo do formulário) — o consumidor pode fazer scroll até o painel.
+     * `true`: painel `position: fixed` no topo do viewport, com fade-in **sem** reservar espaço no formulário
+     * nem alterar o scroll da página (útil em formulários muito longos).
+     */
+    pinned: boolean;
+    variant: ValidationSummaryVariant;
+    compact: boolean;
+    /**
+     * Altura máxima do painel da lista (ex.: `12rem`, `min(40vh, 14rem)`).
+     * Quando definido, a lista obtém scroll vertical interno.
+     */
+    panelMaxHeight: string | null;
+    /** Comportamento de scroll ao centrar o alvo na tela. */
+    scrollBehavior: ScrollBehavior;
+    /**
+     * Chamado antes de localizar o elemento por `fieldId` (ex.: ativar a aba onde está o campo).
+     * Mantém o contrato do resumo como fonte única de scroll/foco em `navigateToFieldId`.
+     */
+    beforeItemActivate?: (item: ValidationSummaryItem) => void;
+    /** Mostra botão que apenas fecha o painel (não altera validação nem o formulário). */
+    showCloseButton: boolean;
+    /**
+     * Mostra o botão com setas (recolher / expandir) ao lado do título para esconder só a lista
+     * e poupar espaço vertical sem fechar o painel.
+     */
+    showListCollapseToggle: boolean;
+    closeButtonLabel: string;
+    /** Texto da dica nativa (`title`) nas linhas com destino ao campo. */
+    fieldNavigateHint: string;
+    readonly panelClose: EventEmitter<void>;
+    /** Com `pinned`: breve fade-in após o painel passar a visível (sem deslocar o layout). */
+    pinnedOpen: boolean;
+    /** `true`: lista de erros visível; `false`: só cabeçalho + botões (menos altura). */
+    panelBodyExpanded: boolean;
+    private wasShown;
+    get hostClass(): string;
+    ngOnChanges(_changes: SimpleChanges): void;
+    get hostHidden(): true | null;
+    get resolvedItems(): ValidationSummaryItem[];
+    get isShown(): boolean;
+    onCloseClick(): void;
+    toggleListBody(): void;
+    /**
+     * Chave estável para `@for` — `track $index` reutiliza mal nós quando a lista muda ao vivo
+     * e o getter `resolvedItems` devolve novas referências a cada CD.
+     */
+    itemTrackKey(row: ValidationSummaryItem, index: number): string;
+    /**
+     * Clique na linha com destino: primeiro alinha a linha no `list-wrap` com scroll
+     * (itens parcialmente visíveis passam a ficar totalmente visíveis), depois navega.
+     */
+    onSummaryLinkActivate(ev: Event, item: ValidationSummaryItem): void;
+    /** Navegação até o controle com `fieldId` (chamado após {@link onSummaryLinkActivate}). */
+    onItemActivate(item: ValidationSummaryItem): void;
+    private navigateToFieldId;
+    /** Após `tick()`, garante um frame de pintura antes de scroll/foco (evita foco em ramo ainda oculto). */
+    private scheduleScrollAndFocusAfterDomFlush;
+    private isInsideCollapsedFormGroupBody;
+    private scrollAndFocusFieldById;
+    /**
+     * Dispara `ui-request-expand` em cada `app-form-group` colapsado do formulário que contém este resumo,
+     * para montar campos com `destroyOnCollapse` antes de `getElementById(fieldId)`.
+     * Ordem do DOM (pais antes dos filhos) alinha a expansão de grupos aninhados.
+     */
+    private expandCollapsedFormGroupsInNearestForm;
+    /** Expande do mais externo para o mais interno para o conteúdo ficar visível. */
+    private expandCollapsedFormGroupAncestors;
+    private resolveFocusable;
+    private isFocusableElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationSummaryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ValidationSummaryComponent, "app-validation-summary", never, { "messages": { "alias": "messages"; "required": false; }; "items": { "alias": "items"; "required": false; }; "summaryHeading": { "alias": "title"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "pinned": { "alias": "pinned"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "panelMaxHeight": { "alias": "panelMaxHeight"; "required": false; }; "scrollBehavior": { "alias": "scrollBehavior"; "required": false; }; "beforeItemActivate": { "alias": "beforeItemActivate"; "required": false; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; }; "showListCollapseToggle": { "alias": "showListCollapseToggle"; "required": false; }; "closeButtonLabel": { "alias": "closeButtonLabel"; "required": false; }; "fieldNavigateHint": { "alias": "fieldNavigateHint"; "required": false; }; }, { "panelClose": "panelClose"; }, never, never, true, never>;
+    static ngAcceptInputType_visible: unknown;
+    static ngAcceptInputType_pinned: unknown;
+    static ngAcceptInputType_compact: unknown;
+    static ngAcceptInputType_showCloseButton: unknown;
+    static ngAcceptInputType_showListCollapseToggle: unknown;
+}
+
+declare class FormTabComponent implements OnChanges {
+    /** Sem `host: true`: o pai está no injetor normal (filho de `app-form-tabs`). */
+    private readonly tabs;
+    private readonly cdr;
+    key: string;
+    /**
+     * Texto do separador na lista de abas.
+     * Não usar o nome `title`: no host `<app-form-tab>` o atributo HTML `title` gera tooltip nativo
+     * sobre o painel (ex.: ao passar o mouse sobre o conteúdo).
+     */
+    tabTitle: string;
+    disabled: boolean;
+    warning: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    get isActive(): boolean;
+    /**
+     * Com `[keepAlive]="false"` no `app-form-tabs` pai, painéis inactivos saem do DOM (menos
+     * custo acumulado em ecrãs com muitas abas ou conteúdo pesado).
+     */
+    get detachInactivePanel(): boolean;
+    /** Chamado por {@link FormTabsComponent} quando a aba ativa muda (OnPush). */
+    refreshActiveState(): void;
+    get hostClass(): string;
+    panelId(): string;
+    labelledById(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormTabComponent, "app-form-tab", never, { "key": { "alias": "key"; "required": true; }; "tabTitle": { "alias": "tabTitle"; "required": true; }; "disabled": { "alias": "disabled"; "required": false; }; "warning": { "alias": "warning"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_warning: unknown;
+}
+
+type FormTabsVariant = 'default' | 'pill';
+
+declare class FormTabsComponent implements AfterContentInit {
+    private static nextUid;
+    private readonly cdr;
+    readonly uid: string;
+    tabQuery: QueryList<FormTabComponent>;
+    private _activeKey;
+    set activeKey(v: string | undefined | null);
+    get activeKey(): string;
+    readonly activeKeyChange: EventEmitter<string>;
+    /**
+     * `true` (padrão): todos os painéis permanecem no DOM; inactivos usam `[hidden]` (útil para
+     * preservar estado de UI puramente client-side dentro da aba).
+     * `false`: só o painel da aba activa é montado — menos DOM/CD ao alternar; o modelo reactivo
+     * (`FormGroup` no ascendente) mantém-se; ao voltar à aba, os campos remontam e religam-se.
+     */
+    keepAlive: boolean;
+    stretch: boolean;
+    variant: FormTabsVariant;
+    /** Rótulo acessível para a lista de separadores (ex.: “Seções do formulário”). */
+    tablistAriaLabel: string;
+    ngAfterContentInit(): void;
+    get tabs(): FormTabComponent[];
+    get hostClass(): string;
+    baseId(): string;
+    headerIdFor(key: string): string;
+    panelIdFor(key: string): string;
+    selectTab(key: string): void;
+    private refreshTabPanels;
+    /**
+     * Chamado por {@link FormTabComponent} quando inputs que afetam o tablist (ex.: `warning`, `tabTitle`)
+     * mudam — com OnPush o cabeçalho não voltava a desenhar só com alterações nos filhos projetados.
+     */
+    onTabHeaderStateChanged(): void;
+    isSelected(key: string): boolean;
+    private syncInitialActiveKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormTabsComponent, "app-form-tabs", never, { "activeKey": { "alias": "activeKey"; "required": false; }; "keepAlive": { "alias": "keepAlive"; "required": false; }; "stretch": { "alias": "stretch"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "tablistAriaLabel": { "alias": "tablistAriaLabel"; "required": false; }; }, { "activeKeyChange": "activeKeyChange"; }, ["tabQuery"], ["app-form-tab"], true, never>;
+    static ngAcceptInputType_keepAlive: unknown;
+    static ngAcceptInputType_stretch: unknown;
+}
+
+/**
+ * Mantém ícones / getters que dependem do estado reactivo actualizados com OnPush.
+ * `markAllAsTouched()` pode não emitir `valueChanges` no raiz; o `submit` do `<form>` (após um tick)
+ * cobre o caso de submissão — alinhado a {@link FormGroupComponent} `setupFormPathInvalidTracking`.
+ */
+declare function subscribeMarkForCheckOnInvalidUiRefresh(rootCtrl: AbstractControl, hostElement: HTMLElement, cdr: ChangeDetectorRef, destroyRef: DestroyRef): void;
+
+/** Resolve `a.b.c` a partir da raiz do formulário (normalmente o `FormGroup` do `<form [formGroup]>`). */
+declare function resolveControlAtPath(root: AbstractControl, path: string): AbstractControl | null;
+/**
+ * Há erro “visível” na subárvore: folho inválido e (`dirty` ou `formSubmitted`).
+ * `formSubmitted` deve incluir o equivalente a «formulário já enviado» (ex.: `FormGroupDirective.submitted`
+ * ou passo activo após o evento `submit` do `<form>` em `app-form-group`), para acender o ícone após
+ * «Salvar» + `markAllAsTouched()` sem exigir `dirty` em cada campo.
+ * Não usar `touched` sozinho: Tab/blur marca touched sem alterar valor e não deve acender o ícone.
+ */
+declare function subtreeHasVisibleInvalid(control: AbstractControl, formSubmitted?: boolean): boolean;
+/**
+ * Critério alinhado ao ícone automático de `app-form-group` com `formGroupPath`
+ * (e reutilizável para aviso por separador, ex. `app-form-tab` + `formGroupName`).
+ */
+declare function sectionHasVisibleInvalid(root: AbstractControl, path: string, formSubmitted?: boolean): boolean;
+
+/**
+ * Configuração de coluna da lib — convertida internamente para `ColDef` do AG Grid.
+ */
+interface DataGridColumn<T = unknown> {
+    /** Campo no registro ou identificador lógico (ex.: `__actions` para coluna de ações). */
+    key: keyof T | string;
+    header: string;
+    width?: number;
+    flex?: number;
+    type?: 'text' | 'number' | 'actions';
+    /** Por omissão `true` para texto/número; ignorado para `actions`. */
+    sortable?: boolean;
+}
+
+/** Contexto injetado pelo {@link DataGridComponent} (não exportado para consumidores). */
+interface DataGridActionsContext<T = unknown> {
+    onEditRow: (row: T) => void;
+    onRemoveRow: (row: T) => void;
+}
+declare class DataGridActionsCellRendererComponent implements ICellRendererAngularComp {
+    params: ICellRendererParams & {
+        context?: DataGridActionsContext;
+    };
+    agInit(params: ICellRendererParams): void;
+    refresh(): boolean;
+    /** `params.context` nem sempre vem preenchido; o grid guarda o mesmo objeto em `gridOptions.context`. */
+    private get actionsContext();
+    edit(): void;
+    remove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataGridActionsCellRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataGridActionsCellRendererComponent, "app-data-grid-actions-cell-renderer", never, {}, {}, never, never, true, never>;
+}
+
+/** Emitido quando o usuário muda de página ou tamanho de página na grade paginada. */
+interface DataGridPaginationChangeEvent {
+    /** Índice 0-based da página atual (API ag-Grid). */
+    currentPage: number;
+    newPage: boolean;
+    newPageSize: boolean;
+}
+declare class DataGridComponent<T = unknown> implements OnInit, OnChanges, OnDestroy {
+    private readonly ngZone;
+    private gridApi;
+    private paginationChangedListener?;
+    rows: T[];
+    columns: DataGridColumn<T>[];
+    pageSize: number;
+    loading: boolean;
+    /**
+     * Após remontar a grade (ex.: skeleton), volta a esta página (0-based).
+     * Só aplicado em `gridReady` e quando o valor muda com a API já disponível.
+     */
+    initialPaginationPage: number;
+    height: string | null;
+    emptyMessage: string;
+    pagination: boolean;
+    /** Se `false`, omite colunas com `type: 'actions'` (editar/remover). Por omissão `true`. */
+    showActionsColumn: boolean;
+    readonly edit: EventEmitter<T>;
+    readonly remove: EventEmitter<T>;
+    /** Reservado para evolução (seleção de linhas); não ligado na v1 para manter a UI minimal. */
+    readonly selectionChange: EventEmitter<T[]>;
+    /** Paginação interna do ag-Grid: mudança de página ou de `pageSize`. */
+    readonly paginationChanged: EventEmitter<DataGridPaginationChangeEvent>;
+    readonly frameworkComponents: {
+        dataGridActions: typeof DataGridActionsCellRendererComponent;
+    };
+    readonly paginationPageSizeChoices: number[];
+    /**
+     * O AG Grid avisa se `paginationPageSize` não está em `paginationPageSizeSelector`.
+     * Junta `pageSize` às opções base quando o consumidor usa um valor fora da lista (ex.: 8).
+     */
+    get effectivePaginationPageSizeSelector(): number[];
+    get skeletonColumnCount(): number;
+    get skeletonRowCount(): number;
+    readonly defaultColDef: ColDef<T>;
+    /**
+     * O AG Grid corre muitos callbacks fora da `NgZone`; sem `run()`, o pai com `OnPush`
+     * não volta a renderizar e editar/remover parece “morto”.
+     */
+    readonly actionsContext: DataGridActionsContext<T>;
+    agColumnDefs: ColDef<T>[];
+    ngOnInit(): void;
+    /**
+     * IDs estáveis por linha (evita `''` duplicado quando não existe `id` nos dados).
+     * Tenta `id`, depois `sku` (comum em grades de produto), senão impressão digital do objeto.
+     */
+    readonly getRowId: (params: GetRowIdParams<T>) => string;
+    /** Identificador determinístico e curto para linhas sem chave explícita. */
+    private stableRowFingerprint;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    get emptyOverlayTemplate(): string;
+    get hostHeight(): string;
+    onGridReady(ev: GridReadyEvent<T>): void;
+    private applyInitialPaginationPage;
+    /** Evita `removeEventListener` na API depois do grid destruído (ex.: `@if (loading)` remove o DOM). */
+    private detachPaginationListenerIfLive;
+    private columnsForGrid;
+    private mapColumnsToColDef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataGridComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataGridComponent<any>, "app-data-grid", never, { "rows": { "alias": "rows"; "required": true; }; "columns": { "alias": "columns"; "required": true; }; "pageSize": { "alias": "pageSize"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "initialPaginationPage": { "alias": "initialPaginationPage"; "required": false; }; "height": { "alias": "height"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "pagination": { "alias": "pagination"; "required": false; }; "showActionsColumn": { "alias": "showActionsColumn"; "required": false; }; }, { "edit": "edit"; "remove": "remove"; "selectionChange": "selectionChange"; "paginationChanged": "paginationChanged"; }, never, never, true, never>;
+    static ngAcceptInputType_initialPaginationPage: unknown;
+}
+
+/** Barra de consulta: pesquisa, filtros, ações e contador (slots `toolbar-start` / `toolbar-end`). */
+declare class DataToolbarComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataToolbarComponent, "app-data-toolbar", never, {}, {}, never, ["[toolbar-start]", "[toolbar-end]"], true, never>;
+}
+
+/** Vista mapeada por item para {@link CardListComponent}. */
+interface CardItemView {
+    title: string;
+    subtitle?: string;
+    /** Texto curto para o avatar (ex.: iniciais). */
+    avatarText?: string;
+}
+type CardListMapFn<T> = (item: T) => CardItemView;
+
+/** Limite de largura para tratar como “mobile” na escolha grid vs card. */
+declare const ADAPTIVE_DATA_VIEW_MOBILE_QUERY = "(max-width: 767.98px)";
+type AdaptiveDataViewMode = 'grid' | 'card';
+/**
+ * Escolhe **um** de `app-data-grid` ou `app-card-list` conforme breakpoint e preferências.
+ * Nunca renderiza os dois em simultâneo.
+ */
+declare class AdaptiveDataViewComponent<T = unknown> implements OnInit {
+    private readonly bp;
+    private readonly cdr;
+    private readonly destroyRef;
+    items: T[];
+    gridColumns: DataGridColumn<T>[];
+    mapItem: CardListMapFn<T>;
+    pageSize: number;
+    gridHeight: string | null;
+    cardScrollMaxHeight: string | null;
+    emptyMessageGrid: string;
+    emptyMessageCard: string;
+    pagination: boolean;
+    showActionsColumn: boolean;
+    showCardItemActions: boolean;
+    scrollBatchSize: number;
+    showCardFooter: boolean;
+    /** Estado de carregamento reposto no grid ou na lista conforme a vista ativa. */
+    loading: boolean;
+    /**
+     * Mostra uma linha de contagem **abaixo** da grade ou da lista (incluindo paginação interna).
+     * Texto padrão em português; use `{count}` como marcador do número de linhas em `items`.
+     */
+    showResultCount: boolean;
+    resultCountTemplate: string;
+    /** Vista quando `ADAPTIVE_DATA_VIEW_MOBILE_QUERY` corresponde. Por padrão `card`. */
+    mobileView: AdaptiveDataViewMode;
+    /** Vista quando a tela é maior. Por padrão `grid`. */
+    desktopView: AdaptiveDataViewMode;
+    readonly edit: EventEmitter<T>;
+    readonly remove: EventEmitter<T>;
+    readonly loadMore: EventEmitter<void>;
+    /** Corresponde ao breakpoint mobile. */
+    isMobileLayout: boolean;
+    ngOnInit(): void;
+    get effectiveKind(): AdaptiveDataViewMode;
+    get showGrid(): boolean;
+    get showCard(): boolean;
+    get resultCountDisplay(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdaptiveDataViewComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdaptiveDataViewComponent<any>, "app-adaptive-data-view", never, { "items": { "alias": "items"; "required": true; }; "gridColumns": { "alias": "gridColumns"; "required": true; }; "mapItem": { "alias": "mapItem"; "required": true; }; "pageSize": { "alias": "pageSize"; "required": false; }; "gridHeight": { "alias": "gridHeight"; "required": false; }; "cardScrollMaxHeight": { "alias": "cardScrollMaxHeight"; "required": false; }; "emptyMessageGrid": { "alias": "emptyMessageGrid"; "required": false; }; "emptyMessageCard": { "alias": "emptyMessageCard"; "required": false; }; "pagination": { "alias": "pagination"; "required": false; }; "showActionsColumn": { "alias": "showActionsColumn"; "required": false; }; "showCardItemActions": { "alias": "showCardItemActions"; "required": false; }; "scrollBatchSize": { "alias": "scrollBatchSize"; "required": false; }; "showCardFooter": { "alias": "showCardFooter"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "showResultCount": { "alias": "showResultCount"; "required": false; }; "resultCountTemplate": { "alias": "resultCountTemplate"; "required": false; }; "mobileView": { "alias": "mobileView"; "required": false; }; "desktopView": { "alias": "desktopView"; "required": false; }; }, { "edit": "edit"; "remove": "remove"; "loadMore": "loadMore"; }, never, never, true, never>;
+}
+
+declare class DataCardComponent {
+    title: string;
+    subtitle?: string;
+    /** 1–2 caracteres para o círculo de iniciais. */
+    avatarText?: string;
+    variant: 'default';
+    showActions: boolean;
+    readonly edit: EventEmitter<void>;
+    readonly remove: EventEmitter<void>;
+    onEditClick(ev: Event): void;
+    onRemoveClick(ev: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataCardComponent, "app-data-card", never, { "title": { "alias": "title"; "required": true; }; "subtitle": { "alias": "subtitle"; "required": false; }; "avatarText": { "alias": "avatarText"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "showActions": { "alias": "showActions"; "required": false; }; }, { "edit": "edit"; "remove": "remove"; }, never, never, true, never>;
+}
+
+/**
+ * - **memory**: `items` tem a lista completa (ex.: 500 em memória); só se mostram
+ *   `scrollBatchSize` de cada vez até o usuário fazer scroll (fatia local).
+ * - **remote**: `items` são só as linhas já devolvidas pela API; ao fim do scroll
+ *   emite `loadMore` para pedir a próxima página (SQL OFFSET/FETCH no backend).
+ */
+type CardListDataMode = 'memory' | 'remote';
+declare class CardListComponent<T = unknown> implements OnChanges {
+    private readonly cdr;
+    items: T[];
+    loading: boolean;
+    /**
+     * Com itens já visíveis: mostra **um** skeleton no fundo (próxima página remota)
+     * para não saltar o scroll nem ocupar altura de vários cartões. O carregamento inicial
+     * continua a usar só {@link loading} (lista vazia ou refresh completo com `loading` e sem `loadingMore`).
+     */
+    loadingMore: boolean;
+    emptyMessage: string;
+    variant: 'default';
+    mapItem: CardListMapFn<T>;
+    showItemActions: boolean;
+    trackByProp: keyof T | string;
+    dataMode: CardListDataMode;
+    /** Em modo `memory`: quantos itens revelar por cada passo de scroll. Por omissão `10`. */
+    scrollBatchSize: number;
+    scrollLoadThresholdPx: number;
+    /** Mostra o rodapé com o resumo (“X de Y”) e dica. Por omissão `true`; com `false` oculta o footer. */
+    showFooter: boolean;
+    scrollMaxHeight: string | null;
+    /**
+     * Modo **remote**: total de registros no servidor (ex.: COUNT SQL), para o texto “X de Y”.
+     * Se `null`, usa `items.length`.
+     */
+    totalCountRemote: number | null;
+    /** Modo **remote**: existe página seguinte para pedir ao backend. */
+    hasNextPage: boolean;
+    /** Modo **remote**: pedido de mais dados (próxima página). */
+    readonly loadMore: EventEmitter<void>;
+    readonly edit: EventEmitter<T>;
+    readonly remove: EventEmitter<T>;
+    /** Modo memory: quantos cartões renderizar (fatia inicial = scrollBatchSize). */
+    visibleCount: number;
+    private loadMorePending;
+    /** Skeleton que ocupa a lista inteira (carregamento inicial / refresh com `loading`). */
+    get showFullSkeleton(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    get totalItemCount(): number;
+    /** Total para o rodapé “X de Y”. */
+    get totalForStatus(): number;
+    get visibleItems(): T[];
+    get scrollStatusLabel(): string;
+    get scrollAreaStyle(): Record<string, string>;
+    /** Há mais linhas para mostrar (memória) ou para pedir à API (remote). */
+    get hasMoreToReveal(): boolean;
+    viewFor(item: T): CardItemView;
+    skeletonCardIndices(): number[];
+    /** Um único cartão skeleton no fundo durante `loadingMore` (mantém o scroll estável). */
+    skeletonTailIndices(): number[];
+    trackFn: (index: number, item: T) => unknown;
+    onScroll(ev: Event): void;
+    private requestRemotePage;
+    private loadMoreMemoryChunk;
+    private resetVisibleWindow;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardListComponent<any>, "app-card-list", never, { "items": { "alias": "items"; "required": true; }; "loading": { "alias": "loading"; "required": false; }; "loadingMore": { "alias": "loadingMore"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "mapItem": { "alias": "mapItem"; "required": true; }; "showItemActions": { "alias": "showItemActions"; "required": false; }; "trackByProp": { "alias": "trackByProp"; "required": false; }; "dataMode": { "alias": "dataMode"; "required": false; }; "scrollBatchSize": { "alias": "scrollBatchSize"; "required": false; }; "scrollLoadThresholdPx": { "alias": "scrollLoadThresholdPx"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "scrollMaxHeight": { "alias": "scrollMaxHeight"; "required": false; }; "totalCountRemote": { "alias": "totalCountRemote"; "required": false; }; "hasNextPage": { "alias": "hasNextPage"; "required": false; }; }, { "loadMore": "loadMore"; "edit": "edit"; "remove": "remove"; }, never, never, true, never>;
+    static ngAcceptInputType_loadingMore: unknown;
+}
+
+declare class EmptyStateComponent {
+    message: string;
+    description?: string;
+    /** Classe Font Awesome do ícone (ex.: `fa-solid fa-inbox`). */
+    iconClass: string;
+    variant: 'default';
+    /** Padding reduzido (ex.: células de tabela, listas densas). */
+    embed: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateComponent, "app-empty-state", never, { "message": { "alias": "message"; "required": true; }; "description": { "alias": "description"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "embed": { "alias": "embed"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_embed: unknown;
+}
+
+/**
+ * HTML injetado no AG Grid (`overlayNoRowsTemplate`) — manter alinhado ao markup de {@link EmptyStateComponent}.
+ */
+declare function escapeHtml(text: string): string;
+declare function buildEmptyStateOverlayHtml(message: string): string;
+
+/** Variantes visuais do `app-status-badge` (cores semânticas da lib). */
+type StatusBadgeVariant = 'success' | 'error' | 'warning' | 'info' | 'neutral';
+/** Tamanho do `app-status-badge`. */
+type StatusBadgeSize = 'sm' | 'md';
+/** Linha chave → valor para `app-details-view` (modo lista). */
+interface DetailsViewItem {
+    label: string;
+    value?: string | null;
+}
+/** Tom da variação opcional no `app-stat-card` (ex.: +12% vs mês anterior). */
+type StatCardDeltaTone = 'positive' | 'negative' | 'neutral';
+
+/**
+ * Etiqueta de estado (Ativo, Pendente, etc.) com fundo suave e cor semântica.
+ */
+declare class StatusBadgeComponent {
+    label: string;
+    variant: StatusBadgeVariant;
+    /** Classes Font Awesome (ex.: `fa-solid fa-check`). */
+    icon: string;
+    size: StatusBadgeSize;
+    bordered: boolean;
+    readonly variantClassMap: Record<StatusBadgeVariant, string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatusBadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StatusBadgeComponent, "app-status-badge", never, { "label": { "alias": "label"; "required": true; }; "variant": { "alias": "variant"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "size": { "alias": "size"; "required": false; }; "bordered": { "alias": "bordered"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_bordered: unknown;
+}
+
+/**
+ * Lista de descrição (chave → valor) para detalhes, drawer ou resumo.
+ * Modo **lista**: `[items]`; modo **composto**: projectar `app-details-field` no conteúdo.
+ */
+declare class DetailsViewComponent {
+    items: readonly DetailsViewItem[];
+    /**
+     * Se `true`, ignora `items` e renderiza só `<ng-content />` dentro de um `<dl>`
+     * (usar com `app-details-field` para valores ricos).
+     */
+    projectionOnly: boolean;
+    /** `2` ativa grade em dois tempos em telas largas. */
+    columns: 1 | 2;
+    loading: boolean;
+    /** Texto quando `items` está vazio, sem `loading` e sem `projectionOnly`. */
+    emptyMessage: string;
+    readonly emDash = "\u2014";
+    /** Linhas de skeleton em modo loading. */
+    readonly skeletonPairs: number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DetailsViewComponent, "app-details-view", never, { "items": { "alias": "items"; "required": false; }; "projectionOnly": { "alias": "projectionOnly"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_projectionOnly: unknown;
+    static ngAcceptInputType_loading: unknown;
+}
+
+/**
+ * Uma linha chave → valor para usar **dentro** de `app-details-view` (projeção).
+ * O host usa `display: contents` para manter `<dl>` > `<dt>`/`<dd>` válidos.
+ */
+declare class DetailsFieldComponent {
+    label: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DetailsFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DetailsFieldComponent, "app-details-field", never, { "label": { "alias": "label"; "required": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Cartão de métrica (KPI) com a **mesma superfície** que `app-data-card` (mixin SCSS `data-card-shell`).
+ * Não usa o selector `app-data-card` (esse componente é para linhas de lista com ações).
+ */
+declare class StatCardComponent {
+    title: string;
+    value: string;
+    description: string;
+    icon: string;
+    /** Texto curto (ex.: +12% ou −3%). */
+    delta: string;
+    deltaTone: StatCardDeltaTone;
+    clickable: boolean;
+    readonly cardActivate: EventEmitter<void>;
+    onActivate(ev: Event): void;
+    onKeydown(ev: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StatCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StatCardComponent, "app-stat-card", never, { "title": { "alias": "title"; "required": true; }; "value": { "alias": "value"; "required": true; }; "description": { "alias": "description"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "delta": { "alias": "delta"; "required": false; }; "deltaTone": { "alias": "deltaTone"; "required": false; }; "clickable": { "alias": "clickable"; "required": false; }; }, { "cardActivate": "cardActivate"; }, never, never, true, never>;
+    static ngAcceptInputType_clickable: unknown;
+}
+
+/**
+ * Linha base para listas (`app-data-list`): texto, área de estado e ações projetadas.
+ * Estrutura preparada para selecção futura (`selectable` apenas aplica classe visual).
+ */
+declare class ListItemComponent {
+    title: string;
+    subtitle: string;
+    clickable: boolean;
+    /**
+     * Reserva visual para selecção futura (sem lógica de modelo).
+     */
+    selectable: boolean;
+    readonly itemActivate: EventEmitter<void>;
+    onKeydown(ev: KeyboardEvent): void;
+    onClick(ev: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListItemComponent, "app-list-item", never, { "title": { "alias": "title"; "required": true; }; "subtitle": { "alias": "subtitle"; "required": false; }; "clickable": { "alias": "clickable"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; }, { "itemActivate": "itemActivate"; }, never, ["*", "[list-item-status]", "[list-item-actions]"], true, never>;
+    static ngAcceptInputType_clickable: unknown;
+    static ngAcceptInputType_selectable: unknown;
+}
+
+/**
+ * Lista vertical de registros com estados de loading e vazio padronizados.
+ * O conteúdo de cada linha deve usar `app-list-item` (ou composição equivalente).
+ */
+declare class DataListComponent {
+    loading: boolean;
+    empty: boolean;
+    emptyTitle: string;
+    emptyDescription: string;
+    emptyIconClass: string;
+    /** Linhas de skeleton em modo loading. */
+    skeletonRows: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataListComponent, "app-data-list", never, { "loading": { "alias": "loading"; "required": false; }; "empty": { "alias": "empty"; "required": false; }; "emptyTitle": { "alias": "emptyTitle"; "required": false; }; "emptyDescription": { "alias": "emptyDescription"; "required": false; }; "emptyIconClass": { "alias": "emptyIconClass"; "required": false; }; "skeletonRows": { "alias": "skeletonRows"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_loading: unknown;
+    static ngAcceptInputType_empty: unknown;
+}
+
+/**
+ * Bloco de dashboard: título, ações opcionais e conteúdo (stat-cards, listas, grades).
+ * Superfície alinhada aos cartões da lib.
+ */
+declare class DashboardSectionComponent {
+    title: string;
+    subtitle: string;
+    readonly titleId: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DashboardSectionComponent, "app-dashboard-section", never, { "title": { "alias": "title"; "required": true; }; "subtitle": { "alias": "subtitle"; "required": false; }; }, {}, never, ["[dashboard-section-actions]", "*"], true, never>;
+}
+
+/**
+ * Barra auxiliar para tabelas / grades: envolve {@link DataToolbarComponent}
+ * com áreas para pesquisa, contagem e ações.
+ */
+declare class TableToolbarComponent {
+    /** Ex.: `128 resultados` ou `Nenhum resultado`. */
+    resultCountLabel: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableToolbarComponent, "app-table-toolbar", never, { "resultCountLabel": { "alias": "resultCountLabel"; "required": false; }; }, {}, never, ["[tableToolbarSearch]", "[tableToolbarFilters]", "[tableToolbarActions]"], true, never>;
+}
+
+/**
+ * Estado vazio para tabelas ou listas densas — reutiliza {@link EmptyStateComponent}
+ * e permite uma ação opcional (ex.: limpar filtros).
+ */
+declare class TableEmptyStateComponent {
+    title: string;
+    description: string;
+    iconClass: string;
+    embed: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableEmptyStateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableEmptyStateComponent, "app-table-empty-state", never, { "title": { "alias": "title"; "required": true; }; "description": { "alias": "description"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "embed": { "alias": "embed"; "required": false; }; }, {}, never, ["[tableEmptyAction]"], true, never>;
+    static ngAcceptInputType_embed: unknown;
+}
+
+/** Largura máxima do painel `app-dialog` (conteúdo responsivo). */
+declare enum LibDialogSize {
+    Sm = "sm",
+    Md = "md",
+    Lg = "lg"
+}
+
+/**
+ * Diálogo modal declarativo com `[(open)]`, projeção de corpo e rodapé opcional (`[appDialogFooter]`).
+ * Bloqueio de scroll com {@link lockPageScrollAppDialog} (sem deslocar o `html` como o CDK),
+ * para o scrim `position: fixed` alinhar ao viewport em páginas com scroll no `body`.
+ */
+declare class AppDialogComponent implements OnInit, OnChanges, OnDestroy {
+    private readonly hostEl;
+    private readonly appTheme;
+    /**
+     * Com o host em `document.body`, sem isto os `--app-color-*` / `--ui-field-*` ficam só com
+     * valores de `:root` (azul); alinhamos ao CDK Dialog (`libDialogPanelClasses`).
+     */
+    get hostThemeClasses(): string;
+    /**
+     * Impede o tooltip nativo do browser: o `@Input('title')` alimenta só `dialogHeading`, mas o
+     * binding `title="…"` no host ainda podia definir `HTMLElement.title` no `<app-dialog>`.
+     */
+    readonly hostTitleAttr: null;
+    open: boolean;
+    readonly openChange: EventEmitter<boolean>;
+    /**
+     * Título do cabeçalho (`<app-dialog title="…">`).
+     * O nome da propriedade **não** pode ser `title`: no host DOM isso colide com
+     * `HTMLElement.title` e o browser desenha o tooltip nativo por cima do overlay.
+     */
+    dialogHeading: string;
+    /** Texto de apoio abaixo do título (opcional); liga `aria-describedby` no painel. */
+    description: string;
+    /**
+     * Rótulo acessível quando não há título (evita diálogo sem nome).
+     * Ignorado se `dialogHeading` tiver texto.
+     */
+    ariaLabel: string;
+    size: LibDialogSize;
+    /**
+     * Quando `false`, a tecla Escape e o clique no backdrop não fecham o diálogo
+     * (botão ✕, `[(open)]` e `requestClose()` continuam disponíveis).
+     * Omisso: `true`.
+     */
+    allowOverlayDismiss: boolean;
+    showCloseButton: boolean;
+    readonly LibDialogSize: typeof LibDialogSize;
+    readonly titleId: string;
+    readonly descriptionId: string;
+    /**
+     * O modal fica no fim de `document.body` enquanto aberto, para o `backdrop-filter`
+     * não ficar «preso» a ancestrais com `overflow: auto` (ex.: `app-shell__content`).
+     */
+    private bodyRestoreParent;
+    private bodyRestoreNext;
+    private previousActive;
+    private scrollLock;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private attachHostToBody;
+    private detachHostFromBody;
+    onDocumentKeydown(ev: KeyboardEvent): void;
+    onBackdropClick(): void;
+    requestClose(): void;
+    private restoreFocus;
+    private stripHostNativeTitle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppDialogComponent, "app-dialog", never, { "open": { "alias": "open"; "required": false; }; "dialogHeading": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "size": { "alias": "size"; "required": false; }; "allowOverlayDismiss": { "alias": "allowOverlayDismiss"; "required": false; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*", "[appDialogFooter]"], true, never>;
+    static ngAcceptInputType_open: unknown;
+    static ngAcceptInputType_allowOverlayDismiss: unknown;
+    static ngAcceptInputType_showCloseButton: unknown;
+}
+
+/** Marca o conteúdo projectado no rodapé de `app-dialog`. */
+declare class DialogFooterDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogFooterDirective, "[appDialogFooter]", never, {}, {}, never, never, true, never>;
+}
+
+type ConfirmDialogVariant = 'default' | 'danger';
+interface ConfirmDialogData {
+    title: string;
+    message: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    variant?: ConfirmDialogVariant;
+    /**
+     * Se `true`, Escape e clique fora **não** fecham o diálogo (apenas botões do rodapé).
+     * Omisso: `false` — permite dispensar com Esc ou backdrop (emite `undefined` no `closed`).
+     */
+    blockOverlayDismiss?: boolean;
+}
+
+declare class ConfirmDialogComponent implements AfterViewInit {
+    readonly ref: DialogRef<boolean, ConfirmDialogComponent>;
+    readonly data: ConfirmDialogData;
+    readonly BaseButtonType: typeof BaseButtonType;
+    readonly BaseButtonVariant: typeof BaseButtonVariant;
+    readonly titleId: string;
+    readonly descId: string;
+    private cancelBtn?;
+    private static seq;
+    ngAfterViewInit(): void;
+    onConfirm(): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmDialogComponent, "app-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class ConfirmDialogService {
+    private readonly dialog;
+    private readonly theme;
+    /**
+     * Abre o diálogo de confirmação (CDK Dialog + `ConfirmDialogComponent`).
+     * Emite `true` se confirmar, `false` se cancelar, `undefined` se fechar sem resultado (Esc/backdrop, quando permitido).
+     * Por defeito permite dispensar com Esc e clique fora; use `data.blockOverlayDismiss` para exigir só botões.
+     */
+    open(data: ConfirmDialogData): Observable<boolean | undefined>;
+    /** Confirmação como Promise (adequado a `async`/`await`). */
+    confirm(data: ConfirmDialogData): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmDialogService>;
+}
+
+declare const APP_THEME_IDS: readonly ["blue", "green", "purple", "orange", "white", "gray", "sepia", "black"];
+type AppThemeId = (typeof APP_THEME_IDS)[number];
+/** Opção de tema para UI (selector, documentação). */
+interface AppThemeOption {
+    readonly id: AppThemeId;
+    readonly label: string;
+}
+/**
+ * Estado global do tema da library: classe CSS `theme-*` em conjunto com `.app-library-theme`.
+ * Os tokens `--app-color-*` são definidos em `src/app/_theme/`; paletas em `_theme-palettes.scss`.
+ */
+declare class AppThemeService {
+    private readonly activeId;
+    /** Identificador do tema activo (`blue`, `green`, …). */
+    readonly activeThemeId: i0.Signal<"blue" | "green" | "purple" | "orange" | "white" | "gray" | "sepia" | "black">;
+    /** Classe CSS do tema (ex.: `theme-green`) para `[ngClass]` no host tematizado. */
+    readonly themeClass: i0.Signal<string>;
+    /** Lista fixa de temas suportados pela library. */
+    readonly themeOptions: readonly AppThemeOption[];
+    setTheme(id: AppThemeId): void;
+    isActive(id: AppThemeId): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppThemeService>;
+}
+
+/** Classes aplicadas ao painel CDK Dialog + tema da app. */
+declare function libDialogPanelClasses(theme: AppThemeService, extra?: string | string[]): string[];
+
+/**
+ * Substituto do `BlockScrollStrategy` do CDK para modais Structra (Dialog de confirmação,
+ * loading, etc.): activa {@link lockPageScrollAppDialog} em vez de `cdk-global-scrollblock`
+ * com `html` deslocado — alinha o backdrop do overlay ao viewport real.
+ */
+declare class AppLibLightBlockScrollStrategy implements ScrollStrategy {
+    private snapshot;
+    attach(_overlayRef: OverlayRef): void;
+    enable(): void;
+    disable(): void;
+}
+
+type ToastType = 'success' | 'error' | 'warning' | 'info';
+/** Onde empilhar o toast na tela (canto superior ou inferior direito). */
+type ToastVerticalPosition = 'top' | 'bottom';
+interface ToastShowOptions {
+    message: string;
+    title?: string;
+    type?: ToastType;
+    /** Omisso: `top` (comportamento anterior). */
+    position?: ToastVerticalPosition;
+    /**
+     * Duração em ms. `0` = não fecha automaticamente (só botão fechar / ação).
+     * Omisso: 5000 ms.
+     */
+    durationMs?: number;
+    actionLabel?: string;
+    onAction?: () => void;
+}
+interface ToastInstance {
+    readonly id: string;
+    readonly message: string;
+    readonly title?: string;
+    readonly type: ToastType;
+    readonly durationMs: number;
+    readonly actionLabel?: string;
+    readonly position: ToastVerticalPosition;
+}
+
+declare class ToastService {
+    private readonly items;
+    private readonly timers;
+    private readonly actionHandlers;
+    /** Lista actual (mais recente primeiro). */
+    readonly toasts: i0.Signal<ToastInstance[]>;
+    /** Mostra um toast; devolve o id (para `dismiss` manual). */
+    show(options: ToastShowOptions): string;
+    dismiss(id: string): void;
+    clear(): void;
+    runAction(id: string): void;
+    private clearTimer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}
+
+declare class ToastHostComponent {
+    readonly toastService: ToastService;
+    readonly theme: AppThemeService;
+    readonly topToasts: i0.Signal<structra_ui.ToastInstance[]>;
+    readonly bottomToasts: i0.Signal<structra_ui.ToastInstance[]>;
+    dismiss(id: string): void;
+    action(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToastHostComponent, "app-toast-host", never, {}, {}, never, never, true, never>;
+}
+
+declare class LoadingDialogComponent {
+    private readonly data;
+    readonly titleId: string;
+    readonly message: string;
+    private static seq;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingDialogComponent, "app-loading-dialog", never, {}, {}, never, never, true, never>;
+}
+
+interface LoadingDialogData {
+    /**
+     * Texto sob o indicador de progresso.
+     * Omisso: mensagem por defeito da lib (`A carregar…`).
+     */
+    message?: string;
+}
+
+declare class LoadingDialogService {
+    private readonly dialog;
+    private readonly theme;
+    /**
+     * Abre o diálogo de carregamento.
+     * `disableClose: true` — não fecha com Escape nem clique fora; use `ref.close()` quando terminar.
+     */
+    open(data?: LoadingDialogData): DialogRef<void, LoadingDialogComponent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingDialogService>;
+}
+
+/**
+ * Posicionamento vertical preferido do dropdown em relação ao trigger.
+ * O CDK faz flip automático se não couber no viewport quando configurado com posições múltiplas.
+ */
+declare enum MenuDropdownPlacement {
+    /** Abre por baixo do trigger (preferencial). */
+    Below = "below",
+    /** Abre por cima do trigger. */
+    Above = "above"
+}
+
+declare class DropdownMenuComponent<T = string> {
+    private readonly host;
+    items: readonly MenuNodeItem<T>[];
+    placement: MenuDropdownPlacement;
+    /** Largura mínima do painel em px (o painel pode alargar ao conteúdo). */
+    minWidthPx: number;
+    /** Se `true`, a largura do painel segue a do trigger. */
+    matchTriggerWidth: boolean;
+    menuId: string;
+    readonly itemSelect: EventEmitter<T>;
+    readonly openChange: EventEmitter<boolean>;
+    panelTpl: TemplateRef<unknown>;
+    private menuList?;
+    open: boolean;
+    private readonly generatedId;
+    get resolvedMenuId(): string;
+    /** Largura do painel no overlay (mínimo garantido; pode igualar ao trigger). */
+    get effectivePanelWidth(): number;
+    get connectedPositions(): _angular_cdk_overlay.ConnectedPosition[];
+    onTriggerClick(ev: Event): void;
+    toggle(): void;
+    setOpen(next: boolean): void;
+    onBaseOpenChange(next: boolean): void;
+    onItemSelect(id: T): void;
+    onCloseRequest(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownMenuComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownMenuComponent<any>, "app-dropdown-menu", never, { "items": { "alias": "items"; "required": true; }; "placement": { "alias": "placement"; "required": false; }; "minWidthPx": { "alias": "minWidthPx"; "required": false; }; "matchTriggerWidth": { "alias": "matchTriggerWidth"; "required": false; }; "menuId": { "alias": "menuId"; "required": false; }; }, { "itemSelect": "itemSelect"; "openChange": "openChange"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_matchTriggerWidth: unknown;
+}
+
+declare class ContextMenuComponent<T = string> implements OnDestroy {
+    private readonly overlay;
+    private readonly vcr;
+    private readonly appTheme;
+    private readonly cdr;
+    items: readonly MenuNodeItem<T>[];
+    disabled: boolean;
+    menuId: string;
+    readonly itemSelect: EventEmitter<T>;
+    menuTpl: TemplateRef<unknown>;
+    private menuList?;
+    private overlayRef;
+    private escSub;
+    private readonly generatedId;
+    readonly panelThemeNgClass: i0.Signal<{
+        [x: string]: boolean;
+        'app-library-theme': boolean;
+    }>;
+    get resolvedMenuId(): string;
+    ngOnDestroy(): void;
+    onContextMenu(ev: MouseEvent): void;
+    private openAt;
+    private disposeOverlay;
+    onItemSelect(id: T): void;
+    onCloseRequest(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuComponent<any>, "app-context-menu", never, { "items": { "alias": "items"; "required": true; }; "disabled": { "alias": "disabled"; "required": false; }; "menuId": { "alias": "menuId"; "required": false; }; }, { "itemSelect": "itemSelect"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/** Lado de ancoragem do drawer. */
+declare enum DrawerSide {
+    Left = "left",
+    Right = "right",
+    Bottom = "bottom"
+}
+
+/** Larguras padronizadas do painel lateral (drawer). */
+declare enum DrawerSize {
+    Sm = "sm",
+    Md = "md",
+    Lg = "lg"
+}
+
+declare class DrawerComponent implements OnChanges, OnDestroy {
+    private readonly cdr;
+    private readonly injector;
+    private readonly hostEl;
+    open: boolean;
+    side: DrawerSide;
+    size: DrawerSize;
+    /** `title="…"` no template — evita colisão com `HTMLElement.title` no host. */
+    drawerHeading: string;
+    showCloseButton: boolean;
+    readonly openChange: EventEmitter<boolean>;
+    private panelRef?;
+    readonly DrawerSide: typeof DrawerSide;
+    readonly DrawerSize: typeof DrawerSize;
+    readonly titleId: string;
+    private focusPreOpen;
+    /** Igual ao `app-dialog`: backdrop + painel no `body` para `backdrop-filter` correcto. */
+    private bodyRestoreParent;
+    private bodyRestoreNext;
+    get panelClasses(): Record<string, boolean>;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private attachHostToBody;
+    private detachHostFromBody;
+    onBackdropClick(): void;
+    onCloseClick(): void;
+    onPanelKeydown(ev: KeyboardEvent): void;
+    requestClose(): void;
+    private restoreFocus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DrawerComponent, "app-drawer", never, { "open": { "alias": "open"; "required": false; }; "side": { "alias": "side"; "required": false; }; "size": { "alias": "size"; "required": false; }; "drawerHeading": { "alias": "title"; "required": false; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*", "[appDrawerFooter]"], true, never>;
+    static ngAcceptInputType_open: unknown;
+    static ngAcceptInputType_showCloseButton: unknown;
+}
+
+interface MenuRowAction<T = string> {
+    kind: 'action';
+    item: MenuItemAction<T>;
+    /** Índice na navegação por teclado; `null` se desabilitado. */
+    focusIndex: number | null;
+}
+interface MenuRowDivider {
+    kind: 'divider';
+}
+interface MenuRowGroup {
+    kind: 'group';
+    label?: string;
+}
+interface MenuRowSubmenu<T = string> {
+    kind: 'submenu';
+    item: MenuItemSubmenu<T>;
+    focusIndex: number | null;
+}
+type MenuRow<T = string> = MenuRowAction<T> | MenuRowDivider | MenuRowGroup | MenuRowSubmenu<T>;
+
+declare class MenuListComponent<T = string> implements OnChanges {
+    private readonly cdr;
+    private readonly appTheme;
+    readonly hostRef: ElementRef<any>;
+    items: readonly MenuNodeItem<T>[];
+    /** Prefixo dos `id` das opções focáveis (`${menuId}-opt-${focusIndex}`). */
+    menuId: string;
+    dense: boolean;
+    /** Quando `true`, o menu está dentro de um submenu — seta ← regressa um nível. */
+    nested: boolean;
+    /**
+     * Destaca visualmente o item cuja `id` coincide (navegação actual / rota activa).
+     * Só aplica a linhas `kind: 'item'` neste nível.
+     */
+    selectedItemId: T | null;
+    /**
+     * Oculta rótulos e descrições (ex.: sidebar colapsada), mantendo ícones; define `title` nativo para hover.
+     */
+    compressText: boolean;
+    readonly itemSelect: EventEmitter<T>;
+    readonly closeRequest: EventEmitter<void>;
+    readonly submenuBack: EventEmitter<void>;
+    private nestedLists?;
+    rows: MenuRow<T>[];
+    private focusableCount;
+    /** Índice entre `0` e `focusableCount - 1`, ou `-1` = nenhum realce. */
+    activeIndex: number;
+    /** Painel de submenu aberto (um por instância de lista). */
+    openSubmenuKey: string | null;
+    private submenuOpenTimer;
+    private submenuCloseTimer;
+    readonly submenuPositions: _angular_cdk_overlay.ConnectedPosition[];
+    readonly panelThemeNgClass: i0.Signal<{
+        [x: string]: boolean;
+        'app-library-theme': boolean;
+    }>;
+    overlayPanelClasses(): string[];
+    onNestedItemSelect(id: T): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    submenuRowKey(row: MenuRow<T>, index: number): string;
+    isSubmenuOpen(row: MenuRow<T>, index: number): boolean;
+    submenuMenuId(row: MenuRow<T>): string;
+    onRowMouseEnter(row: MenuRow<T>): void;
+    onSubmenuTriggerEnter(row: MenuRow<T>, index: number): void;
+    onSubmenuTriggerLeave(_row: MenuRow<T>, index: number): void;
+    onSubmenuPanelEnter(): void;
+    onSubmenuPanelLeave(row: MenuRow<T>, index: number): void;
+    private scheduleSubmenuClose;
+    private cancelSubmenuOpenTimer;
+    private cancelSubmenuCloseTimer;
+    /** Fecha o submenu deste nível (seta ← no filho ou fecho de irmão). */
+    closeOpenSubmenu(): void;
+    onSubmenuRowClick(ev: MouseEvent, row: MenuRow<T>, index: number): void;
+    onSubmenuOutsideClick(row: MenuRow<T>, index: number): void;
+    private openSubmenuForRowAt;
+    private queueFocusNestedFirst;
+    /** Primeira opção focável (abertura por teclado). */
+    focusFirstOption(): void;
+    onItemClick(ev: MouseEvent, item: MenuItemAction<T>): void;
+    optionId(focusIndex: number): string;
+    isActiveRow(row: MenuRow<T>): boolean;
+    /** Realce de selecção persistente (ex.: item de navegação activo). */
+    isRowSelected(row: MenuRow<T>): boolean;
+    resetHighlight(): void;
+    onMenuSurfaceLeave(): void;
+    private focusActiveDom;
+    onKeydown(ev: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuListComponent<any>, "app-menu-list", never, { "items": { "alias": "items"; "required": true; }; "menuId": { "alias": "menuId"; "required": false; }; "dense": { "alias": "dense"; "required": false; }; "nested": { "alias": "nested"; "required": false; }; "selectedItemId": { "alias": "selectedItemId"; "required": false; }; "compressText": { "alias": "compressText"; "required": false; }; }, { "itemSelect": "itemSelect"; "closeRequest": "closeRequest"; "submenuBack": "submenuBack"; }, never, never, true, never>;
+    static ngAcceptInputType_dense: unknown;
+    static ngAcceptInputType_nested: unknown;
+    static ngAcceptInputType_compressText: unknown;
+}
+
+/**
+ * Menu de ações padrão: mesmo comportamento do `dropdown-menu` com trigger «…» (overflow).
+ * Mantém a API de itens existente (`MenuNodeItem`).
+ */
+declare class ActionMenuComponent<T = string> {
+    items: readonly MenuNodeItem<T>[];
+    placement: MenuDropdownPlacement;
+    minWidthPx: number;
+    menuId: string;
+    /** Texto acessível do botão de gatilho. */
+    triggerLabel: string;
+    /** O painel não segue a largura do botão (ícone estreito). */
+    matchTriggerWidth: boolean;
+    readonly itemSelect: EventEmitter<T>;
+    readonly openChange: EventEmitter<boolean>;
+    readonly MenuDropdownPlacement: typeof MenuDropdownPlacement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionMenuComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionMenuComponent<any>, "app-action-menu", never, { "items": { "alias": "items"; "required": true; }; "placement": { "alias": "placement"; "required": false; }; "minWidthPx": { "alias": "minWidthPx"; "required": false; }; "menuId": { "alias": "menuId"; "required": false; }; "triggerLabel": { "alias": "triggerLabel"; "required": false; }; "matchTriggerWidth": { "alias": "matchTriggerWidth"; "required": false; }; }, { "itemSelect": "itemSelect"; "openChange": "openChange"; }, never, never, true, never>;
+    static ngAcceptInputType_matchTriggerWidth: unknown;
+}
+
+/**
+ * Separador semântico reutilizável — mesma apresentação que o divisor do modelo de dados (`kind: 'divider'`).
+ */
+declare class MenuDividerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuDividerComponent, "app-menu-divider", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Cabeçalho opcional de grupo — alinhado a `MenuItemGroup` (`kind: 'group'`).
+ * Os itens do grupo continuam a ser renderizados pelo `menu-list` (renderização única).
+ */
+declare class MenuGroupComponent {
+    label?: string;
+    /** Quando `true`, não mostra o título (ex.: sidebar colapsada só com ícones). */
+    hideLabel: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MenuGroupComponent, "app-menu-group", never, { "label": { "alias": "label"; "required": false; }; "hideLabel": { "alias": "hideLabel"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_hideLabel: unknown;
+}
+
+/**
+ * Fundação reutilizável para painéis ancorados (tooltip, popover, autocomplete, datepicker, etc.).
+ * Usa `CdkConnectedOverlay` + tema da lib.
+ *
+ * @see `DropdownBaseComponent` — overlay para painéis de **campo** (menus/select): backdrop e fecho por omissão
+ *   alinhados a esse caso; mantido separado para não quebrar contratos públicos.
+ */
+declare class AnchoredOverlayComponent {
+    private readonly appTheme;
+    private readonly overlay;
+    open: boolean;
+    readonly openChange: EventEmitter<boolean>;
+    panelTemplate: TemplateRef<unknown>;
+    connectedPositions: ConnectedPosition[];
+    pushConnectedOverlay: boolean;
+    hasBackdrop: boolean;
+    closeOnEscape: boolean;
+    /** Fecha ao clicar fora do painel e fora da âncora (popover, dialogs leves). */
+    closeOnOutsideClick: boolean;
+    panelWidthPx: number | null;
+    panelMinWidthPx: number | null;
+    panelMaxWidthPx: number | null;
+    /**
+     * Estratégia de scroll (predefinição: reposicionar; `close` para fechar ao scroll em certos modais).
+     */
+    scrollStrategy: ScrollStrategy | null;
+    readonly overlayPanelClasses: i0.Signal<string[]>;
+    readonly panelThemeNgClass: i0.Signal<{
+        [x: string]: boolean;
+        'app-library-theme': boolean;
+    }>;
+    readonly defaultScrollStrategy: _angular_cdk_overlay.RepositionScrollStrategy;
+    get effectiveScrollStrategy(): ScrollStrategy;
+    get overlayWidthCss(): number | string | undefined;
+    get overlayMinWidthCss(): number | string | undefined;
+    onBackdropClick(): void;
+    onOverlayOutsideClick(): void;
+    onOverlayKeydown(ev: KeyboardEvent): void;
+    onDetach(): void;
+    setOpen(next: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnchoredOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AnchoredOverlayComponent, "app-anchored-overlay", never, { "open": { "alias": "open"; "required": false; }; "panelTemplate": { "alias": "panelTemplate"; "required": true; }; "connectedPositions": { "alias": "connectedPositions"; "required": false; }; "pushConnectedOverlay": { "alias": "pushConnectedOverlay"; "required": false; }; "hasBackdrop": { "alias": "hasBackdrop"; "required": false; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "panelWidthPx": { "alias": "panelWidthPx"; "required": false; }; "panelMinWidthPx": { "alias": "panelMinWidthPx"; "required": false; }; "panelMaxWidthPx": { "alias": "panelMaxWidthPx"; "required": false; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_open: unknown;
+    static ngAcceptInputType_pushConnectedOverlay: unknown;
+    static ngAcceptInputType_hasBackdrop: unknown;
+    static ngAcceptInputType_closeOnEscape: unknown;
+    static ngAcceptInputType_closeOnOutsideClick: unknown;
+}
+
+/**
+ * Posição preferencial do painel em relação à âncora (com fallbacks via CDK `push` / ordem de posições).
+ */
+declare enum OverlayPlacement {
+    Top = "top",
+    Bottom = "bottom",
+    Left = "left",
+    Right = "right"
+}
+
+/**
+ * Tooltip ancorado ao conteúdo projectado (trigger).
+ * — Texto: `text` ou `ng-template` com `appTooltipPanel`.
+ */
+declare class TooltipComponent {
+    private readonly cdr;
+    text: string;
+    placement: OverlayPlacement;
+    offsetPx: number;
+    showDelayMs: number;
+    hideDelayMs: number;
+    disabled: boolean;
+    private readonly panelDirective?;
+    panelTpl: TemplateRef<unknown>;
+    readonly placementEnum: typeof OverlayPlacement;
+    readonly tooltipId: string;
+    open: boolean;
+    private showTimer;
+    private hideTimer;
+    get panelContentTpl(): TemplateRef<unknown> | null;
+    get positions(): _angular_cdk_overlay.ConnectedPosition[];
+    get describedByWhenOpen(): string | null;
+    onTriggerMouseEnter(): void;
+    onTriggerMouseLeave(): void;
+    onTriggerFocusIn(): void;
+    onTriggerFocusOut(): void;
+    onPanelMouseEnter(): void;
+    onPanelMouseLeave(): void;
+    private scheduleShow;
+    private scheduleHide;
+    private cancelShow;
+    private cancelHide;
+    onAnchoredOpenChange(next: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "app-tooltip", never, { "text": { "alias": "text"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "offsetPx": { "alias": "offsetPx"; "required": false; }; "showDelayMs": { "alias": "showDelayMs"; "required": false; }; "hideDelayMs": { "alias": "hideDelayMs"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["panelDirective"], ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/**
+ * Marca um `ng-template` como conteúdo do painel do tooltip (em alternativa a `text`).
+ */
+declare class TooltipPanelTemplateDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipPanelTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipPanelTemplateDirective, "ng-template[appTooltipPanel]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PopoverBodyTemplateDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverBodyTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverBodyTemplateDirective, "ng-template[appPopoverBody]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PopoverFooterTemplateDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverFooterTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverFooterTemplateDirective, "ng-template[appPopoverFooter]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Painel flutuante ancorado (ações contextuais, ajuda rica, mini-formulários).
+ * Conteúdo: `ng-template appPopoverBody` obrigatório; `appPopoverFooter` opcional; trigger com `appPopoverTrigger`.
+ */
+declare class PopoverComponent {
+    private readonly cdr;
+    title: string;
+    /** Modo controlado: `open` + `openChange`. */
+    open: boolean;
+    readonly openChange: EventEmitter<boolean>;
+    placement: OverlayPlacement;
+    offsetPx: number;
+    minWidthPx: number;
+    maxWidthPx: number;
+    /** Rótulo acessível quando não há título visível. */
+    ariaLabel: string;
+    readonly bodyDirective?: PopoverBodyTemplateDirective;
+    readonly footerDirective?: PopoverFooterTemplateDirective;
+    panelTpl: TemplateRef<unknown>;
+    readonly popoverId: string;
+    get bodyTpl(): TemplateRef<unknown> | null;
+    get footerTpl(): TemplateRef<unknown> | null;
+    get positions(): _angular_cdk_overlay.ConnectedPosition[];
+    get titleId(): string;
+    get effectiveAriaLabel(): string | null;
+    onTriggerClick(ev: Event): void;
+    toggle(): void;
+    /** Sincroniza com `app-anchored-overlay` e notifica o pai (`[(open)]`). */
+    setOpen(next: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PopoverComponent, "app-popover", never, { "title": { "alias": "title"; "required": false; }; "open": { "alias": "open"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "offsetPx": { "alias": "offsetPx"; "required": false; }; "minWidthPx": { "alias": "minWidthPx"; "required": false; }; "maxWidthPx": { "alias": "maxWidthPx"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "openChange": "openChange"; }, ["bodyDirective", "footerDirective"], ["[appPopoverTrigger]"], true, never>;
+    static ngAcceptInputType_open: unknown;
+}
+
+/** Marca o elemento que abre/fecha o popover ao clicar. */
+declare class PopoverTriggerDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PopoverTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PopoverTriggerDirective, "[appPopoverTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Constrói posições CDK para overlay ancorado (tooltip, popover, autocomplete, etc.).
+ * Inclui alternativas para inverter quando não há espaço (`push` no componente).
+ *
+ * Menus dropdown usam {@link menuConnectedPositions} em `menus/_utils` (alinhamento `start`, gap tipicamente menor).
+ */
+declare function anchoredOverlayPositions(placement: OverlayPlacement, offsetPx?: number): ConnectedPosition[];
+
+/**
+ * Duração da animação de largura da lateral (`flex-basis` / `width` / `padding`).
+ * Manter alinhado com `$app-sidebar-layout-duration` em `_sidebar-reveal.scss`.
+ */
+declare const APP_SIDEBAR_LAYOUT_DURATION_MS = 0;
+/** Folga após o layout, antes de revelar rótulos (evita texto a “comprimir”). */
+declare const APP_SIDEBAR_LABEL_REVEAL_LAG_MS = 48;
+declare const APP_SIDEBAR_NAV_REVEAL_TOTAL_MS: number;
+
+/**
+ * Estrutura principal: barra lateral, topo e conteúdo. Em mobile a lateral projecta-se no `app-drawer`.
+ *
+ * Use `exportAs: 'appShell'` e `toggleMobileNav` / `toggleSidebarCollapsed` a partir da topbar.
+ */
+declare class AppShellComponent implements OnInit {
+    private readonly bp;
+    private readonly cdr;
+    private readonly destroyRef;
+    private readonly theme;
+    protected get hostThemeClasses(): string;
+    private readonly sidebarSlot?;
+    /** Conteúdo lateral (obrigatório): `<ng-template appShellSidebar>...</ng-template>`. */
+    get sidebarTemplate(): TemplateRef<unknown> | null;
+    /** Barra lateral estreita (ícones + compressão de texto na lista). */
+    sidebarCollapsed: boolean;
+    readonly sidebarCollapsedChange: EventEmitter<boolean>;
+    /** Estado do drawer mobile (usar `[(mobileNavOpen)]` para controlar o menu hamburger). */
+    mobileNavOpen: boolean;
+    readonly mobileNavOpenChange: EventEmitter<boolean>;
+    /** Consulta CDK para modo mobile (por omissão igual à vista adaptativa). */
+    mobileLayoutQuery: string;
+    isMobileLayout: boolean;
+    readonly DrawerSide: typeof DrawerSide;
+    readonly DrawerSize: typeof DrawerSize;
+    ngOnInit(): void;
+    onMobileDrawerOpenChange(next: boolean): void;
+    /** Emite alteração; com `[(mobileNavOpen)]` no pai o `@Input` actualiza o estado do drawer. */
+    private emitMobileNavOpen;
+    toggleMobileNav(): void;
+    toggleSidebarCollapsed(): void;
+    closeMobileNav(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppShellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppShellComponent, "app-shell", ["appShell"], { "sidebarCollapsed": { "alias": "sidebarCollapsed"; "required": false; }; "mobileNavOpen": { "alias": "mobileNavOpen"; "required": false; }; "mobileLayoutQuery": { "alias": "mobileLayoutQuery"; "required": false; }; }, { "sidebarCollapsedChange": "sidebarCollapsedChange"; "mobileNavOpenChange": "mobileNavOpenChange"; }, ["sidebarSlot"], ["[appShellTopbar]", "*"], true, never>;
+    static ngAcceptInputType_sidebarCollapsed: unknown;
+    static ngAcceptInputType_mobileNavOpen: unknown;
+}
+
+/**
+ * Marca o `ng-template` cuja instância é projectada na barra lateral (desktop) e no `app-drawer` (mobile).
+ *
+ * ```html
+ * <app-shell>
+ *   <ng-template appShellSidebar>
+ *     <app-sidebar ... />
+ *   </ng-template>
+ *   ...
+ * </app-shell>
+ * ```
+ */
+declare class AppShellSidebarTemplateDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppShellSidebarTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppShellSidebarTemplateDirective, "ng-template[appShellSidebar]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Navegação lateral com o mesmo modelo `MenuNodeItem` dos menus da lib (grupos, submenus, teclado).
+ * Com `collapsed`, `app-menu-list` usa `compressText`: rótulos de grupo (ex. «Principal») ficam ocultos;
+ * itens mostram só ícones com `title` / `aria-label` para acessibilidade.
+ */
+declare class AppSidebarComponent<T extends string = string> implements OnChanges {
+    private readonly theme;
+    private readonly destroyRef;
+    /**
+     * Garante `.app-library-theme` + `theme-*` no host para tokens `--app-color-nav-*` e lista
+     * herdarem a paleta activa (útil fora da demo ou sem antepassado tematizado).
+     */
+    protected get hostThemeClasses(): string;
+    items: readonly MenuNodeItem<T>[];
+    menuId: string;
+    /** Sincronizar com o item de navegação activo (realce persistente). */
+    selectedItemId: T | null;
+    /** Modo estreito: só ícones + `compressText` na lista (rótulos via `title` / `aria-label`). */
+    collapsed: boolean;
+    readonly itemSelect: EventEmitter<T>;
+    /**
+     * Valor efectivo de `compressText` em `app-menu-list`: ao expandir, mantém-se comprimido
+     * até a lateral terminar a animação de largura (evita flicker de texto).
+     */
+    readonly listCompressText: i0.WritableSignal<boolean>;
+    private listRevealTimeoutId;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    private clearListRevealTimeout;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppSidebarComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppSidebarComponent<any>, "app-sidebar", never, { "items": { "alias": "items"; "required": true; }; "menuId": { "alias": "menuId"; "required": false; }; "selectedItemId": { "alias": "selectedItemId"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; }, { "itemSelect": "itemSelect"; }, never, ["[appSidebarToolbar]"], true, never>;
+    static ngAcceptInputType_collapsed: unknown;
+}
+
+/**
+ * Marca conteúdo a projectar no topo da sidebar (ex.: botão recolher/expandir).
+ *
+ * ```html
+ * <app-sidebar [items]="nav">
+ *   <app-shell-sidebar-toggle appSidebarToolbar [collapsed]="collapsed" (toggle)="onToggle()" />
+ * </app-sidebar>
+ * ```
+ */
+declare class AppSidebarToolbarDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppSidebarToolbarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppSidebarToolbarDirective, "[appSidebarToolbar]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Botão só ícone (setas «abrir/fechar») para recolher/expandir a largura da lateral.
+ * Na demo, usar com `appSidebarToolbar` projectado em `app-sidebar`.
+ */
+declare class AppShellSidebarToggleComponent {
+    /** `true` quando a lateral está estreita / recolhida. */
+    collapsed: boolean;
+    /** Rótulos acessíveis quando `collapsed` é `true` (accção: expandir). */
+    expandLabel: string;
+    /** Rótulos quando `collapsed` é `false` (accção: recolher). */
+    collapseLabel: string;
+    readonly toggle: EventEmitter<void>;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppShellSidebarToggleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppShellSidebarToggleComponent, "app-shell-sidebar-toggle", never, { "collapsed": { "alias": "collapsed"; "required": false; }; "expandLabel": { "alias": "expandLabel"; "required": false; }; "collapseLabel": { "alias": "collapseLabel"; "required": false; }; }, { "toggle": "toggle"; }, never, never, true, never>;
+    static ngAcceptInputType_collapsed: unknown;
+}
+
+/**
+ * Barra superior com três zonas de projeção: início (ex.: menu), título, fim (ex.: usuário).
+ */
+declare class AppTopbarComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppTopbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppTopbarComponent, "app-topbar", never, {}, {}, never, ["[appTopbarStart]", "[appTopbarTitle]", "[appTopbarEnd]"], true, never>;
+}
+
+/**
+ * Menu do usuário: `app-dropdown-menu` com gatilho personalizado (avatar ou ícone).
+ */
+declare class AppUserMenuComponent<T extends string = string> {
+    items: readonly MenuNodeItem<T>[];
+    menuId: string;
+    placement: MenuDropdownPlacement;
+    minWidthPx: number;
+    /** Texto junto ao avatar (oculto em ecrãs muito estreitos via CSS). */
+    displayName: string;
+    /** URL de imagem para avatar; sem valor usa ícone genérico. */
+    avatarUrl: string;
+    triggerLabel: string;
+    showName: boolean;
+    readonly itemSelect: EventEmitter<T>;
+    readonly openChange: EventEmitter<boolean>;
+    readonly MenuDropdownPlacement: typeof MenuDropdownPlacement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppUserMenuComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppUserMenuComponent<any>, "app-user-menu", never, { "items": { "alias": "items"; "required": true; }; "menuId": { "alias": "menuId"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "minWidthPx": { "alias": "minWidthPx"; "required": false; }; "displayName": { "alias": "displayName"; "required": false; }; "avatarUrl": { "alias": "avatarUrl"; "required": false; }; "triggerLabel": { "alias": "triggerLabel"; "required": false; }; "showName": { "alias": "showName"; "required": false; }; }, { "itemSelect": "itemSelect"; "openChange": "openChange"; }, never, never, true, never>;
+    static ngAcceptInputType_showName: unknown;
+}
+
+/**
+ * Segmento do filo de navegação (`app-breadcrumb`).
+ * Prioridade de navegação: se `route` estiver definido, usa-se `RouterLink`; senão, `href` (âncora nativa).
+ */
+interface BreadcrumbItem {
+    label: string;
+    /** Rota Angular (`routerLink`) quando o segmento é navegável dentro da app. */
+    route?: string | readonly unknown[];
+    /**
+     * URL quando não se usa o router (ex.: link externo). Ignorado se `route` estiver definido.
+     */
+    href?: string;
+}
+
+/**
+ * Filo hierárquico com `nav` + lista ordenada; último segmento com `aria-current="page"`.
+ */
+declare class AppBreadcrumbComponent {
+    items: readonly BreadcrumbItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppBreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AppBreadcrumbComponent, "app-breadcrumb", never, { "items": { "alias": "items"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+export { ADAPTIVE_DATA_VIEW_MOBILE_QUERY, APP_SIDEBAR_LABEL_REVEAL_LAG_MS, APP_SIDEBAR_LAYOUT_DURATION_MS, APP_SIDEBAR_NAV_REVEAL_TOTAL_MS, APP_THEME_IDS, ActionMenuComponent, AdaptiveDataViewComponent, AnchoredOverlayComponent, AppBreadcrumbComponent, AppDialogComponent, AppLibLightBlockScrollStrategy, AppShellComponent, AppShellSidebarTemplateDirective, AppShellSidebarToggleComponent, AppSidebarComponent, AppSidebarToolbarDirective, AppThemeService, AppTopbarComponent, AppUserMenuComponent, BR_ESTADOS_NOME_SIGLA, BaseButtonComponent, BaseButtonType, BaseButtonVariant, BaseFieldComponent, BaseFieldDirective, BooleanFieldDirective, CardListComponent, CepFieldComponent, CheckboxFieldComponent, ConfirmDialogComponent, ConfirmDialogService, ContextMenuComponent, CpfCnpjFieldComponent, DashboardSectionComponent, DataCardComponent, DataGridComponent, DataListComponent, DataToolbarComponent, DateFieldComponent, DecimalFieldComponent, DetailsFieldComponent, DetailsViewComponent, DialogFooterDirective, DrawerComponent, DrawerSide, DrawerSize, DropdownBaseComponent, DropdownMenuComponent, DropdownMultiOptionFieldBase, DropdownOptionFieldBase, DropdownSearchFieldComponent, EmptyStateComponent, FormActionsAlign, FormActionsComponent, FormColComponent, FormGroupComponent, FormGroupVariant, FormRowAlign, FormRowComponent, FormRowGap, FormRowJustify, FormSectionComponent, FormTabComponent, FormTabsComponent, InputMaskFieldComponent, IntegerFieldComponent, LayoutStackAlign, LayoutStackComponent, LibDialogSize, ListItemComponent, LoadingDialogComponent, LoadingDialogService, MaskedTextFieldBase, MenuDividerComponent, MenuDropdownPlacement, MenuGroupComponent, MenuListComponent, MultiselectFieldComponent, NgControlFieldDirective, OverlayPlacement, PasswordFieldComponent, PhoneFieldComponent, PopoverBodyTemplateDirective, PopoverComponent, PopoverFooterTemplateDirective, PopoverTriggerDirective, STRUCTRA_UI, SelectFieldComponent, SkeletonBlockComponent, SkeletonCardComponent, SkeletonFieldShellComponent, SkeletonListComponent, SkeletonTableComponent, SkeletonTextComponent, StatCardComponent, StatusBadgeComponent, SwitchFieldComponent, TableEmptyStateComponent, TableToolbarComponent, TextFieldComponent, TextareaFieldComponent, ToastHostComponent, ToastService, TooltipComponent, TooltipPanelTemplateDirective, ValidationSummaryComponent, anchoredOverlayPositions, applyPickedCalendarDate, buildDecimalBrDisplay, buildDecimalBrParseString, buildEmptyStateOverlayHtml, caretIndexFromIntegerDigitCount, caretIndexFromSemantic, cepMaskCompleteValidator, cpfCnpjMaskCompleteValidator, escapeHtml, extractDecimalBrParts, fixedDigitsMaskCompleteValidator, formatDateTimePtBr, formatDecimalBr, formatIntegerThousandsBr, formatMaskDigits, formatUiFieldDateValue, libDialogPanelClasses, mapEstadosToOptions, maskDigitCount, normalizeFormDateValue, parseDecimalBr, parseIntegerString, parseUiFieldDateValue, phoneBrMaskCompleteValidator, resolveControlAtPath, sanitizeDecimalBrInput, sanitizeIntegerDigits, sectionHasVisibleInvalid, semanticCaretAt, semanticIntegerDigitCountLeft, stripToDigits, subscribeMarkForCheckOnInvalidUiRefresh, subtreeHasVisibleInvalid };
+export type { AdaptiveDataViewMode, AppThemeId, AppThemeOption, BreadcrumbItem, CardItemView, CardListDataMode, CardListMapFn, ConfirmDialogData, ConfirmDialogVariant, DataGridColumn, DataGridPaginationChangeEvent, DetailsViewItem, DropdownListBindings, DropdownSearchPageRequested, FieldCommonInputs, FormTabsVariant, LoadingDialogData, MenuItemAction, MenuItemDivider, MenuItemGroup, MenuItemKind, MenuItemSubmenu, MenuLeafItem, MenuNodeItem, SelectPageRequested, SkeletonFieldShellVariant, StatCardDeltaTone, StatusBadgeSize, StatusBadgeVariant, ToastInstance, ToastShowOptions, ToastType, ToastVerticalPosition, UiSelectOption, ValidationSummaryItem, ValidationSummaryVariant };