structra-ui 0.1.4 → 0.1.6

package/app/fields/input-fields/_base/ng-control-field.directive.d.ts

@@ -0,0 +1,43 @@
+import { DoCheck, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { AbstractControl, NgControl } from '@angular/forms';
+import { BaseFieldDirective } from './base-field.directive';
+import * as i0 from "@angular/core";
+/**
+ * Campos com `NgControl` + CVA: injeta o control e expõe estado de erro/a11y comuns.
+ */
+export 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, false, never>;
+}

package/app/fields/input-fields/_models/field-common-inputs.model.d.ts

@@ -0,0 +1,49 @@
+import type { MenuNodeItem } from '../../../menus/_models/menu-item.model';
+/**
+ * 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).
+ */
+export 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;
+}

package/app/fields/input-fields/_models/index.d.ts

@@ -0,0 +1 @@
+export type { FieldCommonInputs } from './field-common-inputs.model';

package/app/fields/input-fields/_utils/mask-complete.validators.d.ts

@@ -0,0 +1,18 @@
+import { ValidatorFn } from '@angular/forms';
+/**
+ * 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`.
+ */
+export 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.
+ */
+export 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`.
+ */
+export declare function fixedDigitsMaskCompleteValidator(expectedDigits: number): ValidatorFn;
+/** CEP brasileiro (`app-cep-field`): 8 dígitos. Usar com `Validators.required`. */
+export declare function cepMaskCompleteValidator(): ValidatorFn;

package/app/fields/input-fields/_utils/mask-format.utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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. */
+export declare function stripToDigits(s: string): string;
+/** Conta quantos `#` existem no padrão (= número máximo de dígitos). */
+export 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).
+ */
+export declare function formatMaskDigits(digitsOnly: string, pattern: string): string;

package/app/fields/input-fields/cep-field/cep-field.component.d.ts

@@ -0,0 +1,12 @@
+import { MaskedTextFieldBase } from '../_base/masked-text-field.base';
+import * as i0 from "@angular/core";
+/** CEP brasileiro (8 dígitos). Valor do modelo: só dígitos, ex. `01310100`. */
+export 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>;
+}

package/app/fields/input-fields/cpf-cnpj-field/cpf-cnpj-field.component.d.ts

@@ -0,0 +1,20 @@
+import { MaskedTextFieldBase } from '../_base/masked-text-field.base';
+import * as i0 from "@angular/core";
+/**
+ * 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`.
+ */
+export 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>;
+}

package/app/fields/input-fields/date-field/date-field.component.d.ts

@@ -0,0 +1,30 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { MatDatepicker } from '@angular/material/datepicker';
+import { NgControlFieldDirective } from '../_base/ng-control-field.directive';
+import * as i0 from "@angular/core";
+export 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;
+}

package/app/fields/input-fields/decimal-field/decimal-field.component.d.ts

@@ -0,0 +1,17 @@
+import { NgControlFieldDirective } from '../_base/ng-control-field.directive';
+import * as i0 from "@angular/core";
+export 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;
+}

package/app/fields/input-fields/index.d.ts

@@ -0,0 +1,22 @@
+export { BaseFieldDirective } from './_base/base-field.directive';
+export { BaseFieldComponent } from './_base/base-field.component';
+export { NgControlFieldDirective } from './_base/ng-control-field.directive';
+export { TextFieldComponent } from './text-field/text-field.component';
+export { PasswordFieldComponent } from './password-field/password-field.component';
+export { TextareaFieldComponent } from './textarea-field/textarea-field.component';
+export { IntegerFieldComponent } from './integer-field/integer-field.component';
+export { DecimalFieldComponent } from './decimal-field/decimal-field.component';
+export { DateFieldComponent } from './date-field/date-field.component';
+export { InputMaskFieldComponent } from './input-mask-field/input-mask-field.component';
+export { CepFieldComponent } from './cep-field/cep-field.component';
+export { PhoneFieldComponent } from './phone-field/phone-field.component';
+export { CpfCnpjFieldComponent } from './cpf-cnpj-field/cpf-cnpj-field.component';
+export { MaskedTextFieldBase } from './_base/masked-text-field.base';
+export { stripToDigits, maskDigitCount, formatMaskDigits, } from './_utils/mask-format.utils';
+export { cepMaskCompleteValidator, cpfCnpjMaskCompleteValidator, fixedDigitsMaskCompleteValidator, phoneBrMaskCompleteValidator, } from './_utils/mask-complete.validators';
+export type { FieldCommonInputs } from './_models';
+export { BR_ESTADOS_NOME_SIGLA, mapEstadosToOptions, } from '../../_utils/estados-br.data';
+export { sanitizeIntegerDigits, parseIntegerString, } from '../../_utils/integer-value.utils';
+export { formatIntegerThousandsBr, semanticIntegerDigitCountLeft, caretIndexFromIntegerDigitCount, } from '../../_utils/integer-br.utils';
+export { sanitizeDecimalBrInput, parseDecimalBr, formatDecimalBr, extractDecimalBrParts, buildDecimalBrDisplay, buildDecimalBrParseString, semanticCaretAt, caretIndexFromSemantic, } from '../../_utils/decimal-br.utils';
+export { formatDateTimePtBr, formatUiFieldDateValue, parseUiFieldDateValue, normalizeFormDateValue, applyPickedCalendarDate, } from '../../_utils/date-pt-br.utils';

package/app/fields/input-fields/input-mask-field/input-mask-field.component.d.ts

@@ -0,0 +1,16 @@
+import { MaskedTextFieldBase } from '../_base/masked-text-field.base';
+import * as i0 from "@angular/core";
+/**
+ * Campo de texto com máscara configurável (`#` = dígito).
+ * Valor do formulário: apenas dígitos, sem máscara.
+ */
+export 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>;
+}

