@seniorsistemas/data-seniorx-core 3.0.0 → 3.1.0

package/features/datepicker/datepicker.component.d.ts

@@ -0,0 +1,118 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import { InputsComponent } from '../../core/directives/inputs.directive';
+import type { CalendarDay, DatePickerMode, DatePickerSelectionMode, DateRange, DatepickerMonthChangeEvent, DatepickerView } from '../../core/types/datepicker.type';
+import * as i0 from "@angular/core";
+type DatepickerValue = Date | DateRange | Date[] | null;
+export declare class DatepickerComponent extends InputsComponent<DatepickerValue> implements OnInit, OnDestroy, Validator {
+    private readonly translate;
+    private readonly cdr;
+    private readonly elementRef;
+    private readonly subscriptions;
+    mode: DatePickerMode;
+    selectionMode: DatePickerSelectionMode;
+    showIcon: boolean;
+    icon: string;
+    min: Date | null;
+    max: Date | null;
+    defaultDate: Date | null;
+    dateFormat: string;
+    hourFormat: '12' | '24';
+    minuteStep: number;
+    showSeconds: boolean;
+    rangeSeparator: string;
+    showOnFocus: boolean;
+    readonlyInput: boolean;
+    firstDayOfWeek: number;
+    showButtonBar: boolean;
+    showClear: boolean;
+    disabledDates: Date[];
+    disabledDays: number[];
+    selected: EventEmitter<DatepickerValue>;
+    closed: EventEmitter<void>;
+    monthChange: EventEmitter<DatepickerMonthChangeEvent>;
+    yearChange: EventEmitter<DatepickerMonthChangeEvent>;
+    inputRef?: ElementRef<HTMLInputElement>;
+    triggerRef?: ElementRef<HTMLElement>;
+    private readonly panelContentRef?;
+    private readonly dayButtonRefs?;
+    protected readonly inputId: string;
+    panelOpen: boolean;
+    private suppressNextFocusOpen;
+    readonly currentView: import("@angular/core").WritableSignal<DatepickerView>;
+    readonly viewDate: import("@angular/core").WritableSignal<Date>;
+    readonly focusedDate: import("@angular/core").WritableSignal<Date | null>;
+    readonly hours: import("@angular/core").WritableSignal<number>;
+    readonly minutes: import("@angular/core").WritableSignal<number>;
+    readonly seconds: import("@angular/core").WritableSignal<number>;
+    private readonly rangeStart;
+    private readonly rangeEnd;
+    private readonly rangeSelecting;
+    readonly weekDayNames: import("@angular/core").Signal<string[]>;
+    calendarDays(): CalendarDay[];
+    calendarWeeks(): CalendarDay[][];
+    calendarMonths(): {
+        month: number;
+        name: string;
+        selected: boolean;
+    }[];
+    readonly yearRange: import("@angular/core").Signal<number[]>;
+    displayValue(): string;
+    readonly viewMonthYearLabel: import("@angular/core").Signal<string>;
+    readonly showTimePicker: import("@angular/core").Signal<boolean>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: DatepickerValue): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    openPanel(): void;
+    closePanel(): void;
+    private closePanelAndFocusInput;
+    togglePanel(): void;
+    onInputClick(): void;
+    onInputFocus(): void;
+    onOverlayKeydown(event: KeyboardEvent): void;
+    onKeydown(event: KeyboardEvent): void;
+    private focusIntoPanel;
+    onDaysGridKeydown(event: KeyboardEvent): void;
+    prevMonth(): void;
+    nextMonth(): void;
+    prevYear(): void;
+    nextYear(): void;
+    prevYearRange(): void;
+    nextYearRange(): void;
+    switchToMonthView(): void;
+    switchToYearView(): void;
+    selectMonth(month: number): void;
+    selectYear(year: number): void;
+    selectDay(day: CalendarDay): void;
+    incrementHours(): void;
+    decrementHours(): void;
+    incrementMinutes(): void;
+    decrementMinutes(): void;
+    incrementSeconds(): void;
+    decrementSeconds(): void;
+    selectToday(): void;
+    clearValue(): void;
+    confirmDateTime(): void;
+    onPopoverOpenChange(open: boolean): void;
+    private initializeViewDate;
+    private commitDateValue;
+    private handleRangeSelection;
+    private handleMultipleSelection;
+    private updateTimeOnValue;
+    private isDateSelected;
+    private isDateDisabled;
+    private isInRange;
+    private isRangeStart;
+    private isRangeEnd;
+    private isMonthSelected;
+    private isSameDay;
+    private handleDaysKeydown;
+    private focusDayButton;
+    isDayTabStop(day: CalendarDay): boolean;
+    private formatDate;
+    padTime(n: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatepickerComponent, "sdc-datepicker", never, { "mode": { "alias": "mode"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "defaultDate": { "alias": "defaultDate"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "hourFormat": { "alias": "hourFormat"; "required": false; }; "minuteStep": { "alias": "minuteStep"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "rangeSeparator": { "alias": "rangeSeparator"; "required": false; }; "showOnFocus": { "alias": "showOnFocus"; "required": false; }; "readonlyInput": { "alias": "readonlyInput"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "showButtonBar": { "alias": "showButtonBar"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "disabledDates": { "alias": "disabledDates"; "required": false; }; "disabledDays": { "alias": "disabledDays"; "required": false; }; }, { "selected": "selected"; "closed": "closed"; "monthChange": "monthChange"; "yearChange": "yearChange"; }, never, never, true, never>;
+}
+export {};

package/features/dynamic-form/dynamic-form-field.directive.d.ts

@@ -0,0 +1,26 @@
+import { OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import type { DynamicFieldConfig } from '../../core/types/dynamic-form.type';
+import * as i0 from "@angular/core";
+export declare class DynamicFormFieldDirective implements OnChanges, OnDestroy {
+    private readonly viewContainer;
+    private componentRef;
+    field: DynamicFieldConfig;
+    formGroup: FormGroup;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private renderField;
+    private applyFieldConfig;
+    private mapCommonInputs;
+    private mapRequiredAndDisabled;
+    private mapOptionsAndRange;
+    private mapOptions;
+    private mapRange;
+    private mapExtraInputs;
+    private trySetInput;
+    private updateFormControl;
+    private writeValueToInstance;
+    private bindInstanceCallbacksToControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormFieldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicFormFieldDirective, "[sdcDynamicFormField]", never, { "field": { "alias": "sdcDynamicFormField"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; }, {}, never, never, true, never>;
+}

package/features/dynamic-form/dynamic-form.component.d.ts

@@ -0,0 +1,15 @@
+import { FormGroup } from '@angular/forms';
+import type { DynamicFieldConfig, DynamicStructureConfig } from '../../core/types/dynamic-form.type';
+import * as i0 from "@angular/core";
+export declare class DynamicFormComponent {
+    form: FormGroup;
+    fields: (DynamicFieldConfig | DynamicStructureConfig)[];
+    isStructure(item: DynamicFieldConfig | DynamicStructureConfig): item is DynamicStructureConfig;
+    isField(item: DynamicFieldConfig | DynamicStructureConfig): item is DynamicFieldConfig;
+    isFieldVisible(field: DynamicFieldConfig): boolean;
+    getGridStyle(structure: DynamicStructureConfig): Record<string, string>;
+    getFieldStyle(field: DynamicFieldConfig): Record<string, string>;
+    trackItem(index: number, item: DynamicFieldConfig | DynamicStructureConfig): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormComponent, "sdc-dynamic-form", never, { "form": { "alias": "form"; "required": true; }; "fields": { "alias": "fields"; "required": false; }; }, {}, never, never, true, never>;
+}

package/features/dynamic-form/dynamic-form.registry.d.ts

@@ -0,0 +1,11 @@
+import { Type } from '@angular/core';
+import type { DynamicFieldType } from '../../core/types/dynamic-form.type';
+export declare class DynamicFormRegistry {
+    private static readonly fields;
+    static registerField(type: DynamicFieldType, component: Type<unknown>): void;
+    static resolveField(type: string): Type<unknown> | undefined;
+    static registerMany(mappings: Array<{
+        type: DynamicFieldType;
+        component: Type<unknown>;
+    }>): void;
+}

package/features/editable-overlay/editable-overlay-editor.directive.d.ts

@@ -0,0 +1,22 @@
+import { TemplateRef } from '@angular/core';
+import type { EditableOverlayEditorContext } from '../../core/types/editable-overlay.type';
+import * as i0 from "@angular/core";
+/**
+ * Structural directive used to project a custom editor inside `sdc-editable-overlay`:
+ *
+ * ```html
+ * <sdc-editable-overlay [formControl]="control">
+ *   <ng-template sdcEditableOverlayEditor let-value let-commit="commit">
+ *     <sdc-textarea [value]="value" (valueChange)="commit($event)"></sdc-textarea>
+ *   </ng-template>
+ * </sdc-editable-overlay>
+ * ```
+ *
+ * See `EditableOverlayEditorContext` for the full shape available to the template.
+ */
+export declare class EditableOverlayEditorDirective<T = unknown> {
+    readonly template: TemplateRef<EditableOverlayEditorContext<T>>;
+    constructor(template: TemplateRef<EditableOverlayEditorContext<T>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditableOverlayEditorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EditableOverlayEditorDirective<any>, "ng-template[sdcEditableOverlayEditor]", never, {}, {}, never, never, true, never>;
+}

package/features/editable-overlay/editable-overlay.component.d.ts

@@ -0,0 +1,60 @@
+import { EventEmitter } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import type { EditableOverlayEditorContext } from '../../core/types/editable-overlay.type';
+import type { StringBoolean } from '../../core/types/semantics.type';
+import { EditableOverlayEditorDirective } from './editable-overlay-editor.directive';
+import * as i0 from "@angular/core";
+export declare class EditableOverlayComponent implements ControlValueAccessor {
+    private readonly cdr;
+    private readonly translate;
+    label: StringBoolean;
+    message: StringBoolean;
+    invalid: boolean;
+    required: boolean;
+    disabled: boolean;
+    placeholder: string;
+    emptyText: StringBoolean;
+    saveLabel: StringBoolean;
+    cancelLabel: StringBoolean;
+    maxlength?: number;
+    displayFormatter?: (value: unknown) => string;
+    saved: EventEmitter<unknown>;
+    canceled: EventEmitter<void>;
+    openChange: EventEmitter<boolean>;
+    valueChange: EventEmitter<unknown>;
+    protected editorTemplate?: EditableOverlayEditorDirective;
+    protected readonly labelId: string;
+    protected readonly messageId: string;
+    protected readonly triggerId: string;
+    protected value: unknown;
+    protected draft: unknown;
+    protected open: boolean;
+    protected readonly editorContext: EditableOverlayEditorContext;
+    private onChangeFn;
+    private onTouchedFn;
+    protected get editAriaLabel(): string;
+    protected get saveButtonLabel(): string;
+    protected get cancelButtonLabel(): string;
+    protected get emptyStateText(): string;
+    protected get isValueEmpty(): boolean;
+    protected get displayText(): string;
+    protected get draftAsString(): string;
+    labelKey(): string;
+    messageKey(): string;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected startEdit(): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    protected saveEdit(): void;
+    protected cancelEdit(): void;
+    /** Reacts to sdc-popover closing itself (outside click / Escape) - treated as a cancel. */
+    protected onPopoverOpenChange(nextOpen: boolean): void;
+    protected updateDraft(value: unknown): void;
+    private closeOverlay;
+    private isEmpty;
+    private formatValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditableOverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditableOverlayComponent, "sdc-editable-overlay", never, { "label": { "alias": "label"; "required": false; }; "message": { "alias": "message"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; "saveLabel": { "alias": "saveLabel"; "required": false; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "displayFormatter": { "alias": "displayFormatter"; "required": false; }; }, { "saved": "saved"; "canceled": "canceled"; "openChange": "openChange"; "valueChange": "valueChange"; }, ["editorTemplate"], never, true, never>;
+}

package/features/editor/editor.component.d.ts

@@ -0,0 +1,47 @@
+import { AfterViewInit, EventEmitter, OnDestroy } from '@angular/core';
+import { InputsComponent } from '../../core/directives/inputs.directive';
+import * as i0 from "@angular/core";
+/** Event emitted when the editor content changes. */
+export interface EditorTextChangeEvent {
+    htmlValue: string;
+    textValue: string;
+}
+/** Text alignment options accepted by {@link EditorComponent.setTextAlign}. */
+export type EditorTextAlignment = 'left' | 'center' | 'right' | 'justify';
+/** Default toolbar buttons available in the editor. */
+export declare const EDITOR_DEFAULT_TOOLBAR_BUTTONS: string[];
+export declare class EditorComponent extends InputsComponent<string> implements AfterViewInit, OnDestroy {
+    readonly: boolean;
+    minHeight: string;
+    maxHeight: string;
+    showToolbar: boolean;
+    toolbarButtons: string[];
+    infoTooltip: string | null;
+    textChange: EventEmitter<EditorTextChangeEvent>;
+    selectionChange: EventEmitter<void>;
+    private readonly editorHost;
+    protected readonly editorHostId: string;
+    private editor;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: string): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Check if a mark or node is active in the current selection. */
+    isActive(name: string | Record<string, unknown>, attrs?: Record<string, unknown>): boolean;
+    /** Check if a toolbar button should be shown based on `toolbarButtons` config. */
+    isButtonVisible(name: string): boolean;
+    toggleBold(): void;
+    toggleItalic(): void;
+    toggleUnderline(): void;
+    toggleStrike(): void;
+    toggleBulletList(): void;
+    toggleOrderedList(): void;
+    setTextAlign(alignment: EditorTextAlignment): void;
+    toggleBlockquote(): void;
+    toggleCode(): void;
+    undo(): void;
+    redo(): void;
+    private buildExtensions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditorComponent, "sdc-editor", never, { "readonly": { "alias": "readonly"; "required": false; }; "minHeight": { "alias": "minHeight"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; "toolbarButtons": { "alias": "toolbarButtons"; "required": false; }; "infoTooltip": { "alias": "infoTooltip"; "required": false; }; }, { "textChange": "textChange"; "selectionChange": "selectionChange"; }, never, never, true, never>;
+}

package/features/help-popover/help-popover.component.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter, TemplateRef } from '@angular/core';
+import type { HelpPopoverArrowPosition, HelpPopoverPosition } from '../../core/types/help-popover.type';
+import type { PopoverPlacement } from '../../core/types/popover.type';
+import * as i0 from "@angular/core";
+/**
+ * @description Balão de ajuda contextual acionado a partir de um elemento projetado (trigger).
+ * Reutiliza o `sdc-popover` como motor de overlay/posicionamento (abertura, clique fora, escape,
+ * anexação ao body/appendTo, foco). O `sdc-help-popover` é responsável apenas pela apresentação
+ * do balão (cabeçalho, conteúdo, rodapé e seta indicativa) e pelo cálculo visual adicional
+ * necessário para as posições `left`/`right`, que o `sdc-popover` não modela nativamente.
+ *
+ * @example
+ * ```html
+ * <sdc-help-popover content="Informe aqui o seu CPF" position="right">
+ *   <button sdc-help-popover-trigger type="button">?</button>
+ * </sdc-help-popover>
+ * ```
+ */
+export declare class HelpPopoverComponent {
+    private readonly cdr;
+    /** Conteúdo do balão: texto simples (chave de tradução ou texto literal) ou `TemplateRef`. */
+    content: string | TemplateRef<unknown> | null;
+    /** Exibe o botão de fechar (X) no cabeçalho do balão. */
+    closeButton: boolean;
+    /** Classe de ícone (ex: Font Awesome) exibida no cabeçalho. */
+    icon: string;
+    /** Texto (chave de tradução) exibido no cabeçalho. */
+    header: string;
+    /** Texto (chave de tradução) exibido no rodapé. */
+    footer: string;
+    /** Texto (chave de tradução) do botão de ação do rodapé. */
+    buttonText: string;
+    /** Posição do balão em relação ao elemento de trigger. */
+    position: HelpPopoverPosition;
+    /** Alinhamento da seta indicadora em relação ao lado do balão. */
+    arrowPosition: HelpPopoverArrowPosition;
+    /** Desabilita a abertura do balão. */
+    disabled: boolean;
+    /** Fecha o balão ao clicar fora dele. */
+    closeOnOutsideClick: boolean;
+    /** Seletor do elemento onde o painel do balão será anexado (padrão: `document.body`). */
+    appendTo?: string;
+    /** Sobrescreve o texto (chave de tradução) usado como `aria-label` do balão. */
+    ariaLabel?: string;
+    /** Classes adicionais aplicadas ao painel do balão. */
+    panelClass?: string;
+    /** Emitido quando o usuário clica no botão de ação do rodapé. */
+    buttonClicked: EventEmitter<void>;
+    /** Emitido quando o estado de abertura do balão muda (clique no trigger, X, fora, ou show()/hide()). */
+    openChange: EventEmitter<boolean>;
+    private readonly popoverRef?;
+    protected readonly closeAriaLabelKey = "platform.datacore.help_popover.close";
+    protected open: boolean;
+    protected triggerWidth: number;
+    protected triggerHeight: number;
+    protected get contentIsString(): boolean;
+    protected get contentText(): string;
+    protected get contentTemplate(): TemplateRef<unknown> | null;
+    protected get hasIcon(): boolean;
+    protected get hasHeaderText(): boolean;
+    protected get hasHeader(): boolean;
+    protected get hasFooterText(): boolean;
+    protected get hasButtonText(): boolean;
+    protected get hasFooter(): boolean;
+    protected get isTopOrBottom(): boolean;
+    protected get isLeftOrRight(): boolean;
+    protected get resolvedPlacement(): PopoverPlacement;
+    protected get resolvedAriaLabel(): string;
+    protected get resolvedPanelClass(): string[];
+    /** Abre o balão programaticamente. */
+    show(): void;
+    /** Fecha o balão programaticamente. */
+    hide(): void;
+    /** Alterna a visibilidade do balão. */
+    toggle(): void;
+    protected onButtonClicked(): void;
+    protected onOpenChange(isOpen: boolean): void;
+    private measureTrigger;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HelpPopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HelpPopoverComponent, "sdc-help-popover", never, { "content": { "alias": "content"; "required": false; }; "closeButton": { "alias": "closeButton"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "header": { "alias": "header"; "required": false; }; "footer": { "alias": "footer"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; "position": { "alias": "position"; "required": false; }; "arrowPosition": { "alias": "arrowPosition"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; }, { "buttonClicked": "buttonClicked"; "openChange": "openChange"; }, never, ["[sdc-help-popover-trigger]"], true, never>;
+}

package/features/info-sign/info-sign.component.d.ts

@@ -11,10 +11,11 @@ export declare class InfoSignComponent {
     iconAriaLabel: string;
     tooltipPosition: TooltipPosition;
     tooltipEvent: TooltipEvent;
+    allowHtml: boolean;
     inline: boolean;
     get resolvedTooltip(): string;
     get resolvedLabel(): string | null;
     get resolvedAriaLabel(): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<InfoSignComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<InfoSignComponent, "sdc-info-sign", never, { "label": { "alias": "label"; "required": false; }; "labelParams": { "alias": "labelParams"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": true; }; "tooltipParams": { "alias": "tooltipParams"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "iconAriaLabel": { "alias": "iconAriaLabel"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "tooltipEvent": { "alias": "tooltipEvent"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InfoSignComponent, "sdc-info-sign", never, { "label": { "alias": "label"; "required": false; }; "labelParams": { "alias": "labelParams"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": true; }; "tooltipParams": { "alias": "tooltipParams"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "iconAriaLabel": { "alias": "iconAriaLabel"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "tooltipEvent": { "alias": "tooltipEvent"; "required": false; }; "allowHtml": { "alias": "allowHtml"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; }, {}, never, ["*"], true, never>;
 }

package/features/input-mask/input-mask.directive.d.ts

@@ -0,0 +1,117 @@
+import { EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { AbstractControl, ControlValueAccessor, ValidationErrors, Validator } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * @description Diretiva de máscara de entrada interativa para campos de texto.
+ *
+ * Aplique `sdcInputMask` em qualquer `<input>` para aplicar uma máscara de formatação,
+ * guiando a entrada do usuário com um padrão definido. Implementa `ControlValueAccessor`
+ * e `Validator` para integração nativa com Angular Forms (`ngModel`/`formControl`).
+ *
+ * **Tokens de máscara:**
+ * - `9` — dígito (0-9)
+ * - `a` — letra (conforme `characterPattern`, padrão `[A-Za-z]`)
+ * - `*` — alfanumérico (letra ou dígito)
+ * - Qualquer outro caractere é tratado como literal (ex: `.`, `-`, `/`, `(`, `)`)
+ * - `?` — tudo após esse ponto na máscara passa a ser opcional
+ *
+ * @example
+ * ```html
+ * <!-- CPF -->
+ * <input type="text" sdcInputMask="999.999.999-99" [(ngModel)]="cpf" />
+ *
+ * <!-- CNPJ -->
+ * <input type="text" sdcInputMask="99.999.999/9999-99" [(ngModel)]="cnpj" />
+ *
+ * <!-- Telefone, retornando só os dígitos digitados -->
+ * <input type="text" sdcInputMask="(99) 99999-9999" [unmask]="true" [(ngModel)]="telefone" />
+ * ```
+ * @category Input
+ */
+export declare class InputMaskDirective implements OnInit, OnChanges, ControlValueAccessor, Validator {
+    /**
+     * Padrão da máscara. Tokens: `9` (dígito), `a` (letra), `*` (alfanumérico).
+     * Demais caracteres são literais. `?` torna o restante da máscara opcional.
+     */
+    mask: string | undefined;
+    /**
+     * Caractere exibido nas posições ainda não preenchidas.
+     * @default '_'
+     */
+    slotChar: string;
+    /**
+     * Quando `true`, o modelo recebe apenas os caracteres digitados pelo usuário,
+     * sem os literais da máscara. Quando `false`, o modelo recebe o valor completo
+     * incluindo literais.
+     * @default false
+     */
+    unmask: boolean;
+    /**
+     * Expressão regular usada para validar o token `a` (letra).
+     * @default '[A-Za-z]'
+     */
+    characterPattern: string;
+    /**
+     * Quando `true`, limpa o campo ao perder o foco se a máscara estiver incompleta.
+     * @default true
+     */
+    autoClear: boolean;
+    /**
+     * Emitido quando todos os tokens obrigatórios da máscara estão preenchidos.
+     * Disparado apenas na transição de incompleto para completo (edge-triggered).
+     * Emite o valor atual (mascarado ou não, conforme `unmask`).
+     */
+    maskComplete: EventEmitter<string>;
+    private readonly el;
+    private readonly renderer;
+    private tokens;
+    private buffer;
+    private wasComplete;
+    private lastValue;
+    private onChange;
+    private onTouched;
+    private onValidatorChange;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    registerOnValidatorChange(fn: () => void): void;
+    private buildMask;
+    private parseMask;
+    private buildToken;
+    private resetBuffer;
+    private isValidChar;
+    private isEditable;
+    private nextEditablePos;
+    private prevEditablePos;
+    private setCursor;
+    private setInputValue;
+    private getDisplayValue;
+    private getBlurDisplayValue;
+    /**
+     * Retorna o valor que deve ser propagado ao modelo.
+     * Retorna `null` quando o usuário não digitou nada.
+     */
+    private getModelValue;
+    private clearRange;
+    private isMaskComplete;
+    private checkAndEmitComplete;
+    private dispatchInputEvent;
+    onKeyDown(event: KeyboardEvent): void;
+    private shouldIgnoreKeydown;
+    private handleBackspace;
+    private handleDelete;
+    private handleCharacterInput;
+    private finishEdit;
+    onFocus(_event: FocusEvent): void;
+    onBlur(_event: Event): void;
+    onPaste(event: ClipboardEvent): void;
+    private consumePastedText;
+    private consumePastedChar;
+    onClick(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(onChange: (value: string | null) => void): void;
+    registerOnTouched(onTouched: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputMaskDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputMaskDirective, "input[sdcInputMask]", never, { "mask": { "alias": "sdcInputMask"; "required": false; }; "slotChar": { "alias": "slotChar"; "required": false; }; "unmask": { "alias": "unmask"; "required": false; }; "characterPattern": { "alias": "characterPattern"; "required": false; }; "autoClear": { "alias": "autoClear"; "required": false; }; }, { "maskComplete": "maskComplete"; }, never, never, true, never>;
+}

package/features/lookup/lookup.component.d.ts

@@ -0,0 +1,104 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { ConnectedPosition, ScrollStrategy } from '@angular/cdk/overlay';
+import { InputsComponent } from '../../core/directives/inputs.directive';
+import type { LookupConfig, LookupSearchRequest, LookupSearchResponse } from '../../core/types/lookup.type';
+import type { ModalButton } from '../../core/types/modal.type';
+import type { TableColumn } from '../../core/types/table.type';
+import type { PaginatorState } from '../../core/types/paginator.type';
+import * as i0 from "@angular/core";
+export declare class LookupComponent extends InputsComponent<unknown> implements AfterViewInit, OnDestroy {
+    private static nextId;
+    private static allocateComponentId;
+    private readonly overlay;
+    private readonly router;
+    private readonly destroy$;
+    private readonly inputSubject;
+    private dismissWatcher;
+    /** CDK overlay config */
+    protected readonly scrollStrategy: ScrollStrategy;
+    protected readonly overlayPositions: ConnectedPosition[];
+    protected containerDiv?: ElementRef<HTMLElement>;
+    config: LookupConfig;
+    suggestions: unknown[];
+    dialogData: LookupSearchResponse;
+    dialogLoading: boolean;
+    onLookupRequest: EventEmitter<string>;
+    onDialogSearch: EventEmitter<LookupSearchRequest>;
+    onDialogOpen: EventEmitter<void>;
+    valueSelected: EventEmitter<unknown>;
+    protected readonly componentId: string;
+    protected readonly inputValue: import("@angular/core").WritableSignal<string>;
+    protected readonly panelOpen: import("@angular/core").WritableSignal<boolean>;
+    protected readonly dialogVisible: import("@angular/core").WritableSignal<boolean>;
+    protected readonly dialogQuery: import("@angular/core").WritableSignal<string>;
+    protected readonly dialogPage: import("@angular/core").WritableSignal<number>;
+    protected readonly filtersExpanded: import("@angular/core").WritableSignal<boolean>;
+    protected readonly filterValues: import("@angular/core").WritableSignal<Record<string, string>>;
+    protected readonly dialogSelection: import("@angular/core").WritableSignal<unknown[]>;
+    protected readonly pageSize: import("@angular/core").Signal<number>;
+    protected readonly isMultiple: import("@angular/core").Signal<boolean>;
+    protected readonly hasFilters: import("@angular/core").Signal<boolean>;
+    protected readonly dialogTableConfig: import("@angular/core").Signal<{
+        search: {
+            show: boolean;
+        };
+        table: {
+            totalRecordsLabel: string;
+            responsive: boolean;
+            mode: "api";
+        };
+        pagination: {
+            show: boolean;
+        };
+        empty: {
+            show: boolean;
+            title: string;
+            text: string;
+        };
+        cells: {
+            checkbox: {
+                selectAll: boolean;
+            };
+        };
+    }>;
+    protected readonly tableColumns: import("@angular/core").Signal<TableColumn<import("../../core/types/table-shared.type").RowBase>[]>;
+    protected readonly dialogFirst: import("@angular/core").Signal<number>;
+    protected readonly hasDialogSelection: import("@angular/core").Signal<boolean>;
+    protected readonly dialogModalFooterButtons: import("@angular/core").Signal<ModalButton[]>;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: unknown): void;
+    protected toggleFilters(): void;
+    protected onFilterValueChange(name: string, value: string | null): void;
+    protected filterValueFor(name: string): string;
+    protected mapFilterOptions(options: {
+        value: string;
+        label: string;
+    }[] | undefined): {
+        value: string;
+        text: string;
+    }[];
+    protected applyFilters(): void;
+    protected clearFilters(): void;
+    protected onInputChange(event: Event): void;
+    protected onInputFocus(): void;
+    protected closePanel(): void;
+    protected selectSuggestion(item: unknown): void;
+    protected getDisplayValue(item: unknown): string;
+    protected openDialog(): void;
+    protected onDialogVisibleChange(visible: boolean): void;
+    protected onDialogSearchEvent(query: string): void;
+    protected onDialogPageChange(event: PaginatorState): void;
+    protected onDialogRowClick(row: unknown): void;
+    protected onDialogSelectionChange(selection: unknown[]): void;
+    protected confirmMultipleSelection(): void;
+    private selectItem;
+    private toggleDialogRowSelection;
+    private dataKeyOf;
+    private updateInputDisplay;
+    private emitDialogSearch;
+    private mapFieldType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LookupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LookupComponent, "sdc-lookup", never, { "config": { "alias": "config"; "required": true; }; "suggestions": { "alias": "suggestions"; "required": false; }; "dialogData": { "alias": "dialogData"; "required": false; }; "dialogLoading": { "alias": "dialogLoading"; "required": false; }; }, { "onLookupRequest": "onLookupRequest"; "onDialogSearch": "onDialogSearch"; "onDialogOpen": "onDialogOpen"; "valueSelected": "valueSelected"; }, never, never, true, never>;
+}

package/features/modal/modal.component.d.ts

@@ -8,6 +8,7 @@ export declare class ModalComponent implements AfterViewInit, OnDestroy {
     dialogPanel?: ElementRef<HTMLDivElement>;
     bodyPortal?: CdkPortal;
     footerButtons: ModalButton[];
+    headerActions: ModalButton[];
     header: string;
     height: Dimension;
     maximizable: boolean;
@@ -52,6 +53,6 @@ export declare class ModalComponent implements AfterViewInit, OnDestroy {
     private viewInitialized;
     private bodyPortalOutlet?;
     static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "sdc-modal", never, { "footerButtons": { "alias": "footerButtons"; "required": false; }; "header": { "alias": "header"; "required": false; }; "height": { "alias": "height"; "required": false; }; "maximizable": { "alias": "maximizable"; "required": false; }; "maximize": { "alias": "maximize"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "width": { "alias": "width"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "appendToBody": { "alias": "appendToBody"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, { "hidden": "hidden"; "visibleChange": "visibleChange"; }, never, ["*", "[footer]"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "sdc-modal", never, { "footerButtons": { "alias": "footerButtons"; "required": false; }; "headerActions": { "alias": "headerActions"; "required": false; }; "header": { "alias": "header"; "required": false; }; "height": { "alias": "height"; "required": false; }; "maximizable": { "alias": "maximizable"; "required": false; }; "maximize": { "alias": "maximize"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "width": { "alias": "width"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "closable": { "alias": "closable"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "appendToBody": { "alias": "appendToBody"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, { "hidden": "hidden"; "visibleChange": "visibleChange"; }, never, ["*", "[footer]"], true, never>;
     static ngAcceptInputType_appendToBody: unknown;
 }