package/app/fields/input-fields/integer-field/integer-field.component.d.ts

@@ -0,0 +1,17 @@
+import { NgControlFieldDirective } from '../_base/ng-control-field.directive';
+import * as i0 from "@angular/core";
+export 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;
+}

package/app/fields/input-fields/password-field/password-field.component.d.ts

@@ -0,0 +1,30 @@
+import { OnInit } from '@angular/core';
+import { NgControlFieldDirective } from '../_base/ng-control-field.directive';
+import * as i0 from "@angular/core";
+export 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;
+}

package/app/fields/input-fields/phone-field/phone-field.component.d.ts

@@ -0,0 +1,22 @@
+import { MaskedTextFieldBase } from '../_base/masked-text-field.base';
+import * as i0 from "@angular/core";
+/**
+ * Telefone BR: celular 11 dígitos `(##) #####-####` ou fixo 10 `(##) ####-####`.
+ * Valor do modelo: só dígitos (DDD + número), ex. `11999999999` ou `1133334444`.
+ */
+export 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;
+}

package/app/fields/input-fields/text-field/text-field.component.d.ts

@@ -0,0 +1,16 @@
+import { NgControlFieldDirective } from '../_base/ng-control-field.directive';
+import * as i0 from "@angular/core";
+export 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;
+}

package/app/fields/input-fields/textarea-field/textarea-field.component.d.ts

@@ -0,0 +1,31 @@
+import { OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { NgControlFieldDirective } from '../_base/ng-control-field.directive';
+import * as i0 from "@angular/core";
+export 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;
+}

package/app/form-layout/_models/form-layout.model.d.ts

@@ -0,0 +1,41 @@
+/** Espaçamento horizontal/vertical entre itens da linha. */
+export declare enum FormRowGap {
+    Xs = "xs",
+    Sm = "sm",
+    Md = "md",
+    Lg = "lg"
+}
+/** Alinhamento no eixo cruzado (itens da linha). */
+export declare enum FormRowAlign {
+    Start = "start",
+    Center = "center",
+    End = "end",
+    Stretch = "stretch"
+}
+/** Distribuição no eixo principal. */
+export declare enum FormRowJustify {
+    Start = "start",
+    Center = "center",
+    End = "end",
+    Between = "between"
+}
+/** Variante visual do grupo. */
+export declare enum FormGroupVariant {
+    Default = "default",
+    Outlined = "outlined",
+    Subtle = "subtle"
+}
+/** Alinhamento horizontal no eixo principal (`justify-content`) em `app-layout-stack`. */
+export declare enum LayoutStackAlign {
+    Start = "start",
+    Center = "center",
+    End = "end",
+    SpaceBetween = "space-between"
+}
+/** Alinhamento em `app-form-actions` (barra de ações de formulário). */
+export declare enum FormActionsAlign {
+    Start = "start",
+    Center = "center",
+    End = "end",
+    SpaceBetween = "space-between"
+}

package/app/form-layout/_models/form-tabs.model.d.ts

@@ -0,0 +1 @@
+export type FormTabsVariant = 'default' | 'pill';

package/app/form-layout/_models/index.d.ts

@@ -0,0 +1,3 @@
+export { LayoutStackAlign, FormActionsAlign, FormGroupVariant, FormRowAlign, FormRowGap, FormRowJustify, } from './form-layout.model';
+export type { ValidationSummaryItem, ValidationSummaryVariant, } from './validation-summary.model';
+export type { FormTabsVariant } from './form-tabs.model';

package/app/form-layout/_models/validation-summary.model.d.ts

@@ -0,0 +1,8 @@
+/** Variante visual do resumo de validação. */
+export type ValidationSummaryVariant = 'error' | 'warning' | 'info';
+/** Item do resumo: mensagem e destino opcional para foco / scroll / destaque. */
+export interface ValidationSummaryItem {
+    message: string;
+    /** `id` HTML do controle focável (ex.: o mesmo `[id]` dos campos da lib). */
+    fieldId?: string;
+}

package/app/form-layout/form-actions/form-actions.component.d.ts

@@ -0,0 +1,21 @@
+import { FormActionsAlign, LayoutStackAlign } from '../_models/form-layout.model';
+import * as i0 from "@angular/core";
+/** Barra de ações de formulário (Salvar, Cancelar, Adicionar, …). Projeção de conteúdo. */
+export 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;
+}

package/app/form-layout/form-col/form-col.component.d.ts

@@ -0,0 +1,25 @@
+import * as i0 from "@angular/core";
+/**
+ * Coluna no sistema de 12 trilhos da {@link FormRowComponent}.
+ * Em viewports menores que `sm`, usa `xs` (por defeito largura total).
+ */
+export declare class FormColComponent {
+    /** Colunas ocupadas em < `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;
+}

package/app/form-layout/form-group/form-group.component.d.ts

@@ -0,0 +1,125 @@
+import { DoCheck, EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { FormGroupVariant } from '../_models/form-layout.model';
+import * as i0 from "@angular/core";
+export 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;
+}

package/app/form-layout/form-group/form-path.utils.d.ts

@@ -0,0 +1,16 @@
+import { AbstractControl } from '@angular/forms';
+/** Resolve `a.b.c` a partir da raiz do formulário (normalmente o `FormGroup` do `<form [formGroup]>`). */
+export 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.
+ */
+export 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`).
+ */
+export declare function sectionHasVisibleInvalid(root: AbstractControl, path: string, formSubmitted?: boolean): boolean;