@praxisui/dynamic-fields 0.0.1

package/index.d.ts

@@ -0,0 +1,3399 @@
+import * as _angular_core from '@angular/core';
+import { WritableSignal, OnInit, OnDestroy, AfterViewInit, DestroyRef, ElementRef, ChangeDetectorRef, OnChanges, TemplateRef, EventEmitter, ComponentRef, SimpleChanges, Type, Provider, EnvironmentProviders } from '@angular/core';
+import { AbstractControl, ControlValueAccessor, NgControl, ValidationErrors, FormControl, FormGroup, FormGroupDirective, NgForm } from '@angular/forms';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { ComponentMetadata, GenericCrudService, GlobalConfigService, OptionDTO, FieldMetadata, MaterialButtonMetadata, MaterialInputMetadata, MaterialColorInputMetadata, MaterialDateInputMetadata, MaterialDatepickerMetadata, MaterialDateRangeMetadata, MaterialDatetimeLocalInputMetadata, MaterialEmailInputMetadata, MaterialTextareaMetadata, MaterialNumericMetadata, MaterialCurrencyMetadata, MaterialCpfCnpjMetadata, MaterialPriceRangeMetadata, MaterialMonthInputMetadata, MaterialPasswordMetadata, MaterialSearchInputMetadata, MaterialTreeNode, MaterialMultiSelectTreeMetadata, MaterialTreeSelectMetadata, MaterialToggleMetadata, MaterialSliderMetadata, MaterialPhoneMetadata, MaterialTimeInputMetadata, MaterialTimepickerMetadata, MaterialUrlInputMetadata, MaterialWeekInputMetadata, MaterialColorPickerMetadata, MaterialRangeSliderMetadata, MaterialYearInputMetadata, MaterialTimeRangeMetadata, ComponentDocMeta, FieldControlType } from '@praxisui/core';
+import { Router } from '@angular/router';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { MatSelect } from '@angular/material/select';
+import * as _angular_material_error_options_d_CGdTZUYk from '@angular/material/error-options.d-CGdTZUYk';
+import { MatDatepickerInputEvent } from '@angular/material/datepicker';
+import { MatOptionSelectionChange, ErrorStateMatcher } from '@angular/material/core';
+import { SelectionModel } from '@angular/cdk/collections';
+import { NestedTreeControl } from '@angular/cdk/tree';
+import { MatTreeNestedDataSource } from '@angular/material/tree';
+import { MatChipInputEvent } from '@angular/material/chips';
+import { MatButtonToggleChange } from '@angular/material/button-toggle';
+import { MatSelectionListChange, MatSelectionList } from '@angular/material/list';
+import { MatBottomSheet } from '@angular/material/bottom-sheet';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+
+/**
+ * @fileoverview Interface base para todos os componentes de campos dinâmicos
+ *
+ * Define o contrato comum que todos os componentes dinâmicos devem implementar
+ * para garantir compatibilidade com o DynamicFieldLoaderDirective e outros
+ * serviços do sistema.
+ */
+
+/**
+ * Eventos de lifecycle que os componentes podem emitir
+ */
+interface ComponentLifecycleEvent {
+    phase: 'init' | 'afterInit' | 'change' | 'destroy';
+    timestamp: number;
+    componentId: string;
+    metadata?: any;
+}
+/**
+ * Opções para métodos de controle de valor
+ */
+interface ValueChangeOptions {
+    emitEvent?: boolean;
+    updateUI?: boolean;
+}
+/**
+ * Interface base que todos os componentes de campos dinâmicos devem implementar.
+ *
+ * Esta interface define o contrato mínimo necessário para que um componente
+ * seja compatível com o sistema de renderização dinâmica do Praxis.
+ *
+ * ## Responsabilidades Principais
+ *
+ * - Gerenciar metadata do componente através de signals
+ * - Integrar com Angular Reactive Forms
+ * - Fornecer controles de foco e blur
+ * - Implementar lifecycle hooks customizados
+ * - Manter identificação única do componente
+ *
+ * ## Implementação
+ *
+ * Componentes podem implementar esta interface diretamente ou herdar de:
+ * - SimpleBaseInputComponent (para campos de entrada)
+ * - SimpleBaseButtonComponent (para ações/botões)
+ */
+interface BaseDynamicFieldComponent {
+    /**
+     * Metadata do componente que define sua configuração e comportamento.
+     *
+     * Contém informações como label, tipo de controle, validações,
+     * propriedades visuais e outras configurações específicas.
+     */
+    readonly metadata: WritableSignal<ComponentMetadata | null>;
+    /**
+     * ID único do componente para identificação e debugging.
+     *
+     * Gerado automaticamente durante a inicialização e usado
+     * para logging, testes e identificação em runtime.
+     */
+    readonly componentId: WritableSignal<string>;
+    /**
+     * FormControl associado ao componente para integração com Angular Reactive Forms.
+     *
+     * Opcional porque nem todos os componentes precisam de FormControl
+     * (ex: botões, labels, componentes de exibição).
+     */
+    readonly formControl?: WritableSignal<AbstractControl | null>;
+    /**
+     * Label textual exibido para o usuário, quando aplicável.
+     *
+     * Útil para componentes que apresentam uma descrição direta do campo
+     * como inputs e seletores. Implementação opcional.
+     */
+    label?: string;
+    /**
+     * Observable de eventos de lifecycle do componente.
+     *
+     * Permite monitorar o ciclo de vida do componente externamente
+     * para debugging, analytics ou integração com outros sistemas.
+     */
+    readonly lifecycleEvents$?: Observable<ComponentLifecycleEvent | null>;
+    /**
+     * Foca no elemento principal do componente.
+     *
+     * Deve focar no input, botão ou elemento interativo principal.
+     * Implementação deve ser robusta e não falhar se elemento não existir.
+     */
+    focus(): void;
+    /**
+     * Remove o foco do elemento principal do componente.
+     *
+     * Útil para controle programático de foco e navegação por teclado.
+     */
+    blur(): void;
+    /**
+     * Define os metadados de entrada do componente.
+     *
+     * Permite que o componente ajuste propriedades derivadas (como label
+     * e placeholders) antes da configuração padrão.
+     *
+     * @param metadata Metadados do campo
+     */
+    setInputMetadata?(metadata: ComponentMetadata): void;
+    /**
+     * Injeta um FormControl externo a ser utilizado como fonte de verdade.
+     *
+     * Componentes que recebem este controle devem utilizá-lo diretamente,
+     * sem sincronizações manuais com controles internos.
+     */
+    setExternalControl?(control: AbstractControl): void;
+    /**
+     * Hook chamado após a inicialização completa do componente.
+     *
+     * Executado depois que metadata e formControl foram configurados.
+     * Ideal para configurações específicas do componente.
+     */
+    onComponentInit?(): void;
+    /**
+     * Hook chamado antes da destruição do componente.
+     *
+     * Usado para limpeza de recursos, cancelamento de subscriptions,
+     * ou salvamento de estado.
+     */
+    onComponentDestroy?(): void;
+    /**
+     * Define o valor do campo programaticamente.
+     *
+     * Implementação opcional para componentes que gerenciam valores.
+     * Deve atualizar tanto o FormControl quanto o estado interno.
+     */
+    setValue?(value: any, options?: ValueChangeOptions): void;
+    /**
+     * Obtém o valor atual do campo.
+     *
+     * @returns Valor atual ou null se não aplicável
+     */
+    getValue?(): any;
+    /**
+     * Marca o componente como tocado (touched).
+     *
+     * Usado para controle de validação e exibição de mensagens de erro.
+     */
+    markAsTouched?(): void;
+    /**
+     * Marca o componente como modificado (dirty).
+     *
+     * Indica que o valor foi alterado pelo usuário.
+     */
+    markAsDirty?(): void;
+    /**
+     * Define o estado de loading do componente.
+     *
+     * Útil para botões e componentes que executam ações assíncronas.
+     */
+    setLoading?(loading: boolean): void;
+    /**
+     * Define o estado de desabilitado do componente.
+     */
+    setDisabled?(disabled: boolean): void;
+    /**
+     * Força a validação do componente.
+     *
+     * @returns Promise com erros de validação ou null se válido
+     */
+    validateField?(): Promise<any>;
+    /**
+     * Reseta o componente para seu estado inicial.
+     */
+    resetField?(): void;
+}
+/**
+ * Type guard para verificar se um objeto implementa BaseDynamicFieldComponent
+ */
+declare function isBaseDynamicFieldComponent(obj: any): obj is BaseDynamicFieldComponent;
+/**
+ * Type guard para verificar se componente suporta valores (tem FormControl)
+ */
+declare function isValueBasedComponent(component: BaseDynamicFieldComponent): component is BaseDynamicFieldComponent & {
+    formControl: WritableSignal<AbstractControl | null>;
+};
+/**
+ * Type guard para verificar se componente suporta loading
+ */
+declare function isLoadingCapableComponent(component: BaseDynamicFieldComponent): component is BaseDynamicFieldComponent & {
+    setLoading: (loading: boolean) => void;
+};
+
+interface BasicComponentState {
+    initialized: boolean;
+    focused: boolean;
+    disabled: boolean;
+    touched: boolean;
+    dirty: boolean;
+}
+interface BasicFieldState {
+    value: any;
+    valid: boolean;
+    errors: ValidationErrors | null;
+}
+interface BaseValidationConfig {
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string | RegExp;
+    customValidator?: (value: any) => string | null;
+    messages?: {
+        required?: string;
+        minlength?: string;
+        maxlength?: string;
+        pattern?: string;
+        min?: string;
+        max?: string;
+        email?: string;
+        url?: string;
+        matchField?: string;
+        unique?: string;
+        requiredTrue?: string;
+        fileType?: string;
+        maxFileSize?: string;
+        minWords?: string;
+        conditionalValidation?: string;
+        custom?: string;
+    };
+    validateOnBlur?: boolean;
+    debounceTime?: number;
+}
+type LogLevel$1 = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+declare abstract class SimpleBaseInputComponent implements ControlValueAccessor, OnInit, OnDestroy, AfterViewInit, BaseDynamicFieldComponent {
+    protected readonly destroyRef: DestroyRef;
+    protected readonly elementRef: ElementRef<any>;
+    protected readonly cdr: ChangeDetectorRef;
+    private readonly injector;
+    private resolvedNgControl;
+    /** Subject para eventos de lifecycle */
+    readonly lifecycleEvents$: BehaviorSubject<ComponentLifecycleEvent | null>;
+    /** Native element registered by subclasses */
+    protected nativeElement: HTMLElement | null;
+    protected getNgControl(): NgControl | null;
+    /** Metadata do componente */
+    readonly metadata: _angular_core.WritableSignal<ComponentMetadata | null>;
+    /** Estado básico do componente */
+    protected readonly componentState: _angular_core.WritableSignal<BasicComponentState>;
+    /** Estado básico do campo */
+    protected readonly fieldState: _angular_core.WritableSignal<BasicFieldState>;
+    /** ID único do componente */
+    readonly componentId: _angular_core.WritableSignal<string>;
+    /** Rótulo visível do campo */
+    label?: string;
+    /** Placeholder opcional */
+    placeholder?: string;
+    /** Indica se o placeholder deve ser exibido */
+    get shouldShowPlaceholder(): boolean;
+    readonly internalControl: FormControl<any>;
+    /** FormControl signal para interface BaseDynamicFieldComponent */
+    readonly formControl: _angular_core.WritableSignal<FormControl<any> | null>;
+    /**
+     * Define um FormControl externo a ser utilizado como fonte de verdade.
+     */
+    setExternalControl(control: AbstractControl): void;
+    /**
+     * Retorna o FormControl em uso pelo componente.
+     *
+     * Quando um controle externo é fornecido, ele tem precedência;
+     * caso contrário, o controle interno é utilizado.
+     */
+    control(): FormControl;
+    protected onChange: (_value: any) => void;
+    private onTouched;
+    private syncInProgress;
+    readonly valueChange: _angular_core.OutputEmitterRef<any>;
+    readonly focusChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly nativeBlur: _angular_core.OutputEmitterRef<FocusEvent>;
+    readonly nativeChange: _angular_core.OutputEmitterRef<Event>;
+    /** Configuração de validação baseada no metadata */
+    protected readonly validationConfig: _angular_core.Signal<BaseValidationConfig | null>;
+    /** Mensagem de erro atual */
+    readonly errorMessage: _angular_core.Signal<any>;
+    /** Posição/configuração de erro vinda do metadata */
+    readonly errorPosition: _angular_core.Signal<"bottom" | "top" | "tooltip">;
+    /** Se deve exibir erros inline (mat-error) */
+    readonly showInlineErrors: _angular_core.Signal<boolean>;
+    /** Tooltip habilitado quando errorPosition === 'tooltip' */
+    readonly tooltipEnabled: _angular_core.Signal<boolean>;
+    /** Posição do tooltip mapeada para Angular Material */
+    readonly tooltipPosition: _angular_core.Signal<"above" | "below">;
+    /** Gate to control when inline errors may display (debounced for 'change') */
+    private readonly errorDisplayReady;
+    private errorDebounceHandle;
+    /** Verifica se há erro de validação (respeita validationTrigger/debounce) */
+    readonly hasValidationError: _angular_core.Signal<boolean>;
+    /** CSS classes básicas do componente */
+    readonly baseCssClasses: _angular_core.Signal<string[]>;
+    /** CSS classes completas do componente (extensível por subclasses) */
+    readonly componentCssClasses: _angular_core.Signal<string>;
+    /** Tipo de input */
+    readonly inputType: _angular_core.Signal<any>;
+    /** Aparência Material */
+    readonly materialAppearance: _angular_core.Signal<any>;
+    /** Cor Material */
+    readonly materialColor: _angular_core.Signal<any>;
+    /** Comportamento do float label (auto | always) */
+    readonly floatLabelBehavior: _angular_core.Signal<"auto" | "always">;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleInput(event: Event): void;
+    handleFocus(): void;
+    handleBlur(): void;
+    /**
+     * Retorna a paleta Material quando a cor for 'primary' | 'accent' | 'warn'.
+     * Caso contrário, retorna undefined para não aplicar [color].
+     */
+    iconPalette(c?: string): 'primary' | 'accent' | 'warn' | undefined;
+    /**
+     * Retorna a cor customizada (CSS) quando não for paleta Material.
+     * Quando a cor for paleta, retorna null para não conflitar com [color].
+     */
+    iconCustomColor(c?: string): string | null;
+    /**
+     * Define o valor do campo (implementação da interface BaseDynamicFieldComponent)
+     */
+    setValue(value: any, options?: ValueChangeOptions): void;
+    /**
+     * Obtém o valor do campo
+     */
+    getValue(): any;
+    /**
+     * Marca o campo como tocado
+     */
+    markAsTouched(): void;
+    /**
+     * Marca o campo como sujo
+     */
+    markAsDirty(): void;
+    /**
+     * Foca no elemento
+     */
+    focus(): void;
+    /**
+     * Remove foco do elemento
+     */
+    blur(): void;
+    /**
+     * Define metadata do componente
+     */
+    protected setMetadata(metadata: ComponentMetadata): void;
+    /** Registra elemento nativo e aplica atributos/eventos */
+    protected registerInputElement(el: HTMLElement): void;
+    /** Aplica atributos e ARIA com base no metadata */
+    protected applyNativeAttributes(): void;
+    /** Vincula handlers nativos de eventos */
+    private attachNativeEventHandlers;
+    /**
+     * Força validação do campo
+     */
+    validateField(): Promise<ValidationErrors | null>;
+    /**
+     * Hook chamado após inicialização - implementação da interface BaseDynamicFieldComponent
+     * Subclasses podem override para implementar comportamento específico
+     */
+    onComponentInit?(): void;
+    /**
+     * Hook chamado antes da destruição - implementação da interface BaseDynamicFieldComponent
+     * Subclasses podem override para limpeza específica
+     */
+    onComponentDestroy?(): void;
+    /**
+     * Define estado de loading - implementação da interface BaseDynamicFieldComponent
+     */
+    setLoading?(loading: boolean): void;
+    /**
+     * Define estado desabilitado - implementação da interface BaseDynamicFieldComponent
+     */
+    setDisabled?(disabled: boolean): void;
+    /**
+     * Reset do campo - implementação da interface BaseDynamicFieldComponent
+     */
+    resetField?(): void;
+    /**
+     * Retorna classes CSS específicas da subclasse
+     * Subclasses devem implementar este método para adicionar suas próprias classes
+     */
+    protected getSpecificCssClasses(): string[];
+    private setupFormControlIntegration;
+    private refreshErrorTooltip;
+    private setupValidators;
+    private applyValidators;
+    private createCustomValidator;
+    private generateUniqueId;
+    private getTransformApply;
+    private getTransformName;
+    private getValidationTrigger;
+    private getValidationDebounce;
+    private applyErrorDebounceOnChange;
+    private applyTransformOnBlur;
+    private restoreRawValueForEditing;
+    private applyFunctionalDisplayTransformImmediately;
+    /**
+     * Sistema de logging básico
+     */
+    protected log(level: LogLevel$1, message: string, data?: any): void;
+    private emitLifecycleEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SimpleBaseInputComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SimpleBaseInputComponent, never, never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "valueChange": "valueChange"; "focusChange": "focusChange"; "nativeBlur": "nativeBlur"; "nativeChange": "nativeChange"; }, never, never, true, never>;
+}
+
+interface BasicButtonState {
+    initialized: boolean;
+    loading: boolean;
+    disabled: boolean;
+    focused: boolean;
+    clicked: boolean;
+    error: Error | null;
+}
+interface ButtonAction {
+    type: 'navigation' | 'external-link' | 'custom' | 'form-action';
+    target?: string;
+    payload?: any;
+    confirmation?: {
+        title: string;
+        message: string;
+        confirmLabel?: string;
+        cancelLabel?: string;
+    };
+}
+type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+declare abstract class SimpleBaseButtonComponent implements OnInit, OnDestroy, BaseDynamicFieldComponent {
+    protected readonly destroyRef: DestroyRef;
+    protected readonly elementRef: ElementRef<any>;
+    protected readonly cdr: ChangeDetectorRef;
+    protected readonly router: Router;
+    protected readonly dialog: MatDialog;
+    /** Subject para eventos de lifecycle */
+    readonly lifecycleEvents$: BehaviorSubject<ComponentLifecycleEvent | null>;
+    /** Metadata do componente */
+    readonly metadata: _angular_core.WritableSignal<ComponentMetadata | null>;
+    /** Estado básico do botão */
+    protected readonly buttonState: _angular_core.WritableSignal<BasicButtonState>;
+    /** Ação configurada para o botão */
+    protected readonly buttonAction: _angular_core.WritableSignal<ButtonAction | null>;
+    /** Métricas de clique */
+    private readonly clickMetrics;
+    /** ID único do componente */
+    readonly componentId: _angular_core.WritableSignal<string>;
+    readonly actionExecuted: _angular_core.OutputEmitterRef<any>;
+    readonly click: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly focusChange: _angular_core.OutputEmitterRef<boolean>;
+    /** CSS classes básicas do botão */
+    readonly baseButtonCssClasses: _angular_core.Signal<string[]>;
+    /** CSS classes completas do botão (extensível por subclasses) */
+    readonly componentCssClasses: _angular_core.Signal<string>;
+    /** Tipo de botão Material */
+    readonly buttonType: _angular_core.Signal<any>;
+    /** Aparência Material */
+    readonly materialAppearance: _angular_core.Signal<any>;
+    /** Cor Material */
+    readonly materialColor: _angular_core.Signal<any>;
+    /** Se o botão está desabilitado */
+    readonly isDisabled: _angular_core.Signal<any>;
+    /** Se o botão está em loading */
+    readonly isLoading: _angular_core.Signal<any>;
+    /** Texto a ser exibido no botão */
+    readonly buttonText: _angular_core.Signal<any>;
+    /** Ícone a ser exibido */
+    readonly buttonIcon: _angular_core.Signal<any>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    handleClick(event: MouseEvent): Promise<void>;
+    handleFocus(): void;
+    handleBlur(): void;
+    /**
+     * Define loading state
+     */
+    setLoading(loading: boolean): void;
+    /**
+     * Define disabled state
+     */
+    setDisabled(disabled: boolean): void;
+    /**
+     * Executa ação programaticamente
+     */
+    triggerAction(): Promise<void>;
+    /**
+     * Foca no botão
+     */
+    focus(): void;
+    /**
+     * Remove foco do botão
+     */
+    blur(): void;
+    /**
+     * Define metadata do componente
+     */
+    protected setMetadata(metadata: ComponentMetadata): void;
+    /**
+     * Retorna classes CSS específicas da subclasse
+     */
+    protected getSpecificCssClasses(): string[];
+    /**
+     * Hook chamado após inicialização - implementação da interface BaseDynamicFieldComponent
+     * Subclasses podem override para implementar comportamento específico
+     */
+    onComponentInit?(): void;
+    /**
+     * Hook chamado antes da destruição - implementação da interface BaseDynamicFieldComponent
+     * Subclasses podem override para limpeza específica
+     */
+    onComponentDestroy?(): void;
+    /**
+     * Hook chamado antes da execução de ação - para subclasses implementarem
+     */
+    protected onBeforeAction(action: ButtonAction): Promise<boolean>;
+    /**
+     * Hook chamado após execução de ação - para subclasses implementarem
+     */
+    protected onAfterAction(action: ButtonAction, result: any): Promise<void>;
+    private initializeButtonAction;
+    private executeAction;
+    private showConfirmation;
+    private executeCustomAction;
+    private executeFormAction;
+    private shouldAllowClick;
+    private updateClickMetrics;
+    private handleError;
+    private generateUniqueId;
+    /**
+     * Sistema de logging básico
+     */
+    protected log(level: LogLevel, message: string, data?: any): void;
+    /**
+     * Emite evento de lifecycle
+     */
+    private emitLifecycleEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SimpleBaseButtonComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SimpleBaseButtonComponent, never, never, {}, { "actionExecuted": "actionExecuted"; "click": "click"; "focusChange": "focusChange"; }, never, never, true, never>;
+}
+
+/**
+ * Generic option definition for select components.
+ */
+interface SelectOption<T = any> {
+    /** Display label for the option */
+    label: string;
+    /** Value associated with the option */
+    value: T;
+    /** Whether the option is disabled */
+    disabled?: boolean;
+}
+/**
+ * Metadata configuration for simple select components.
+ */
+interface SimpleSelectMetadata<T = any> extends ComponentMetadata {
+    /** Available options */
+    options?: SelectOption<T>[];
+    /** Allow multiple selections */
+    multiple?: boolean;
+    /** Whether search input should be displayed */
+    searchable?: boolean;
+    /** Show select all option */
+    selectAll?: boolean;
+    /** Maximum number of selections allowed */
+    maxSelections?: number;
+    /**
+     * When to load remote options (for async selects)
+     * - 'open' (default): first fetch happens when the select is opened
+     * - 'init': first fetch happens on component initialization
+     * - 'none': do not auto-load; consumer must call retry()/loadMore()
+     */
+    loadOn?: 'open' | 'init' | 'none';
+    /** Backend resource for dynamic options */
+    resourcePath?: string;
+    /** Additional filter criteria for backend requests */
+    filterCriteria?: Record<string, any>;
+    /** Key for option label when loading from backend */
+    optionLabelKey?: string;
+    /** Key for option value when loading from backend */
+    optionValueKey?: string;
+    /** Placeholder option text when no value is selected */
+    emptyOptionText?: string;
+    /** Function to display option values */
+    displayWith?: (value: any) => string;
+    /** Custom compareWith for MatSelect */
+    compareWith?: (a: any, b: any) => boolean;
+}
+/**
+ * Base directive providing common select behaviour. Extends
+ * `SimpleBaseInputComponent` and manages option handling, multiple
+ * selection, selection change events and helper utilities used by the
+ * concrete Material components.
+ */
+declare abstract class SimpleBaseSelectComponent<T = any> extends SimpleBaseInputComponent {
+    protected readonly matSelectRef: _angular_core.Signal<MatSelect | undefined>;
+    /** Available options */
+    readonly options: _angular_core.WritableSignal<SelectOption<T>[]>;
+    /** Whether multiple selection is enabled */
+    readonly multiple: _angular_core.WritableSignal<boolean>;
+    /** Whether the component should allow searching */
+    readonly searchable: _angular_core.WritableSignal<boolean>;
+    /** Current search term when `searchable` is enabled */
+    readonly searchTerm: _angular_core.WritableSignal<string>;
+    /** Emits whenever the search term changes */
+    readonly searchTermChange: _angular_core.OutputEmitterRef<string>;
+    /** Whether a "select all" helper should be displayed */
+    readonly selectAll: _angular_core.WritableSignal<boolean>;
+    /** Maximum number of selections allowed (only applies when multiple=true) */
+    readonly maxSelections: _angular_core.WritableSignal<number | null>;
+    /** Backend resource path for dynamic option loading */
+    readonly resourcePath: _angular_core.WritableSignal<string | null>;
+    /** Criteria applied to backend filtering */
+    readonly filterCriteria: _angular_core.WritableSignal<Record<string, any>>;
+    /** Field used for option labels when loading from backend */
+    readonly optionLabelKey: _angular_core.WritableSignal<string>;
+    /** Field used for option values when loading from backend */
+    readonly optionValueKey: _angular_core.WritableSignal<string>;
+    /** Text displayed for an empty option */
+    readonly emptyOptionText: _angular_core.WritableSignal<string | null>;
+    /** Current page index when fetching remote options */
+    readonly pageIndex: _angular_core.WritableSignal<number>;
+    /** Number of options retrieved per request */
+    readonly pageSize: _angular_core.WritableSignal<number>;
+    /** Indicates options are being loaded from backend */
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    /** Holds error message when option loading fails */
+    readonly error: _angular_core.WritableSignal<string | null>;
+    private readonly matSelectInitEffect;
+    /** CRUD service for remote option loading (optional) */
+    protected readonly crudService: GenericCrudService<any> | null;
+    /** Emits whenever the selected value(s) change */
+    readonly selectionChange: _angular_core.OutputEmitterRef<T | T[]>;
+    /** Emits whenever a specific option is selected */
+    readonly optionSelected: _angular_core.OutputEmitterRef<SelectOption<T>>;
+    /** Emits whenever options are loaded remotely */
+    readonly optionsLoaded: _angular_core.OutputEmitterRef<SelectOption<T>[]>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    protected matSelect: MatSelect | null;
+    protected readonly global: GlobalConfigService;
+    private dependencySub;
+    private hasLoadedOnce;
+    /** Options filtered according to the current `searchTerm` */
+    readonly filteredOptions: _angular_core.Signal<SelectOption<T>[]>;
+    /**
+     * Applies typed metadata to the select component.
+     */
+    setSelectMetadata(metadata: SimpleSelectMetadata<T>): void;
+    protected setMetadata(metadata: ComponentMetadata): void;
+    protected registerMatSelect(select: MatSelect): void;
+    protected applySelectAttributes(): void;
+    /** Whether to show the clear button (if enabled in metadata) */
+    showClear(): boolean;
+    /** Clears the selection according to single/multiple mode */
+    onClearClick(): void;
+    /**
+     * Updates the current search term and emits the change event.
+     */
+    onSearch(term: string): void;
+    /**
+     * Applies metadata after the component is initialized by the
+     * DynamicFieldLoader, ensuring options and remote configuration are
+     * processed when using the component declaratively.
+     */
+    onComponentInit(): void;
+    /**
+     * Selects the given option. Handles both single and multiple selection
+     * modes and emits the proper events.
+     */
+    selectOption(option: SelectOption<T>): void;
+    /** Checks if the provided value is currently selected */
+    isSelected(value: T): boolean;
+    /**
+     * Toggles selection of all options when `selectAll` is enabled in multiple
+     * selection mode.
+     */
+    toggleSelectAll(): void;
+    /** Checks whether all options are currently selected */
+    isAllSelected(): boolean;
+    /** TrackBy function to optimize ngFor over options */
+    trackByOption(index: number, option: SelectOption<T>): T;
+    /** Adds CSS class hook for select components */
+    protected getSpecificCssClasses(): string[];
+    /** Configures the CRUD service with the given resource path */
+    protected configureCrudService(path: string): void;
+    /**
+     * Loads schema metadata to infer label/value keys when not provided.
+     * After resolving the keys, options are fetched from the backend.
+     */
+    protected loadSchema(resolveLabel: boolean, resolveValue: boolean): void;
+    /** Loads options from backend using GenericCrudService */
+    protected loadOptions(page?: number, searchTerm?: string, criteria?: Record<string, any>): void;
+    /** Dev-only warning when legacy alias keys are used instead of canonical ones */
+    protected devWarnSelectAliases(meta: any, component?: string): void;
+    /** Public API to reload options; overridden by async/searchable variants */
+    reload(reset: boolean): void;
+    /** Marks that at least one successful load has happened */
+    protected markLoadedOnce(): void;
+    protected hasLoaded(): boolean;
+    /** Setup effect to re-bind dependency observers when FormControl changes */
+    private readonly _depEffect;
+    /** (Re)configure dependency observers based on metadata and current FormGroup */
+    protected setupDependencies(): void;
+    protected extractDependencyValue(raw: any, path?: string): any;
+    protected applyDependencyCriteria(fragment: Record<string, any>, strategy?: 'merge' | 'replace'): void;
+    protected onDependenciesChanged(): void;
+    private getByPath;
+    private setByPath;
+    private unsetByPath;
+    private mergeObjectsDeep;
+    private replaceMappedKeys;
+    private clone;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SimpleBaseSelectComponent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SimpleBaseSelectComponent<any>, never, never, {}, { "searchTermChange": "searchTermChange"; "selectionChange": "selectionChange"; "optionSelected": "optionSelected"; "optionsLoaded": "optionsLoaded"; "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+type OptionSource = 'byId' | 'page';
+declare class OptionStore<ID = string | number> {
+    private readonly map;
+    private readonly order;
+    readonly loadedPages: Set<number>;
+    upsertById(option: OptionDTO<ID>, ephemeral?: boolean): void;
+    addPage(pageIndex: number, page: OptionDTO<ID>[]): void;
+    ensureVisible(ids: ID[]): void;
+    clearPages(): void;
+    get items(): OptionDTO<ID>[];
+}
+
+/**
+ * @fileoverview Diretiva para renderização dinâmica de campos de formulário
+ *
+ * Renderiza campos de formulário dinamicamente com base em metadados,
+ * integrando com ComponentRegistryService para resolver tipos de componentes
+ * e associando automaticamente com FormGroup controls.
+ *
+ * @example Uso básico
+ * ```html
+ * <ng-container
+ *   dynamicFieldLoader
+ *   [fields]="fieldMetadata"
+ *   [formGroup]="userForm"
+ *   (componentsCreated)="onComponentsReady($event)">
+ * </ng-container>
+ * ```
+ *
+ * @example Uso avançado com template personalizado
+ * ```html
+ * <div class="dynamic-form-container">
+ *   <ng-container
+ *     dynamicFieldLoader
+ *     [fields]="complexFields"
+ *     [formGroup]="complexForm"
+ *     (componentsCreated)="handleComponents($event)">
+ *   </ng-container>
+ * </div>
+ * ```
+ *
+ * Concurrency & Stability
+ * - The directive may receive rapid, back-to-back input changes (e.g. initial
+ *   binding triggers ngOnChanges followed immediately by ngOnInit). Because
+ *   component resolution is async, naive implementations can interleave two
+ *   render cycles, causing duplicated shells/components. To avoid this, the
+ *   render pipeline is serialized with a lightweight reentrancy guard
+ *   (isRendering + pendingRender), coalescing intermediate requests into a
+ *   single subsequent pass.
+ * - All component/shell references and subscriptions are tracked and disposed
+ *   deterministically to prevent memory leaks.
+ */
+
+/**
+ * Diretiva que renderiza campos de formulário dinamicamente baseado em metadados.
+ *
+ * Integra-se com ComponentRegistryService para resolver componentes por tipo,
+ * associa automaticamente FormControls e emite referências dos componentes criados.
+ *
+ * ## 🏗️ Funcionalidades Principais
+ *
+ * - ✅ Renderização dinâmica baseada em FieldMetadata[]
+ * - ✅ Integração automática com Angular Reactive Forms
+ * - ✅ Resolução de componentes via ComponentRegistryService
+ * - ✅ Validação robusta de inputs
+ * - ✅ Emissão de ComponentRef para controle externo
+ * - ✅ Lifecycle management completo
+ * - ✅ Detecção automática de mudanças
+ *
+ * ## 🎯 Casos de Uso
+ *
+ * - Formulários dinâmicos baseados em configuração JSON
+ * - Admin panels com campos configuráveis
+ * - Workflows com etapas dinâmicas
+ * - Formulários gerados por API/backend
+ * - A/B testing de interfaces de formulário
+ *
+ * @selector [dynamicFieldLoader]
+ * @usageNotes
+ * - Sempre fornecer tanto fields quanto formGroup
+ * - FormGroup deve ter controls correspondentes aos field names
+ * - Usar ViewChild para capturar referências se necessário
+ * - Componentes são criados de forma lazy (apenas quando necessário)
+ */
+declare class DynamicFieldLoaderDirective implements OnInit, OnDestroy, OnChanges {
+    private readonly viewContainer;
+    private readonly componentRegistry;
+    private readonly cdr;
+    /**
+     * Metadados dos campos a serem renderizados.
+     *
+     * Array de objetos FieldMetadata que define a estrutura,
+     * validação e comportamento de cada campo do formulário.
+     *
+     * @example
+     * ```typescript
+     * const fields: FieldMetadata[] = [
+     *   {
+     *     name: 'email',
+     *     label: 'Email',
+     *     controlType: 'input',
+     *     required: true,
+     *     validators: { email: true }
+     *   },
+     *   {
+     *     name: 'password',
+     *     label: 'Senha',
+     *     controlType: 'input',
+     *     inputType: 'password',
+     *     required: true
+     *   }
+     * ];
+     * ```
+     */
+    fields: FieldMetadata[];
+    /**
+     * FormGroup que gerencia os controles dos campos.
+     *
+     * Deve conter AbstractControl para cada campo definido no array fields.
+     * A diretiva associa automaticamente cada componente ao control correspondente.
+     *
+     * @example
+     * ```typescript
+     * const formGroup = this.fb.group({
+     *   email: ['', [Validators.required, Validators.email]],
+     *   password: ['', [Validators.required, Validators.minLength(8)]]
+     * });
+     * ```
+     */
+    formGroup: FormGroup | null;
+    /**
+     * Controla se a diretiva deve injetar o AbstractControl externo
+     * diretamente no componente via setExternalControl(control).
+     *
+     * Quando false (padrão), a diretiva apenas atribui o control ao signal
+     * formControl, caso o componente o exponha, evitando acoplamento.
+     */
+    enableExternalControlBinding: boolean;
+    /**
+     * Template opcional para embrulhar cada campo renderizado.
+     *
+     * O contexto fornece:
+     * - `field`: metadata do campo
+     * - `index`: posição do campo na lista
+     * - `content`: `TemplateRef` com o conteúdo do campo a ser projetado
+     *
+     * @example
+     * ```html
+    * <ng-template #fieldItem let-field="field" let-index="index" let-content="content">
+    *   <div class="field-wrapper">
+    *     <ng-container [ngTemplateOutlet]="content"></ng-container>
+    *   </div>
+    * </ng-template>
+     *
+     * <ng-container
+     *   dynamicFieldLoader
+     *   [fields]="fields"
+     *   [formGroup]="form"
+     *   [itemTemplate]="fieldItem">
+     * </ng-container>
+     * ```
+     *
+    * O `itemTemplate` permite projetar elementos adicionais ao redor do conteúdo
+    * do campo. Não há suporte a arraste no `FieldShellComponent`.
+    */
+    itemTemplate?: TemplateRef<{
+        field: FieldMetadata;
+        index: number;
+        content: TemplateRef<any>;
+    }>;
+    /**
+     * Estados globais opcionais aplicados a todos os campos renderizados.
+     *
+     * Quando definidos, não substituem explicitamente metadados a menos que
+     * seja necessário (ex.: readonlyMode/presentationMode = true, visible = false,
+     * disabledMode = true). Quando não definidos (null), prevalecem metadados.
+     */
+    readonlyMode: boolean | null;
+    disabledMode: boolean | null;
+    presentationMode: boolean | null;
+    visible: boolean | null;
+    /** @internal Special input for canvas mode integration */
+    canvasMode: boolean;
+    /**
+     * Emite um mapa com as referências dos componentes criados.
+     *
+     * Indexado pelo nome do campo (FieldMetadata.name).
+     * Útil para controle externo, validação customizada ou manipulação direta.
+     *
+     * @example
+     * ```typescript
+     * onComponentsCreated(components: Map<string, ComponentRef<BaseDynamicFieldComponent>>) {
+     *   // Acessar componente específico
+     *   const emailComponent = components.get('email');
+     *   if (emailComponent) {
+     *     emailComponent.instance.focus();
+     *   }
+     *
+     *   // Iterar todos os componentes
+     *   components.forEach((componentRef, fieldName) => {
+     *     console.log(`Campo ${fieldName} criado:`, componentRef.instance);
+     *   });
+     * }
+     * ```
+     */
+    componentsCreated: EventEmitter<Map<string, ComponentRef<BaseDynamicFieldComponent>>>;
+    /** Evento emitido após a criação individual de um campo */
+    fieldCreated: EventEmitter<{
+        field: FieldMetadata;
+        componentRef: ComponentRef<any>;
+        index: number;
+    }>;
+    /** Evento emitido quando um campo é destruído */
+    fieldDestroyed: EventEmitter<{
+        fieldName: string;
+    }>;
+    /** @internal Emits when a field is hovered in canvas mode */
+    canvasMouseEnter: EventEmitter<{
+        field: FieldMetadata;
+        element: HTMLElement;
+    }>;
+    /** @internal Emits when a field is no longer hovered in canvas mode */
+    canvasMouseLeave: EventEmitter<{
+        field: FieldMetadata;
+        element: HTMLElement;
+    }>;
+    /** @internal Emits when a field is clicked in canvas mode */
+    canvasClick: EventEmitter<{
+        field: FieldMetadata;
+        element: HTMLElement;
+    }>;
+    /** Mapa interno de componentes criados */
+    private componentRefs;
+    /** Mapa de shells criados */
+    private shellRefs;
+    /** Subscription manager for shell events */
+    private shellSubscriptions;
+    /** Ordem atual dos nomes de campo renderizados */
+    private currentOrder;
+    /** Snapshot compacto para detectar mudanças relevantes nos campos (tipo + flags principais) */
+    private lastFieldsSnapshot;
+    /** First-render guard to ignore transient input changes */
+    /** Serialize async renders to avoid duplicate creations on rapid changes */
+    private isRendering;
+    private pendingRender;
+    private _dbgPrevFieldsRef;
+    private _dbgPrevFormGroupRef;
+    private _dbgNgChangesCount;
+    private _dbgRenderCalls;
+    private debugEnabled;
+    /** Tracks whether at least one successful render has completed */
+    private hasRenderedOnce;
+    private dbg;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /**
+     * Re-renderiza todos os campos forçadamente.
+     *
+     * Útil quando metadata ou FormGroup foram alterados externamente
+     * e a detecção automática de mudanças não foi suficiente.
+     *
+     * @example
+     * ```typescript
+     * @ViewChild(DynamicFieldLoaderDirective)
+     * fieldLoader!: DynamicFieldLoaderDirective;
+     *
+     * updateFieldsExternally() {
+     *   // Modificar fields ou formGroup externamente
+     *   this.fields[0].disabled = true;
+     *
+     *   // Forçar re-renderização
+     *   this.fieldLoader.refresh();
+     * }
+     * ```
+     */
+    refresh(): void;
+    /**
+     * Obtém referência de componente específico por nome do campo.
+     *
+     * @param fieldName - Nome do campo conforme FieldMetadata.name
+     * @returns ComponentRef ou undefined se não encontrado
+     *
+     * @example
+     * ```typescript
+     * const emailComponent = this.fieldLoader.getComponent('email');
+     * if (emailComponent) {
+     *   emailComponent.instance.setLoading(true);
+     * }
+     * ```
+     */
+    getComponent(fieldName: string): ComponentRef<BaseDynamicFieldComponent> | undefined;
+    /**
+     * Obtém todos os componentes criados.
+     *
+     * @returns Map com todas as referências de componentes indexadas por nome
+     */
+    getAllComponents(): Map<string, ComponentRef<BaseDynamicFieldComponent>>;
+    /**
+     * Valida as entradas da diretiva antes de processá-las.
+     *
+     * Verifica se inputs obrigatórios estão presentes e válidos,
+     * emite warnings para problemas não-críticos.
+     *
+     * @throws Error se validação crítica falhar
+     */
+    private validateInputs;
+    /**
+     * Carrega os campos dinâmicos no contêiner de visualização.
+     *
+     * Processo completo:
+     * 1. Validar inputs
+     * 2. Limpar componentes existentes
+     * 3. Resolver e criar cada componente
+     * 4. Associar propriedades e FormControl
+     * 5. Emitir mapa de componentes criados
+     */
+    private renderFields;
+    /**
+     * Executa a renderização dos campos com rollback em caso de erro.
+     *
+     * @private
+     */
+    private executeRendering;
+    /** Builds a minimal snapshot capturing changes that matter for re-rendering. */
+    private buildFieldSnapshot;
+    /**
+     * Reatribui apenas os FormControls existentes aos componentes/shells sem refazer a renderização.
+     */
+    private rebindControlsOnly;
+    /** Destroi todos os componentes e limpa o container */
+    private destroyComponents;
+    /** Destroi um único campo pelo nome */
+    private destroySingle;
+    /** Cria o componente de campo dentro de um FieldShell e aplica metadados/controle */
+    private createFieldComponent;
+    /**
+     * Aplica os estados globais aos shells já criados, sem re-render completo.
+     */
+    private applyGlobalStates;
+    /**
+     * Tenta inferir o controlType a partir do próprio field.
+     * Retorna null quando não é possível inferir, mantendo a validação original.
+     */
+    private inferControlTypeFromField;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicFieldLoaderDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DynamicFieldLoaderDirective, "[dynamicFieldLoader]", never, { "fields": { "alias": "fields"; "required": true; }; "formGroup": { "alias": "formGroup"; "required": true; }; "enableExternalControlBinding": { "alias": "enableExternalControlBinding"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "canvasMode": { "alias": "canvasMode"; "required": false; }; }, { "componentsCreated": "componentsCreated"; "fieldCreated": "fieldCreated"; "fieldDestroyed": "fieldDestroyed"; "canvasMouseEnter": "canvasMouseEnter"; "canvasMouseLeave": "canvasMouseLeave"; "canvasClick": "canvasClick"; }, never, never, true, never>;
+}
+
+declare class MaterialButtonComponent extends SimpleBaseButtonComponent implements OnDestroy {
+    private readonly actionResolver;
+    private readonly keyboardService;
+    private unregisterShortcut?;
+    /** Estado adicional específico do Material Button */
+    protected readonly materialButtonState: _angular_core.WritableSignal<{
+        isPressed: boolean;
+        rippleDisabled: boolean;
+    }>;
+    /** Variante do botão Material */
+    readonly buttonVariant: _angular_core.Signal<"basic" | "icon" | "flat" | "raised" | "stroked" | "fab" | "mini-fab">;
+    /** Deve desabilitar ripple */
+    readonly shouldDisableRipple: _angular_core.Signal<boolean>;
+    /** É botão somente ícone */
+    readonly isIconOnlyButton: _angular_core.Signal<boolean>;
+    /** Deve mostrar ícone no texto */
+    readonly shouldShowIcon: _angular_core.Signal<any>;
+    /** Atalho de teclado */
+    readonly keyboardShortcut: _angular_core.Signal<any>;
+    /** Tooltip text */
+    readonly tooltipText: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Classes CSS específicas do Material Button
+     */
+    protected getSpecificCssClasses(): string[];
+    /**
+     * Override do handleClick para adicionar comportamento específico do Material Button
+     */
+    handleClick(event: MouseEvent): Promise<void>;
+    /**
+     * Define metadata específica do Material Button
+     */
+    setButtonMetadata(metadata: MaterialButtonMetadata): void;
+    /**
+     * Alterna estado de ripple
+     */
+    toggleRipple(disabled: boolean): void;
+    /**
+     * Obtém informações do botão
+     */
+    getButtonInfo(): any;
+    private setupKeyboardShortcuts;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialButtonComponent, "pdx-material-button", never, {}, {}, never, never, true, never>;
+}
+
+interface ConfirmDialogData {
+    title: string;
+    message: string;
+    confirmText: string;
+    cancelText: string;
+    type?: 'warning' | 'danger' | 'info';
+    icon?: string;
+}
+declare class ConfirmDialogComponent {
+    dialogRef: MatDialogRef<ConfirmDialogComponent>;
+    data: ConfirmDialogData;
+    constructor(dialogRef: MatDialogRef<ConfirmDialogComponent>, data: ConfirmDialogData);
+    getConfirmButtonColor(): 'primary' | 'accent' | 'warn';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmDialogComponent, "pdx-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class TextInputComponent extends SimpleBaseInputComponent {
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    isReadonlyEffective(): boolean;
+    ngOnInit(): void;
+    onComponentInit(): void;
+    /**
+     * Adiciona classes CSS específicas do text-input
+     */
+    protected getSpecificCssClasses(): string[];
+    /**
+     * Reset do campo
+     */
+    resetField(): void;
+    /**
+     * Força validação do campo (override para emitir evento)
+     */
+    validateField(): Promise<ValidationErrors | null>;
+    /**
+     * Define metadata e aplica configurações
+     */
+    setInputMetadata(metadata: MaterialInputMetadata): void;
+    showClear(): boolean;
+    onClearClick(): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextInputComponent, "pdx-text-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for HTML color inputs.
+ *
+ * Renders a `<mat-form-field>` containing an `<input type="color">` element
+ * with basic validation and hint support. Built on top of the
+ * `SimpleBaseInputComponent` to leverage common functionality such as
+ * reactive forms integration and error handling.
+ */
+declare class ColorInputComponent extends SimpleBaseInputComponent {
+    private nativePickerRef?;
+    private menuTrigger?;
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    palettePreset: 'basic' | 'office' | 'material' | string;
+    paletteColors: string[] | undefined;
+    columns: number;
+    popupWidth: number | string;
+    preview: boolean;
+    showRecent: boolean;
+    maxRecent: number;
+    showNativeOption: boolean;
+    panelWidthPx: number;
+    readonly recent: _angular_core.WritableSignal<string[]>;
+    readonly swatches: _angular_core.Signal<string[]>;
+    constructor();
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialColorInputMetadata): void;
+    /** Programmatically opens the native color picker if supported. */
+    openNativePicker(): void;
+    onNativeColorChange(event: Event): void;
+    previewColor(): string;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    isReadonlyEffective(): boolean;
+    openMenu(): void;
+    onSwatchClick(c: string): void;
+    isSelected(c: string): boolean;
+    copyCurrent(): void;
+    private applyColor;
+    currentSolidHex(): string;
+    private pushRecent;
+    private normalizeHex;
+    private buildPaletteColors;
+    private coerceWidth;
+    private loadFromStorage;
+    private saveToStorage;
+    trackColor(_: number, c: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorInputComponent, "pdx-color-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; "palettePreset": { "alias": "palettePreset"; "required": false; }; "paletteColors": { "alias": "paletteColors"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "popupWidth": { "alias": "popupWidth"; "required": false; }; "preview": { "alias": "preview"; "required": false; }; "showRecent": { "alias": "showRecent"; "required": false; }; "maxRecent": { "alias": "maxRecent"; "required": false; }; "showNativeOption": { "alias": "showNativeOption"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for HTML date inputs.
+ *
+ * Renders a `<mat-form-field>` containing an `<input type="date">` element
+ * with basic validation and hint support. Built on top of the
+ * `SimpleBaseInputComponent` to leverage common functionality such as
+ * reactive forms integration and error handling.
+ */
+declare class DateInputComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    isReadonlyEffective(): boolean;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialDateInputMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateInputComponent, "pdx-date-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized component using Angular Material Datepicker.
+ *
+ * Renders a `<mat-form-field>` with an `<input>` bound to a
+ * `mat-datepicker`. Includes toggle button, hint and error support
+ * following the same pattern used by other dynamic field components.
+ */
+declare class MaterialDatepickerComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    readonly minDate: _angular_core.Signal<any>;
+    readonly maxDate: _angular_core.Signal<any>;
+    readonly startAt: _angular_core.Signal<any>;
+    onDateChange(event: MatDatepickerInputEvent<Date | null>): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setDatepickerMetadata(metadata: MaterialDatepickerMetadata): void;
+    isReadonlyEffective(): boolean;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    showClear(): boolean;
+    onClearClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialDatepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialDatepickerComponent, "pdx-material-datepicker", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized component using Angular Material Date Range picker.
+ *
+ * Renders a `<mat-form-field>` with a `mat-date-range-input` bound to
+ * an internal `FormGroup`. Integrates toggle button, hint and error support
+ * following the same pattern used by other dynamic field components.
+ */
+declare class MaterialDateRangeComponent extends SimpleBaseInputComponent implements OnInit {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    readonly rangeGroup: FormGroup<{
+        start: FormControl<Date | null>;
+        end: FormControl<Date | null>;
+    }>;
+    readonly minDate: _angular_core.Signal<any>;
+    readonly maxDate: _angular_core.Signal<any>;
+    readonly startAt: _angular_core.Signal<any>;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setDateRangeMetadata(metadata: MaterialDateRangeMetadata): void;
+    isReadonlyEffective(): boolean;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialDateRangeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialDateRangeComponent, "pdx-material-date-range", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for HTML datetime-local inputs.
+ *
+ * Renders a `<mat-form-field>` containing an `<input type="datetime-local">`
+ * element with basic validation and hint support.
+ */
+declare class DatetimeLocalInputComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    isReadonlyEffective(): boolean;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialDatetimeLocalInputMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    private datetimeBoundsValidator;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatetimeLocalInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatetimeLocalInputComponent, "pdx-datetime-local-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for HTML email inputs.
+ *
+ * Renders a `<mat-form-field>` containing an `<input type="email">` element
+ * with basic validation and hint support. Built on top of the
+ * `SimpleBaseInputComponent` to leverage common functionality such as
+ * reactive forms integration and error handling.
+ */
+declare class EmailInputComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialEmailInputMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    isReadonlyEffective(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmailInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmailInputComponent, "pdx-email-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Minimal Material Textarea component for isolation/debug
+ */
+
+declare class MaterialTextareaComponent extends SimpleBaseInputComponent implements AfterViewInit {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    charCount: number;
+    isReadonlyEffective(): boolean;
+    protected getSpecificCssClasses(): string[];
+    setInputMetadata(metadata: MaterialTextareaMetadata): void;
+    private viewReady;
+    ngAfterViewInit(): void;
+    autoResizeEnabled(): boolean;
+    private toNumber;
+    getRowsAttr(): number;
+    getMinRowsAttr(): number;
+    getMaxRowsAttr(): number;
+    ngOnInit(): void;
+    showCharacterCount(): boolean;
+    showStats(): boolean;
+    getWords(): number;
+    getLines(): number;
+    isNearLimit(): boolean;
+    isAtOrOverLimit(): boolean;
+    private getMode;
+    isCodeLikeMode(): boolean;
+    effectiveSpellcheck(): boolean | null;
+    effectiveWrap(): string | null;
+    private getCurrentLines;
+    private getLineStart;
+    private outdentAtSelection;
+    private _log;
+    enableTabIndent(): boolean;
+    showClear(): boolean;
+    onClearClick(): void;
+    onFocusLog(): void;
+    onBlurLog(): void;
+    onTextareaKeydown(event: KeyboardEvent): void;
+    private getTabSize;
+    private getTabUnit;
+    onInputLog(_event: Event): void;
+    onPaste(_event: ClipboardEvent): void;
+    onCut(_event: ClipboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialTextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialTextareaComponent, "pdx-material-textarea", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for HTML number inputs.
+ *
+ * Renders a `<mat-form-field>` containing an `<input type="number">` element
+ * with basic validation and hint support. Built on top of the
+ * `SimpleBaseInputComponent` to leverage common functionality such as
+ * reactive forms integration and error handling.
+ */
+declare class NumberInputComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    isReadonlyEffective(): boolean;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialNumericMetadata): void;
+    showClear(): boolean;
+    onClearClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberInputComponent, "pdx-number-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Input component for currency values with basic formatting support.
+ *
+ * Displays a currency symbol as prefix or suffix and validates numeric input.
+ */
+declare class MaterialCurrencyComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    private readonly currencyPipe;
+    private readonly defaultLocale;
+    private readonly inputRef;
+    /** Currency code used for formatting. */
+    readonly currencyCode: _angular_core.Signal<string>;
+    /** Position of the currency symbol relative to the input. */
+    readonly currencyPosition: _angular_core.Signal<"before" | "after">;
+    /** Decimal places used for formatting. */
+    readonly decimalPlaces: _angular_core.Signal<number>;
+    /** Locale used for formatting and parsing. */
+    readonly locale: _angular_core.Signal<string>;
+    /** Thousands separator based on locale or metadata. */
+    readonly thousandsSeparator: _angular_core.Signal<string>;
+    /** Decimal separator based on locale or metadata. */
+    readonly decimalSeparator: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    /** Handles raw input and keeps numeric value in the control. */
+    onInput(event: Event): void;
+    /** Removes formatting when focusing for easier editing. */
+    onFocus(): void;
+    /** Formats the current value using CurrencyPipe on blur. */
+    onBlur(): void;
+    /** Extracts the symbol for the configured currency. */
+    protected currencySymbol(): string;
+    protected getSpecificCssClasses(): string[];
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    private escapeRegex;
+    /** Applies component metadata with strong typing. */
+    set metadataInput(metadata: MaterialCurrencyMetadata);
+    setInputMetadata(metadata: MaterialCurrencyMetadata): void;
+    validateField(): Promise<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    isReadonlyEffective(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialCurrencyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialCurrencyComponent, "pdx-material-currency", never, { "metadataInput": { "alias": "metadata"; "required": true; }; "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+declare class MaterialCpfCnpjInputComponent extends SimpleBaseInputComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    private dynamicValidator;
+    cpfCnpjMetadata: _angular_core.Signal<MaterialCpfCnpjMetadata | null>;
+    getSpecificCssClasses(): string[];
+    setInputMetadata(metadata: MaterialCpfCnpjMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    onComponentInit(): void;
+    private setupDynamicValidator;
+    isReadonlyEffective(): boolean;
+    writeValue(value: any): void;
+    handleInput(event: Event): void;
+    private cleanValue;
+    private formatValue;
+    private applyCpfMask;
+    private applyCnpjMask;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialCpfCnpjInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialCpfCnpjInputComponent, "pdx-material-cpf-cnpj-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Component for selecting a price range using two currency inputs.
+ *
+ * Reuses `MaterialCurrencyComponent` for both the minimum and maximum
+ * values, keeping formatting and validation consistent.
+ */
+declare class MaterialPriceRangeComponent extends SimpleBaseInputComponent implements OnInit {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    readonly rangeGroup: FormGroup<{
+        minPrice: FormControl<number | null>;
+        maxPrice: FormControl<number | null>;
+    }>;
+    readonly startCurrencyMetadata: _angular_core.Signal<MaterialCurrencyMetadata>;
+    readonly endCurrencyMetadata: _angular_core.Signal<MaterialCurrencyMetadata>;
+    /** Custom error messages for range-specific validations */
+    readonly errorMessage: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setPriceRangeMetadata(metadata: MaterialPriceRangeMetadata): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialPriceRangeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialPriceRangeComponent, "pdx-material-price-range", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for HTML month inputs.
+ *
+ * Renders a `<mat-form-field>` containing an `<input type="month">` element
+ * with optional min/max constraints, basic validation and hint support.
+ * Built on top of the `SimpleBaseInputComponent` to reuse core features
+ * like reactive forms integration and error handling.
+ */
+declare class MonthInputComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialMonthInputMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    isReadonlyEffective(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MonthInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MonthInputComponent, "pdx-month-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for password fields.
+ *
+ * Renders a `<mat-form-field>` wrapping an `<input type="password">` element
+ * and leverages `SimpleBaseInputComponent` for common functionality such as
+ * validation, hint display and reactive forms integration.
+ */
+declare class PasswordInputComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies typed metadata to the component. */
+    setInputMetadata(metadata: MaterialPasswordMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    isReadonlyEffective(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PasswordInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PasswordInputComponent, "pdx-password-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for HTML search inputs.
+ *
+ * Renders a `<mat-form-field>` containing an `<input type="search">` element
+ * with Material styling and basic validation support. Built on top of the
+ * `SimpleBaseInputComponent` to leverage common functionality such as reactive
+ * forms integration and error handling.
+ */
+declare class SearchInputComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialSearchInputMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    isReadonlyEffective(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchInputComponent, "pdx-search-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+declare class MaterialSelectComponent extends SimpleBaseSelectComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    setSelectMetadata(metadata: SimpleSelectMetadata<any>): void;
+    ngOnInit(): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialSelectComponent, "pdx-material-select", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialMultiSelectComponent extends SimpleBaseSelectComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    setSelectMetadata(metadata: SimpleSelectMetadata<any>): void;
+    /** Disables options when maxSelections reached */
+    isOptionDisabled(option: SelectOption<any>): boolean;
+    /** Emits optionSelected when a user picks an option */
+    onOptionSelectionChange(option: SelectOption<any>, event: MatOptionSelectionChange): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialMultiSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialMultiSelectComponent, "pdx-material-multi-select", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Material wrapper for hierarchical multi select using `mat-tree`.
+ *
+ * Supports recursive selection with checkboxes and optional
+ * "select all" helper. Values are emitted as array of node values.
+ */
+declare class MaterialMultiSelectTreeComponent extends SimpleBaseInputComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    /** Tree control managing expansion state */
+    readonly treeControl: NestedTreeControl<MaterialTreeNode, MaterialTreeNode>;
+    /** Data source bound to the tree */
+    readonly dataSource: MatTreeNestedDataSource<MaterialTreeNode>;
+    /** Selection model for nodes */
+    readonly selection: SelectionModel<MaterialTreeNode>;
+    private readonly parentMap;
+    private readonly valueMap;
+    /** Show select all option */
+    readonly selectAll: _angular_core.WritableSignal<boolean>;
+    /** Maximum allowed selections */
+    readonly maxSelections: _angular_core.WritableSignal<number | null>;
+    /** Label for select all option */
+    readonly selectAllLabel: _angular_core.WritableSignal<string>;
+    /** Emits whenever the selection changes */
+    readonly selectionChange: EventEmitter<any[]>;
+    onComponentInit(): void;
+    showClear(): boolean;
+    onClearClick(): void;
+    /** Configure component metadata */
+    setTreeMetadata(metadata: MaterialMultiSelectTreeMetadata): void;
+    private normalizeNodes;
+    /** Whether a node has children */
+    hasChild: (_: number, node: MaterialTreeNode) => boolean;
+    /** Toggle selection state of a node and its descendants */
+    toggleNode(node: MaterialTreeNode): void;
+    private toggleDescendants;
+    private updateAllParents;
+    private updateParentSelection;
+    private getDescendants;
+    private getParent;
+    private buildParentMap;
+    /** Whether descendants of a node are partially selected */
+    descendantsPartiallySelected(node: MaterialTreeNode): boolean;
+    private emitValue;
+    writeValue(value: any): void;
+    /** Toggle select all nodes */
+    toggleSelectAll(): void;
+    private selectAllRecursive;
+    /** Check if all enabled nodes are selected */
+    isAllSelected(): boolean;
+    private getAllEnabledNodes;
+    /** Disable node when maxSelections reached */
+    isNodeDisabled(node: MaterialTreeNode): boolean;
+    /** CSS hook */
+    protected getSpecificCssClasses(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialMultiSelectTreeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialMultiSelectTreeComponent, "pdx-material-multi-select-tree", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialTreeSelectComponent extends SimpleBaseSelectComponent {
+    private host;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    readonly treeControl: NestedTreeControl<MaterialTreeNode, MaterialTreeNode>;
+    readonly dataSource: MatTreeNestedDataSource<MaterialTreeNode>;
+    readonly leafOnly: _angular_core.WritableSignal<boolean>;
+    readonly autoExpandOnSearch: _angular_core.WritableSignal<boolean>;
+    readonly returnPath: _angular_core.WritableSignal<boolean>;
+    readonly returnObject: _angular_core.WritableSignal<boolean>;
+    private parentMap;
+    private allNodes;
+    private selectedNode;
+    constructor(host: ElementRef<HTMLElement>);
+    onComponentInit(): void;
+    setTreeMetadata(metadata: MaterialTreeSelectMetadata): void;
+    private normalizeNodes;
+    private buildParentMap;
+    hasChild: (_: number, node: MaterialTreeNode) => boolean;
+    selectNode(node: MaterialTreeNode): void;
+    private resolveValue;
+    private getPath;
+    isSelected(node: MaterialTreeNode): boolean;
+    isNodeDisabled(node: MaterialTreeNode): boolean;
+    handleKeydown(event: KeyboardEvent, node: MaterialTreeNode): void;
+    private focusSiblingNode;
+    private focusNode;
+    private getVisibleNodes;
+    private applyFilter;
+    private filterNodes;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialTreeSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialTreeSelectComponent, "pdx-material-tree-select", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialSearchableSelectComponent extends SimpleBaseSelectComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    private searchInput?;
+    private readonly store;
+    readonly endReached: _angular_core.WritableSignal<boolean>;
+    private initialLoadStrategy;
+    setSelectMetadata(metadata: any): void;
+    ngOnInit(): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    onOpened(opened: boolean): void;
+    private getSelectedIds;
+    private preloadSelected;
+    private refreshOptions;
+    protected loadOptions(page?: number, searchTerm?: string, criteria?: Record<string, any>): void;
+    loadNextPage(): void;
+    onSearch(term: string): void;
+    protected registerMatSelect(select: any): void;
+    reload(reset: boolean): void;
+    protected onDependenciesChanged(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialSearchableSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialSearchableSelectComponent, "pdx-material-searchable-select", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialAutocompleteComponent extends SimpleBaseSelectComponent<OptionDTO<any>> {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    private readonly store;
+    readonly endReached: _angular_core.WritableSignal<boolean>;
+    displayWith: (opt: OptionDTO<any>) => string;
+    private initialLoadStrategy;
+    setSelectMetadata(metadata: SimpleSelectMetadata<any>): void;
+    ngOnInit(): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    isReadonlyEffective(): boolean;
+    private getSelectedId;
+    private preloadSelected;
+    private refreshOptions;
+    protected loadOptions(page?: number, searchTerm?: string, criteria?: Record<string, any>): void;
+    onOpened(): void;
+    onScroll(index: number): void;
+    onSearch(term: string): void;
+    trackByOption(index: number, option: SelectOption<OptionDTO<any>>): any;
+    reload(reset: boolean): void;
+    protected onDependenciesChanged(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialAutocompleteComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialAutocompleteComponent, "pdx-material-autocomplete", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialChipsComponent extends SimpleBaseSelectComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    readonly removable: _angular_core.WritableSignal<boolean>;
+    readonly addOnBlur: _angular_core.WritableSignal<boolean>;
+    readonly separatorKeys: number[];
+    displayOption: (value: any) => string;
+    selectedOptions(): SelectOption[];
+    removeChip(option: SelectOption): void;
+    onInputTokenEnd(event: MatChipInputEvent): void;
+    setSelectMetadata(metadata: SimpleSelectMetadata<any>): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialChipsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialChipsComponent, "pdx-material-chips", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialButtonToggleComponent extends SimpleBaseSelectComponent {
+    setSelectMetadata(metadata: SimpleSelectMetadata<any>): void;
+    protected getSpecificCssClasses(): string[];
+    onGroupChange(event: MatButtonToggleChange): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialButtonToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialButtonToggleComponent, "pdx-material-button-toggle", never, {}, {}, never, never, true, never>;
+}
+
+declare class MaterialSlideToggleComponent extends SimpleBaseInputComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialToggleMetadata): void;
+    protected getSpecificCssClasses(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialSlideToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialSlideToggleComponent, "pdx-material-slide-toggle", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialSliderComponent extends SimpleBaseInputComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    /** Display function for slider values */
+    displayWithFn: (value: number) => any;
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialSliderMetadata): void;
+    protected getSpecificCssClasses(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialSliderComponent, "pdx-material-slider", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialAsyncSelectComponent extends SimpleBaseSelectComponent {
+    private lastConfiguredPath?;
+    private initialLoadStrategy;
+    private hasPerformedInitialLoad;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    private searchInput?;
+    readonly termControl: FormControl<string | null>;
+    private readonly store;
+    readonly endReached: _angular_core.WritableSignal<boolean>;
+    private cursorAfter;
+    private cursorPageIndex;
+    private dataVersion?;
+    private useCursor;
+    setSelectMetadata(metadata: any): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    ngOnInit(): void;
+    onOpened(opened: boolean): void;
+    private getSelectedIds;
+    private preloadSelected;
+    private refreshOptions;
+    private runQuery;
+    loadMore(): void;
+    retry(): void;
+    handleKey(event: KeyboardEvent): void;
+    protected registerMatSelect(select: any): void;
+    reload(reset: boolean): void;
+    protected onDependenciesChanged(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialAsyncSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialAsyncSelectComponent, "pdx-material-async-select", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialRadioGroupComponent extends SimpleBaseSelectComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    setSelectMetadata(metadata: SimpleSelectMetadata<any>): void;
+    protected getSpecificCssClasses(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialRadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialRadioGroupComponent, "pdx-material-radio-group", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialCheckboxGroupComponent extends SimpleBaseSelectComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    setSelectMetadata(metadata: SimpleSelectMetadata<any>): void;
+    /** Disables options when maxSelections reached */
+    isOptionDisabled(option: SelectOption<any>): boolean;
+    protected getSpecificCssClasses(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialCheckboxGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialCheckboxGroupComponent, "pdx-material-checkbox-group", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialSelectionListComponent extends SimpleBaseSelectComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    setSelectMetadata(metadata: SimpleSelectMetadata<any>): void;
+    protected getSpecificCssClasses(): string[];
+    onSelectionChange(event: MatSelectionListChange): void;
+    isOptionSelected(value: any): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialSelectionListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialSelectionListComponent, "pdx-material-selection-list", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Placeholder component for file upload fields.
+ *
+ * Currently provides a simple `<input type="file">` element and basic
+ * ControlValueAccessor integration. A full-featured implementation will
+ * be provided in future iterations.
+ */
+declare class MaterialFileUploadComponent extends SimpleBaseInputComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    /**
+     * Updates the control value when the user selects a file.
+     */
+    onFileSelected(event: Event): void;
+    /**
+     * Exposes metadata setter for integration with dynamic form loader.
+     */
+    setFileUploadMetadata(metadata: ComponentMetadata): void;
+    /**
+     * CSS classes specific to the file upload wrapper.
+     */
+    protected getSpecificCssClasses(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialFileUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialFileUploadComponent, "pdx-material-file-upload", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface PreloadStatus {
+    isPreloading: boolean;
+    progress: number;
+    currentComponent: string | null;
+    totalComponents: number;
+    loadedComponents: number;
+    failedComponents: number;
+    errors: string[];
+}
+declare class ComponentPreloaderService {
+    private readonly componentRegistry;
+    private readonly destroyRef;
+    private preloadCompleted;
+    private readonly preloadedComponents;
+    private readonly statusSubject;
+    private readonly componentsToPreload;
+    /**
+     * Observable do status atual do preload
+     */
+    get status$(): Observable<PreloadStatus>;
+    /**
+     * Verifica se o preload foi completado
+     */
+    isPreloadCompleted(): boolean;
+    /**
+     * Verifica se um componente específico foi precarregado
+     */
+    isComponentPreloaded(type: string): boolean;
+    /**
+     * Inicializa o sistema de componentes dinâmicos
+     * Deve ser chamado na inicialização da aplicação
+     */
+    initialize(): Promise<void>;
+    /**
+     * Força um novo preload (útil para desenvolvimento)
+     */
+    forceReload(): Promise<void>;
+    /**
+     * Preload de um componente específico (on-demand)
+     */
+    preloadComponent(type: string): Promise<boolean>;
+    /**
+     * Executa o preload de todos os componentes configurados
+     */
+    private preloadComponents;
+    /**
+     * Atualiza o status interno do preload
+     */
+    private updateStatus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComponentPreloaderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ComponentPreloaderService>;
+}
+/**
+ * Factory function para inicialização da aplicação
+ * Usar no app.config.ts com APP_INITIALIZER
+ *
+ * Executa de forma não-bloqueante para não atrasar o bootstrap da app,
+ * mas garante que o TextInputComponent seja pré-carregado em background
+ */
+declare function initializeComponentSystem(): () => undefined;
+/**
+ * Factory function para inicialização síncrona (opcional)
+ * Use apenas se quiser aguardar o preload antes da app inicializar
+ */
+declare function initializeComponentSystemSync(): () => Promise<void>;
+
+/**
+ * @fileoverview Componente para exibir status do preload de componentes
+ *
+ * Componente opcional para debug e monitoramento do preload.
+ * Exibe informações em tempo real sobre o carregamento dos componentes.
+ */
+
+declare class PreloadStatusComponent implements OnInit, OnDestroy {
+    private readonly preloader;
+    status: PreloadStatus | null;
+    autoUpdate: boolean;
+    private externalControl;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Força um novo preload
+     */
+    forceReload(): Promise<void>;
+    /**
+     * Toggle do auto-update
+     */
+    toggleAutoUpdate(): void;
+    /**
+     * Subscreve às atualizações de status em tempo real
+     */
+    private subscribeToStatus;
+    /**
+     * Carrega status atual uma vez
+     */
+    private loadCurrentStatus;
+    setExternalControl(control: AbstractControl): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PreloadStatusComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PreloadStatusComponent, "pdx-preload-status", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for telephone numbers.
+ *
+ * Renders a `<mat-form-field>` wrapping an `<input type="tel">` element with
+ * Material styling. Built on top of `SimpleBaseInputComponent` to leverage
+ * reactive forms integration, hint/error messaging and validation hooks.
+ */
+declare class PhoneInputComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies strongly typed metadata to the component. */
+    setInputMetadata(metadata: MaterialPhoneMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    isReadonlyEffective(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneInputComponent, "pdx-phone-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for HTML time inputs.
+ *
+ * Renders a `<mat-form-field>` containing an `<input type="time">` element
+ * with optional min/max/step constraints, basic validation and hint support.
+ * Built on top of the `SimpleBaseInputComponent` to reuse core features
+ * like reactive forms integration and error handling.
+ */
+declare class TimeInputComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialTimeInputMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    isReadonlyEffective(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimeInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimeInputComponent, "pdx-time-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Angular Material timepicker component used in dynamic forms.
+ *
+ * Provides a form field with an input connected to `mat-timepicker`, allowing
+ * users to select a time of day. Built on top of the `SimpleBaseInputComponent`
+ * to reuse control value accessor integration and validation handling.
+ */
+declare class MaterialTimepickerComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialTimepickerMetadata): void;
+    isReadonlyEffective(): boolean;
+    /** Calculates step attribute (seconds) based on metadata. */
+    stepAttribute(): number | null;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialTimepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialTimepickerComponent, "pdx-material-timepicker", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for HTML URL inputs.
+ *
+ * Renders a `<mat-form-field>` containing an `<input type="url">` element
+ * with basic validation and hint support. Built on top of the
+ * `SimpleBaseInputComponent` to leverage common functionality such as
+ * reactive forms integration and error handling.
+ */
+declare class UrlInputComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialUrlInputMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    isReadonlyEffective(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UrlInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UrlInputComponent, "pdx-url-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Specialized input component for HTML week inputs.
+ *
+ * Renders a `<mat-form-field>` containing an `<input type="week">` element
+ * with optional min/max constraints, basic validation and hint support.
+ * Built on top of the `SimpleBaseInputComponent` to reuse core features
+ * like reactive forms integration and error handling.
+ */
+declare class WeekInputComponent extends SimpleBaseInputComponent {
+    /** Emits whenever validation state changes. */
+    readonly validationChange: _angular_core.OutputEmitterRef<ValidationErrors | null>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    ngOnInit(): void;
+    validateField(): Promise<ValidationErrors | null>;
+    protected getSpecificCssClasses(): string[];
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialWeekInputMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    isReadonlyEffective(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WeekInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WeekInputComponent, "pdx-week-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, { "validationChange": "validationChange"; }, never, never, true, never>;
+}
+
+/**
+ * Basic color picker component leveraging the native input type="color".
+ *
+ * Renders a text field displaying the selected color value and a palette
+ * icon that opens the browser's color picker. This acts as a starting point
+ * for a more advanced color selection experience.
+ */
+declare class MaterialColorPickerComponent extends SimpleBaseInputComponent {
+    private pickerRef;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    /** Applies component metadata with strong typing. */
+    setInputMetadata(metadata: MaterialColorPickerMetadata): void;
+    /** Opens the native color picker dialog. */
+    openPicker(): void;
+    /** Handles color selection from the native input. */
+    onNativeColorChange(event: Event): void;
+    protected getSpecificCssClasses(): string[];
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    isReadonlyEffective(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialColorPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialColorPickerComponent, "pdx-material-colorpicker", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type SelectionMode = 'continuous' | 'single';
+type PrecisionMode = 'item' | 'half';
+interface RatingIconState {
+    index: number;
+    filled: boolean;
+    half: boolean;
+    hover: boolean;
+}
+declare class MaterialRatingComponent extends SimpleBaseInputComponent implements ControlValueAccessor {
+    itemsCount: number;
+    selection: SelectionMode;
+    precision: PrecisionMode;
+    icon?: string;
+    svgIcon?: string;
+    svgIconOutline?: string;
+    outlineIcon?: string;
+    disabled: boolean;
+    readonlyMode: boolean;
+    presentationMode: boolean;
+    tabindex: number;
+    size: 'small' | 'medium' | 'large';
+    ariaLabel?: string;
+    ratingColor?: string;
+    outlineColor?: string;
+    itemTemplate?: TemplateRef<any>;
+    itemsRoot?: ElementRef<HTMLElement>;
+    value: number | null;
+    private hoverIndex;
+    private hoverHalf;
+    private normalizeCssColor;
+    writeValue(obj: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    isFilled(index: number): boolean;
+    showHalf(index: number): boolean;
+    iconState(index: number): RatingIconState;
+    onMouseMove(ev: MouseEvent, index: number): void;
+    onMouseLeave(): void;
+    onClick(ev: MouseEvent, index: number): void;
+    onKeyDown(ev: KeyboardEvent): void;
+    private computeValueFromIndex;
+    private getVisualValue;
+    private getActiveIndexAndHalf;
+    private applyValue;
+    readonlyEffective(): boolean;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    setInputMetadata(meta: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialRatingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialRatingComponent, "pdx-material-rating", never, { "itemsCount": { "alias": "itemsCount"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "precision": { "alias": "precision"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "svgIcon": { "alias": "svgIcon"; "required": false; }; "svgIconOutline": { "alias": "svgIconOutline"; "required": false; }; "outlineIcon": { "alias": "outlineIcon"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "size": { "alias": "size"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ratingColor": { "alias": "ratingColor"; "required": false; }; "outlineColor": { "alias": "outlineColor"; "required": false; }; }, {}, ["itemTemplate"], never, true, never>;
+}
+
+type PickerView = 'gradient' | 'palette';
+type ColorFormat = 'hex' | 'rgb' | 'rgba' | 'hsl';
+interface GradientSettings {
+    showOpacity?: boolean;
+    channel?: 'hsv' | 'hsl';
+}
+interface PaletteSettings {
+    preset?: 'basic' | 'office' | 'material' | string;
+    colors?: string[];
+    columns?: number;
+}
+interface PopupSettings {
+    width?: number | string;
+    anchor?: Element;
+    appendTo?: Element | any;
+}
+declare class PdxColorPickerComponent extends SimpleBaseInputComponent implements ControlValueAccessor {
+    private readonly bottomSheet;
+    actionsLayout: 'start' | 'end';
+    activeView: PickerView;
+    adaptiveMode: boolean;
+    adaptiveTitle?: string;
+    adaptiveSubtitle?: any;
+    clearButton: boolean;
+    disabledMode: boolean;
+    readonlyMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    fillMode: 'solid' | 'flat' | 'outline';
+    format: ColorFormat;
+    gradientSettings?: GradientSettings;
+    icon?: string;
+    iconClass?: string | string[] | Record<string, boolean>;
+    svgIcon?: any;
+    paletteSettings?: PaletteSettings;
+    popupSettings?: PopupSettings;
+    preview: boolean;
+    rounded: 'none' | 'small' | 'medium' | 'large' | 'full';
+    size: 'small' | 'medium' | 'large';
+    tabindex: number;
+    views: PickerView[];
+    maxRecent: number;
+    showRecent: boolean;
+    readonly valueChange: _angular_core.OutputEmitterRef<string | null>;
+    readonly open: _angular_core.OutputEmitterRef<void>;
+    readonly close: _angular_core.OutputEmitterRef<void>;
+    readonly cancel: _angular_core.OutputEmitterRef<void>;
+    readonly activeViewChange: _angular_core.OutputEmitterRef<PickerView>;
+    readonly activeColorClick: _angular_core.OutputEmitterRef<string>;
+    readonly focusEvent: _angular_core.OutputEmitterRef<void>;
+    readonly blurEvent: _angular_core.OutputEmitterRef<void>;
+    toggleBtn?: any;
+    private menuTrigger?;
+    private readonly current;
+    private readonly draft;
+    private readonly draftAlpha;
+    panelWidthPx: number;
+    constructor(bottomSheet: MatBottomSheet);
+    ngOnInit(): void;
+    writeValue(obj: any): void;
+    handleFocus(): void;
+    handleBlur(): void;
+    openPicker(): void;
+    onClose(): void;
+    selectedTabIndex: _angular_core.WritableSignal<number>;
+    readonly showGradient: _angular_core.Signal<boolean>;
+    readonly showPalette: _angular_core.Signal<boolean>;
+    onTabIndexChange(i: number): void;
+    draftPreview: _angular_core.Signal<string | null>;
+    draftSolidHex: _angular_core.Signal<string>;
+    draftOpacity: _angular_core.Signal<number>;
+    previewBackground(): string;
+    onNativeGradient(ev: Event): void;
+    onOpacity(ev: Event): void;
+    private readonly customColors;
+    readonly recentColors: _angular_core.WritableSignal<string[]>;
+    paletteColors: _angular_core.Signal<string[]>;
+    trackColor(_: number, c: string): string;
+    onSwatchClick(c: string): void;
+    addPaletteColor(): void;
+    private pushRecent;
+    copyDraft(): void;
+    isSelected(c: string): boolean;
+    onClear(): void;
+    onCancel(): void;
+    onApply(): void;
+    readonlyEffective(): boolean;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    protected getSpecificCssClasses(): string[];
+    setInputMetadata(meta: any): void;
+    private toFormat;
+    private toHex;
+    private toRgb;
+    private toHsl;
+    private extractAlpha;
+    private clamp01;
+    private buildPaletteColors;
+    private coerceWidth;
+    private loadFromStorage;
+    private saveToStorage;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PdxColorPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PdxColorPickerComponent, "pdx-color-picker", never, { "actionsLayout": { "alias": "actionsLayout"; "required": false; }; "activeView": { "alias": "activeView"; "required": false; }; "adaptiveMode": { "alias": "adaptiveMode"; "required": false; }; "adaptiveTitle": { "alias": "adaptiveTitle"; "required": false; }; "adaptiveSubtitle": { "alias": "adaptiveSubtitle"; "required": false; }; "clearButton": { "alias": "clearButton"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; "fillMode": { "alias": "fillMode"; "required": false; }; "format": { "alias": "format"; "required": false; }; "gradientSettings": { "alias": "gradientSettings"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconClass": { "alias": "iconClass"; "required": false; }; "svgIcon": { "alias": "svgIcon"; "required": false; }; "paletteSettings": { "alias": "paletteSettings"; "required": false; }; "popupSettings": { "alias": "popupSettings"; "required": false; }; "preview": { "alias": "preview"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; "size": { "alias": "size"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "views": { "alias": "views"; "required": false; }; "maxRecent": { "alias": "maxRecent"; "required": false; }; "showRecent": { "alias": "showRecent"; "required": false; }; }, { "valueChange": "valueChange"; "open": "open"; "close": "close"; "cancel": "cancel"; "activeViewChange": "activeViewChange"; "activeColorClick": "activeColorClick"; "focusEvent": "focusEvent"; "blurEvent": "blurEvent"; }, never, never, true, never>;
+}
+
+declare class PdxMaterialRangeSliderComponent extends SimpleBaseInputComponent implements OnInit {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    metadata: _angular_core.WritableSignal<MaterialRangeSliderMetadata | null>;
+    readonly rangeGroup: FormGroup<{
+        start: FormControl<number | null>;
+        end: FormControl<number | null>;
+    }>;
+    readonly isRangeMode: _angular_core.Signal<boolean>;
+    readonly displayWithFn: _angular_core.Signal<(value: number) => string>;
+    readonly errorMessage: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    /**
+     * Overrides writeValue to handle both single and range modes.
+     */
+    writeValue(value: any): void;
+    /**
+     * Sets the component metadata and re-initializes validators.
+     * @param metadata The metadata for the component.
+     */
+    setSliderMetadata(metadata: MaterialRangeSliderMetadata): void;
+    protected getSpecificCssClasses(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PdxMaterialRangeSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PdxMaterialRangeSliderComponent, "pdx-material-range-slider", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MaterialTransferListComponent extends SimpleBaseSelectComponent {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    leftLabel: string;
+    rightLabel: string;
+    leftPlaceholder: string;
+    rightPlaceholder: string;
+    readonly leftOptions: _angular_core.WritableSignal<SelectOption<any>[]>;
+    readonly rightOptions: _angular_core.WritableSignal<SelectOption<any>[]>;
+    readonly leftFilter: _angular_core.WritableSignal<string>;
+    readonly rightFilter: _angular_core.WritableSignal<string>;
+    readonly filteredLeft: _angular_core.Signal<SelectOption<any>[]>;
+    readonly filteredRight: _angular_core.Signal<SelectOption<any>[]>;
+    constructor();
+    setSelectMetadata(metadata: SimpleSelectMetadata<any>): void;
+    ngOnInit(): void;
+    private updateListsFromValue;
+    getSelectedOptions(list: MatSelectionList): SelectOption[];
+    moveRight(options: SelectOption[]): void;
+    moveLeft(options: SelectOption[]): void;
+    moveAllToRight(): void;
+    moveAllToLeft(): void;
+    drop(event: CdkDragDrop<SelectOption<any>[]>): void;
+    private syncControl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialTransferListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaterialTransferListComponent, "pdx-material-transfer-list", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PdxYearInputComponent extends SimpleBaseInputComponent {
+    private get meta();
+    readonly minYear: _angular_core.Signal<number | undefined>;
+    readonly maxYear: _angular_core.Signal<number | undefined>;
+    readonly step: _angular_core.Signal<number>;
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    isReadonlyEffective(): boolean;
+    ngOnInit(): void;
+    setInputMetadata(metadata: MaterialYearInputMetadata): void;
+    errorStateMatcher(): _angular_material_error_options_d_CGdTZUYk.E;
+    onYearInput(event: Event): void;
+    protected getSpecificCssClasses(): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PdxYearInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PdxYearInputComponent, "pdx-year-input", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface TimeRangeValue {
+    start: string | null;
+    end: string | null;
+}
+declare class PdxMaterialTimeRangeComponent extends SimpleBaseInputComponent implements OnInit {
+    readonlyMode: boolean;
+    disabledMode: boolean;
+    visible: boolean;
+    presentationMode: boolean;
+    timeRangeForm: FormGroup<{
+        start: FormControl<string | null>;
+        end: FormControl<string | null>;
+    }>;
+    private get meta();
+    startLabel: () => string;
+    endLabel: () => string;
+    startPlaceholder: () => string;
+    endPlaceholder: () => string;
+    ngOnInit(): void;
+    writeValue(value: TimeRangeValue | null): void;
+    setDisabledState(isDisabled: boolean): void;
+    private rangeOrderValidator;
+    private minDistanceValidator;
+    private maxDistanceValidator;
+    private timeToMinutes;
+    setInputMetadata(metadata: MaterialTimeRangeMetadata): void;
+    isReadonlyEffective(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PdxMaterialTimeRangeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PdxMaterialTimeRangeComponent, "pdx-material-time-range", never, { "readonlyMode": { "alias": "readonlyMode"; "required": false; }; "disabledMode": { "alias": "disabledMode"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "presentationMode": { "alias": "presentationMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Metadata for TextInputComponent */
+declare const PDX_TEXT_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+/** Metadata for NumberInputComponent */
+declare const PDX_NUMBER_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+/**
+ * Metadata for MaterialSelectComponent
+ *
+ * Documenta inputs/descrição para catálogos e builders. Este componente
+ * não expõe @Output próprios (usa ControlValueAccessor), portanto não há
+ * eventos listados aqui.
+ */
+declare const PDX_MATERIAL_SELECT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_COLOR_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_DATE_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_DATETIME_LOCAL_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_EMAIL_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_DATEPICKER_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_DATE_RANGE_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_CURRENCY_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_TEXTAREA_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_SLIDER_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_TIMEPICKER_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_BUTTON_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_BUTTON_TOGGLE_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_CHECKBOX_GROUP_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_CHIPS_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_COLORPICKER_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_RATING_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_COLOR_PICKER_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_CPF_CNPJ_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_FILE_UPLOAD_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_MULTI_SELECT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_MULTI_SELECT_TREE_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_RADIO_GROUP_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_SEARCHABLE_SELECT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_SELECTION_LIST_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_TRANSFER_LIST_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_TREE_SELECT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_PRICE_RANGE_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_RANGE_SLIDER_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MONTH_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_PASSWORD_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_PHONE_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_PRELOAD_STATUS_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_SEARCH_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_TIME_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_URL_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_WEEK_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_MATERIAL_TIME_RANGE_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_YEAR_INPUT_COMPONENT_METADATA: ComponentDocMeta;
+
+declare const PDX_FIELD_SHELL_COMPONENT_METADATA: ComponentDocMeta;
+
+/**
+ * Context object passed to action handlers containing all relevant data
+ * about the component state and form context when an action is executed.
+ *
+ * This interface provides maximum flexibility for action handlers to access
+ * both component-specific data and broader form/application context.
+ *
+ * @example Basic usage in action handler
+ * ```typescript
+ * this.registerAction('customAction', async (context: ActionContext) => {
+ *   console.log('Field:', context.fieldName);
+ *   console.log('Value:', context.fieldValue);
+ *   console.log('Metadata:', context.metadata);
+ *   return { success: true, data: 'Action completed' };
+ * });
+ * ```
+ *
+ * @example Using actionParam for parameterized actions
+ * ```typescript
+ * // Metadata configuration: action: "navigate:/dashboard"
+ * this.registerAction('navigate', async (context: ActionContext) => {
+ *   const url = context.actionParam; // "/dashboard"
+ *   await this.router.navigate([url]);
+ *   return { success: true };
+ * });
+ * ```
+ */
+interface ActionContext {
+    /**
+     * Name/identifier of the field that triggered the action.
+     *
+     * Useful for:
+     * - Logging and debugging
+     * - Field-specific business logic
+     * - Form validation context
+     *
+     * @example "email", "firstName", "submitButton"
+     */
+    fieldName?: string;
+    /**
+     * Current value of the field that triggered the action.
+     *
+     * For different field types:
+     * - Input fields: string value
+     * - Checkboxes: boolean
+     * - Select: selected option value
+     * - Buttons: typically undefined
+     *
+     * @example "john@example.com", true, ["option1", "option2"]
+     */
+    fieldValue?: any;
+    /**
+     * Complete metadata configuration object for the field.
+     *
+     * Contains all field configuration including:
+     * - Label, placeholder, validation rules
+     * - UI configuration (appearance, icons, etc.)
+     * - Custom properties specific to the field
+     *
+     * @example MaterialButtonMetadata, MaterialInputMetadata, etc.
+     */
+    metadata?: any;
+    /**
+     * Complete form data object containing all field values.
+     *
+     * Useful for:
+     * - Cross-field validation
+     * - Conditional logic based on other fields
+     * - Form-wide operations
+     *
+     * @example { email: "user@example.com", name: "John", age: 30 }
+     */
+    formData?: any;
+    /**
+     * Reference to the Angular component instance that triggered the action.
+     *
+     * Provides access to:
+     * - Component methods and properties
+     * - ElementRef for DOM manipulation
+     * - Angular lifecycle and services
+     *
+     * @example MaterialButtonComponent, MaterialInputComponent instances
+     */
+    componentInstance?: any;
+    /**
+     * Parameter extracted from action reference after colon separator.
+     *
+     * When action is defined as "actionName:parameter", this contains the parameter part.
+     * Enables parameterized actions without separate configuration.
+     *
+     * @example
+     * - Action: "navigate:/dashboard" → actionParam: "/dashboard"
+     * - Action: "showAlert:Data saved successfully" → actionParam: "Data saved successfully"
+     * - Action: "download:https://example.com/file.pdf" → actionParam: "https://example.com/file.pdf"
+     */
+    actionParam?: string;
+}
+/**
+ * Result object returned by action handlers indicating success/failure
+ * and any associated data or error information.
+ *
+ * Provides a standardized way for action handlers to communicate results
+ * back to the calling component for appropriate user feedback.
+ *
+ * @example Successful action result
+ * ```typescript
+ * return {
+ *   success: true,
+ *   data: 'Form submitted successfully',
+ *   redirect: '/dashboard'
+ * };
+ * ```
+ *
+ * @example Failed action result
+ * ```typescript
+ * return {
+ *   success: false,
+ *   error: 'Validation failed: Email is required'
+ * };
+ * ```
+ */
+interface ActionResult {
+    /**
+     * Indicates whether the action completed successfully.
+     *
+     * - true: Action completed without errors
+     * - false: Action failed or encountered an error
+     *
+     * Used by components to determine appropriate user feedback
+     * (success message, error display, etc.)
+     */
+    success: boolean;
+    /**
+     * Optional data returned by successful actions.
+     *
+     * Can contain:
+     * - Success messages for user display
+     * - Result data from API calls
+     * - State information for further processing
+     * - Any serializable data relevant to the action
+     *
+     * @example "Form submitted", { userId: 123 }, ["item1", "item2"]
+     */
+    data?: any;
+    /**
+     * Error message when action fails (success = false).
+     *
+     * Should contain:
+     * - User-friendly error descriptions
+     * - Validation error messages
+     * - Technical error details (for logging)
+     *
+     * Displayed to users or logged for debugging purposes.
+     *
+     * @example "Network error occurred", "Invalid email format", "Access denied"
+     */
+    error?: string;
+    /**
+     * Optional URL for automatic navigation after action completion.
+     *
+     * When provided, the calling component may automatically redirect
+     * the user to this URL after the action succeeds.
+     *
+     * Useful for:
+     * - Post-submit redirects
+     * - Workflow navigation
+     * - Success page redirection
+     *
+     * @example "/dashboard", "/success", "https://external-site.com"
+     */
+    redirect?: string;
+}
+/**
+ * Function signature for action handlers that can be registered with the ActionResolverService.
+ *
+ * Action handlers receive an ActionContext with all relevant component and form data,
+ * and must return an ActionResult indicating success/failure.
+ *
+ * Handlers can be either synchronous or asynchronous to support both immediate
+ * operations and API calls/complex processing.
+ *
+ * @example Synchronous action handler
+ * ```typescript
+ * const logHandler: ActionHandler = (context) => {
+ *   console.log('Field value:', context.fieldValue);
+ *   return { success: true, data: 'Logged successfully' };
+ * };
+ * ```
+ *
+ * @example Asynchronous action handler
+ * ```typescript
+ * const saveHandler: ActionHandler = async (context) => {
+ *   try {
+ *     await apiService.saveData(context.formData);
+ *     return { success: true, data: 'Data saved' };
+ *   } catch (error) {
+ *     return { success: false, error: 'Save failed' };
+ *   }
+ * };
+ * ```
+ *
+ * @param context - Complete action execution context
+ * @returns Promise<ActionResult> or ActionResult indicating success/failure
+ */
+type ActionHandler = (context: ActionContext) => Promise<ActionResult> | ActionResult;
+declare class ActionResolverService {
+    private readonly router;
+    private readonly http;
+    private readonly dialog;
+    private readonly actionRegistry;
+    constructor();
+    /**
+     * Registra ações relacionadas a diálogos (unificado PraxisDialog)
+     */
+    private registerDialogActions;
+    /**
+     * Registra uma nova ação
+     */
+    registerAction(actionName: string, handler: ActionHandler): void;
+    /**
+     * Remove uma ação registrada
+     */
+    unregisterAction(actionName: string): void;
+    /**
+     * Executa uma ação por nome
+     */
+    executeAction(actionRef: string, context?: ActionContext): Promise<ActionResult>;
+    /**
+     * Lista todas as ações registradas
+     */
+    getRegisteredActions(): string[];
+    /**
+     * Verifica se uma ação existe
+     */
+    hasAction(actionName: string): boolean;
+    /**
+     * Registra ações built-in (pré-definidas) do sistema ActionResolverService.
+     *
+     * Este método é chamado automaticamente no constructor e registra um conjunto
+     * de ações comuns úteis para aplicações corporativas, eliminando a necessidade
+     * de implementar essas funcionalidades básicas repetidamente.
+     *
+     * Todas as ações built-in seguem padrões corporativos de:
+     * - ✅ Tratamento de erros robusto
+     * - ✅ Logging consistente para auditoria
+     * - ✅ Mensagens user-friendly
+     * - ✅ Segurança (noopener, noreferrer)
+     * - ✅ Compatibilidade cross-browser
+     *
+     * ## 📋 Ações Disponíveis
+     *
+     * ### 📝 Formulários
+     * - **submitForm**: Submete o formulário pai do componente
+     * - **resetForm**: Reseta todos os campos do formulário pai
+     *
+     * ### 🧭 Navegação
+     * - **navigate**: Navegação interna via Angular Router ou externa via window.location
+     * - **openUrl**: Abre URL em nova aba com segurança (noopener, noreferrer)
+     *
+     * ### 📥 Downloads e Dados
+     * - **download**: Inicia download de arquivo via URL
+     * - **copyToClipboard**: Copia texto para área de transferência
+     *
+     * ### 🔔 Interface e Feedback
+     * - **showAlert**: Exibe alerta nativo do navegador
+     * - **log**: Registra mensagem no console para debugging
+     *
+     * ## 🎯 Uso no Metadata
+     *
+     * ```typescript
+     * // Ação simples
+     * const submitButton: MaterialButtonMetadata = {
+     *   name: 'submit',
+     *   label: 'Enviar',
+     *   controlType: 'button',
+     *   action: 'submitForm' // ← Ação built-in
+     * };
+     *
+     * // Ação com parâmetro
+     * const linkButton: MaterialButtonMetadata = {
+     *   name: 'dashboard',
+     *   label: 'Dashboard',
+     *   controlType: 'button',
+     *   action: 'navigate:/dashboard' // ← Parâmetro após ':'
+     * };
+     *
+     * // Ação de download
+     * const downloadButton: MaterialButtonMetadata = {
+     *   name: 'download',
+     *   label: 'Download PDF',
+     *   controlType: 'button',
+     *   action: 'download:https://example.com/report.pdf'
+     * };
+     * ```
+     *
+     * ## ⚠️ Notas Importantes
+     *
+     * - Ações são **case-sensitive**: use exatamente como documentado
+     * - Parâmetros são opcionais: ações funcionam com/sem parâmetros
+     * - Tratamento de erro: todas as ações retornam ActionResult padronizado
+     * - Logging: ações importantes são logadas automaticamente para auditoria
+     * - Segurança: URLs externas usam 'noopener,noreferrer' por padrão
+     *
+     * @private
+     * @see ActionContext - Interface de contexto passada para todas as ações
+     * @see ActionResult - Interface de resultado retornada por todas as ações
+     * @see ActionHandler - Tipo de função para implementar ações customizadas
+     */
+    private registerBuiltInActions;
+    /**
+     * Encontra o elemento <form> pai de um componente Angular.
+     *
+     * Percorre a árvore DOM a partir do elemento do componente até encontrar
+     * um elemento <form> pai ou chegar ao document.body.
+     *
+     * Usado pelas ações submitForm e resetForm para localizar o formulário
+     * que contém o componente que disparou a ação.
+     *
+     * @param componentInstance - Instância do componente Angular
+     * @returns HTMLFormElement se encontrado, null caso contrário
+     *
+     * @example Estrutura HTML típica
+     * ```html
+     * <form>
+     *   <mat-form-field>
+     *     <input matInput>
+     *   </mat-form-field>
+     *   <pdx-material-button action="submitForm">Submit</pdx-material-button>
+     * </form>
+     * ```
+     *
+     * @private
+     */
+    private findParentForm;
+    /**
+     * Registra ações de estado e validação de formulários.
+     * Chamado durante a inicialização do serviço.
+     */
+    private registerStateValidationActions;
+    /**
+     * Registra ações de API e manipulação de dados.
+     * Chamado durante a inicialização do serviço.
+     */
+    private registerApiDataActions;
+    /**
+     * Limpa drafts antigos do localStorage para evitar quota exceeded.
+     *
+     * Remove drafts com mais de 7 dias ou que estejam malformados.
+     * Chamado automaticamente antes de salvar novos drafts.
+     *
+     * @private
+     */
+    private cleanupOldDrafts;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionResolverService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ActionResolverService>;
+}
+
+declare class DateUtilsService {
+    /**
+     * Parses different date representations into a `Date` object.
+     * Accepts ISO strings, `Date` instances or numeric arrays in the form
+     * `[year, month, day, hour?, minute?, second?, millisecond?]`.
+     * Returns `null` when the input cannot be parsed.
+     */
+    parseDate(value: any): Date | null;
+    getDefaultDateFormat(controlType?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateUtilsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DateUtilsService>;
+}
+
+interface ShortcutHandler {
+    callback: () => void;
+    description?: string;
+    componentId?: string;
+    priority?: number;
+}
+interface ShortcutInfo {
+    shortcut: string;
+    handlers: ShortcutHandler[];
+}
+declare class KeyboardShortcutService {
+    private readonly destroyRef;
+    private readonly shortcuts;
+    private isListening;
+    constructor();
+    /**
+     * Registra um atalho de teclado
+     */
+    registerShortcut(shortcut: string, handler: ShortcutHandler): () => void;
+    /**
+     * Remove um atalho de teclado específico
+     */
+    unregisterShortcut(shortcut: string, handler: ShortcutHandler): void;
+    /**
+     * Remove todos os atalhos de um componente específico
+     */
+    unregisterComponentShortcuts(componentId: string): void;
+    /**
+     * Lista todos os atalhos registrados
+     */
+    getRegisteredShortcuts(): ShortcutInfo[];
+    /**
+     * Verifica se um atalho está registrado
+     */
+    hasShortcut(shortcut: string): boolean;
+    /**
+     * Executa manualmente um atalho (para testes)
+     */
+    executeShortcut(shortcut: string): boolean;
+    /**
+     * Inicia a escuta de eventos de teclado
+     */
+    private startListening;
+    /**
+     * Verifica se deve processar o evento
+     */
+    private shouldProcessEvent;
+    /**
+     * Converte um evento de teclado em string de atalho
+     */
+    private eventToShortcut;
+    /**
+     * Normaliza uma string de atalho
+     */
+    private normalizeShortcut;
+    /**
+     * Converte atalho em formato legível
+     */
+    formatShortcut(shortcut: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KeyboardShortcutService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KeyboardShortcutService>;
+}
+
+/**
+ * Interfaces essenciais para o sistema de registro de componentes
+ * Versão ultra-simplificada sem metadados redundantes
+ */
+
+/**
+ * Registro de um componente no sistema com cache inteligente
+ */
+interface ComponentRegistration<T = any> {
+    /** Factory para carregamento lazy */
+    factory: () => Promise<Type<T>>;
+    /** Componente em cache após carregamento */
+    cached?: Type<T>;
+    /** Timestamp do cache para validação TTL */
+    cachedAt?: number;
+    /** Contador de tentativas de carregamento */
+    loadAttempts?: number;
+    /** Último erro de carregamento */
+    lastError?: Error;
+}
+declare const CACHE_TTL: number;
+declare const MAX_LOAD_ATTEMPTS = 3;
+declare const RETRY_DELAY = 1000;
+/**
+ * Interface do serviço de registro
+ */
+interface IComponentRegistry {
+    /**
+     * Registra um novo componente
+     */
+    register<T>(type: FieldControlType, factory: () => Promise<Type<T>>): void;
+    /**
+     * Obtém um componente registrado
+     */
+    getComponent<T>(type: FieldControlType): Promise<Type<T> | null>;
+    /**
+     * Verifica se um tipo está registrado
+     */
+    isRegistered(type: FieldControlType): boolean;
+    /**
+     * Lista tipos registrados
+     */
+    getRegisteredTypes(): FieldControlType[];
+}
+/**
+ * Resultado de carregamento de componente
+ */
+interface ComponentLoadResult<T = any> {
+    /** Componente carregado */
+    component: Type<T> | null;
+    /** Sucesso no carregamento */
+    success: boolean;
+    /** Erro se houver */
+    error?: Error;
+}
+/**
+ * Estatísticas do registro
+ */
+interface RegistryStats {
+    /** Número de componentes registrados */
+    registeredComponents: number;
+    /** Número de componentes em cache */
+    cachedComponents: number;
+    /** Tipos registrados */
+    registeredTypes: FieldControlType[];
+}
+
+declare class ComponentRegistryService implements IComponentRegistry {
+    /**
+     * Registro interno de componentes
+     */
+    private readonly registry;
+    constructor();
+    /**
+     * Registra um novo componente
+     */
+    register<T>(type: FieldControlType, factory: () => Promise<_angular_core.Type<T>>): void;
+    /**
+     * Obtém um componente registrado com cache inteligente
+     * Handles both string literals and enum values for backward compatibility
+     */
+    getComponent<T>(type: FieldControlType | string): Promise<_angular_core.Type<T> | null>;
+    /**
+     * Verifica se um tipo está registrado
+     * Handles both string literals and enum values
+     */
+    isRegistered(type: FieldControlType | string): boolean;
+    /**
+     * Lista todos os tipos registrados
+     */
+    getRegisteredTypes(): FieldControlType[];
+    /**
+     * Limpa o cache de todos os componentes
+     */
+    clearCache(): void;
+    /**
+     * Obtém estatísticas do registro
+     */
+    getStats(): RegistryStats;
+    /**
+     * Limpa cache de componentes específicos ou todos
+     */
+    clearCacheForType(type: FieldControlType): void;
+    /**
+     * Remove um componente do registro
+     */
+    unregister(type: FieldControlType): boolean;
+    /**
+     * Pré-carrega componentes especificados
+     */
+    preload(types: FieldControlType[]): Promise<ComponentLoadResult[]>;
+    /**
+     * Normalizes control type to handle both string literals and enum values
+     * This provides backward compatibility for existing code using string literals
+     */
+    private normalizeControlType;
+    /**
+     * Registra componentes Material Design padrão
+     */
+    private initializeDefaultComponents;
+    /**
+     * Verifica se o cache de um componente é válido
+     */
+    private isCacheValid;
+    /**
+     * Carrega componente com lógica de retry
+     */
+    private loadComponentWithRetry;
+    /**
+     * Verifica se está em ambiente de produção
+     */
+    private isProduction;
+    /**
+     * Utilitário para delay
+     */
+    private delay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComponentRegistryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ComponentRegistryService>;
+}
+
+/**
+ * @fileoverview Providers para configuração da biblioteca praxis-dynamic-fields
+ *
+ * Providers necessários para o funcionamento correto da biblioteca,
+ * incluindo HttpClient e outros serviços essenciais.
+ */
+
+/**
+ * Providers essenciais para praxis-dynamic-fields
+ *
+ * Inclui HttpClient para data loading e outros providers necessários.
+ *
+ * @example
+ * ```typescript
+ * // No app.config.ts ou main.ts
+ * import { providePraxisDynamicFields } from 'praxis-dynamic-fields';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     ...providePraxisDynamicFields(),
+ *     // outros providers...
+ *   ]
+ * });
+ * ```
+ */
+declare function providePraxisDynamicFields(): (Provider | EnvironmentProviders)[];
+/**
+ * Providers básicos sem HttpClient (para casos onde já está configurado)
+ */
+declare function providePraxisDynamicFieldsCore(): Provider[];
+
+/**
+ * @fileoverview Custom Error State Matcher for Praxis Dynamic Fields
+ *
+ * Implements configurable error state matching strategies for Material Design
+ * components based on field metadata configuration.
+ *
+ * This resolves CRITICAL ISSUE #8: ErrorStateMatcher not implemented
+ */
+
+type ErrorStateStrategy = 'default' | 'showOnDirtyAndInvalid' | 'showOnSubmitted' | 'showImmediately';
+/**
+ * Custom Error State Matcher that implements configurable strategies
+ * for when to show validation errors in Material components.
+ */
+declare class PraxisErrorStateMatcher implements ErrorStateMatcher {
+    private strategy;
+    constructor(strategy?: ErrorStateStrategy);
+    /**
+     * Determines if a control should be considered to be in an error state.
+     *
+     * @param control - The form control to check
+     * @param form - The parent form (if any)
+     * @returns true if the control should show errors
+     */
+    isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean;
+}
+/**
+ * Factory function to create ErrorStateMatcher instances based on strategy
+ */
+declare function createErrorStateMatcher(strategy?: ErrorStateStrategy): ErrorStateMatcher;
+/**
+ * Determines the appropriate error state strategy based on component context
+ */
+declare function inferErrorStateStrategy(fieldType: string, isLongForm?: boolean, userPreference?: ErrorStateStrategy): ErrorStateStrategy;
+/**
+ * Helper function to get ErrorStateMatcher for a dynamic field component
+ */
+declare function getErrorStateMatcherForField(metadata: any): ErrorStateMatcher;
+
+/**
+ * @fileoverview Sistema de logging inteligente para componentes dinâmicos
+ *
+ * Reduz spam de logs e permite controle fino sobre o que é exibido no console.
+ * Especialmente útil para evitar logs repetitivos do DynamicFieldLoader.
+ */
+type LoggerLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+interface LoggerConfig {
+    /** Nível mínimo de log */
+    level: LoggerLevel;
+    /** Prefixos para filtrar (ex: ['DynamicFieldLoader']) */
+    enabledPrefixes: string[];
+    /** Prefixos para silenciar */
+    silencedPrefixes: string[];
+    /** Throttling para logs repetitivos */
+    throttleRepetitive: boolean;
+    /** Limite de logs iguais consecutivos */
+    repetitiveThreshold: number;
+}
+declare class DynamicFieldsLogger {
+    private config;
+    private repetitiveMessages;
+    /**
+     * Configura o logger globalmente
+     */
+    configure(config: Partial<LoggerConfig>): void;
+    /**
+     * Habilita debug para um componente específico
+     */
+    enableDebugFor(prefix: string): void;
+    /**
+     * Silencia logs de um componente específico
+     */
+    silencePrefix(prefix: string): void;
+    /**
+     * Log inteligente que considera configuração e throttling
+     */
+    log(level: LoggerLevel, message: string, data?: any): void;
+    /**
+     * Shortcuts para diferentes níveis
+     */
+    error(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    debug(message: string, data?: any): void;
+    trace(message: string, data?: any): void;
+    /**
+     * Limpa contadores de mensagens repetitivas (útil para testes)
+     */
+    clearRepetitiveCounters(): void;
+    private shouldLog;
+    private isRepetitive;
+    private cleanup;
+    private getConsoleFn;
+}
+declare const logger: DynamicFieldsLogger;
+declare function configureDynamicFieldsLogger(config: Partial<LoggerConfig>): void;
+declare function enableDebugForComponent(componentName: string): void;
+declare function silenceComponent(componentName: string): void;
+declare const LoggerPresets: {
+    /** Silencia logs repetitivos mas mantém erros e warnings */
+    PRODUCTION: {
+        level: LoggerLevel;
+        silencedPrefixes: string[];
+        throttleRepetitive: boolean;
+        repetitiveThreshold: number;
+    };
+    /** Habilita debug para componentes específicos */
+    DEVELOPMENT: {
+        level: LoggerLevel;
+        silencedPrefixes: string[];
+        throttleRepetitive: boolean;
+        repetitiveThreshold: number;
+    };
+    /** Máximo de logs para debug profundo */
+    VERBOSE: {
+        level: LoggerLevel;
+        enabledPrefixes: never[];
+        silencedPrefixes: never[];
+        throttleRepetitive: boolean;
+        repetitiveThreshold: number;
+    };
+    /** Silencia quase tudo exceto erros críticos */
+    SILENT: {
+        level: LoggerLevel;
+        silencedPrefixes: string[];
+        throttleRepetitive: boolean;
+        repetitiveThreshold: number;
+    };
+};
+
+/**
+ * @fileoverview Utilitários para mapear JSON Schema para FieldMetadata
+ *
+ * Converte estruturas JSON Schema/OpenAPI com extensões x-ui
+ * para o formato FieldMetadata esperado pelos componentes dinâmicos.
+ *
+ * Lida com campos que não possuem controlType definido,
+ * inferindo tipos apropriados baseado no schema JSON.
+ */
+
+/**
+ * Interface para propriedades JSON Schema básicas
+ */
+interface JsonSchemaProperty {
+    type?: string;
+    format?: string;
+    'x-ui'?: {
+        controlType?: string;
+        label?: string;
+        required?: boolean;
+        [key: string]: any;
+    };
+    $ref?: string;
+    properties?: {
+        [key: string]: JsonSchemaProperty;
+    };
+    items?: JsonSchemaProperty;
+    enum?: any[];
+    [key: string]: any;
+}
+/**
+ * Interface para schema completo com required fields
+ */
+interface JsonSchema {
+    type: string;
+    properties: {
+        [key: string]: JsonSchemaProperty;
+    };
+    required?: string[];
+    [key: string]: any;
+}
+/**
+ * Mapeia um JSON Schema completo para array de FieldMetadata
+ *
+ * @param schema - Schema JSON completo
+ * @returns Array de FieldMetadata prontos para renderização
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   type: 'object',
+ *   properties: {
+ *     name: { type: 'string', 'x-ui': { controlType: 'input', label: 'Nome' } },
+ *     age: { type: 'integer' }, // Sem x-ui, será inferido
+ *     email: { type: 'string', format: 'email' } // Será inferido como email
+ *   },
+ *   required: ['name']
+ * };
+ *
+ * const fields = mapJsonSchemaToFields(schema);
+ * ```
+ */
+declare function mapJsonSchemaToFields(schema: JsonSchema): FieldMetadata[];
+/**
+ * Mapeia uma propriedade individual para FieldMetadata
+ *
+ * @param fieldName - Nome do campo
+ * @param property - Propriedade do schema
+ * @param requiredFields - Lista de campos obrigatórios
+ * @returns FieldMetadata ou null se não puder ser mapeado
+ */
+declare function mapPropertyToFieldMetadata(fieldName: string, property: JsonSchemaProperty, requiredFields?: string[]): FieldMetadata | null;
+/**
+ * Valida se um schema tem a estrutura mínima necessária
+ *
+ * @param schema - Schema a ser validado
+ * @returns true se válido, false caso contrário
+ */
+declare function isValidJsonSchema(schema: any): schema is JsonSchema;
+/**
+ * Função de conveniência para processar metadata JSON mista
+ *
+ * Aceita tanto arrays de FieldMetadata quanto JSON Schema,
+ * normalizando tudo para FieldMetadata[]
+ *
+ * @param input - Array de FieldMetadata ou JsonSchema
+ * @returns Array normalizado de FieldMetadata
+ */
+declare function normalizeFormMetadata(input: FieldMetadata[] | JsonSchema): FieldMetadata[];
+
+export { ActionResolverService, CACHE_TTL, ColorInputComponent, ComponentPreloaderService, ComponentRegistryService, ConfirmDialogComponent, DateInputComponent, DateUtilsService, DatetimeLocalInputComponent, DynamicFieldLoaderDirective, EmailInputComponent, KeyboardShortcutService, LoggerPresets, MAX_LOAD_ATTEMPTS, MaterialAsyncSelectComponent, MaterialAutocompleteComponent, MaterialButtonComponent, MaterialButtonToggleComponent, MaterialCheckboxGroupComponent, MaterialChipsComponent, MaterialColorPickerComponent, MaterialCpfCnpjInputComponent, MaterialCurrencyComponent, MaterialDateRangeComponent, MaterialDatepickerComponent, MaterialFileUploadComponent, MaterialMultiSelectComponent, MaterialMultiSelectTreeComponent, MaterialPriceRangeComponent, MaterialRadioGroupComponent, MaterialRatingComponent, MaterialSearchableSelectComponent, MaterialSelectComponent, MaterialSelectionListComponent, MaterialSlideToggleComponent, MaterialSliderComponent, MaterialTextareaComponent, MaterialTimepickerComponent, MaterialTransferListComponent, MaterialTreeSelectComponent, MonthInputComponent, NumberInputComponent, OptionStore, PDX_COLOR_INPUT_COMPONENT_METADATA, PDX_COLOR_PICKER_COMPONENT_METADATA, PDX_DATETIME_LOCAL_INPUT_COMPONENT_METADATA, PDX_DATE_INPUT_COMPONENT_METADATA, PDX_EMAIL_INPUT_COMPONENT_METADATA, PDX_FIELD_SHELL_COMPONENT_METADATA, PDX_MATERIAL_BUTTON_COMPONENT_METADATA, PDX_MATERIAL_BUTTON_TOGGLE_COMPONENT_METADATA, PDX_MATERIAL_CHECKBOX_GROUP_COMPONENT_METADATA, PDX_MATERIAL_CHIPS_COMPONENT_METADATA, PDX_MATERIAL_COLORPICKER_COMPONENT_METADATA, PDX_MATERIAL_CPF_CNPJ_INPUT_COMPONENT_METADATA, PDX_MATERIAL_CURRENCY_COMPONENT_METADATA, PDX_MATERIAL_DATEPICKER_COMPONENT_METADATA, PDX_MATERIAL_DATE_RANGE_COMPONENT_METADATA, PDX_MATERIAL_FILE_UPLOAD_COMPONENT_METADATA, PDX_MATERIAL_MULTI_SELECT_COMPONENT_METADATA, PDX_MATERIAL_MULTI_SELECT_TREE_COMPONENT_METADATA, PDX_MATERIAL_PRICE_RANGE_COMPONENT_METADATA, PDX_MATERIAL_RADIO_GROUP_COMPONENT_METADATA, PDX_MATERIAL_RANGE_SLIDER_COMPONENT_METADATA, PDX_MATERIAL_RATING_COMPONENT_METADATA, PDX_MATERIAL_SEARCHABLE_SELECT_COMPONENT_METADATA, PDX_MATERIAL_SELECTION_LIST_COMPONENT_METADATA, PDX_MATERIAL_SELECT_COMPONENT_METADATA, PDX_MATERIAL_SLIDER_COMPONENT_METADATA, PDX_MATERIAL_TEXTAREA_COMPONENT_METADATA, PDX_MATERIAL_TIMEPICKER_COMPONENT_METADATA, PDX_MATERIAL_TIME_RANGE_COMPONENT_METADATA, PDX_MATERIAL_TRANSFER_LIST_COMPONENT_METADATA, PDX_MATERIAL_TREE_SELECT_COMPONENT_METADATA, PDX_MONTH_INPUT_COMPONENT_METADATA, PDX_NUMBER_INPUT_COMPONENT_METADATA, PDX_PASSWORD_INPUT_COMPONENT_METADATA, PDX_PHONE_INPUT_COMPONENT_METADATA, PDX_PRELOAD_STATUS_COMPONENT_METADATA, PDX_SEARCH_INPUT_COMPONENT_METADATA, PDX_TEXT_INPUT_COMPONENT_METADATA, PDX_TIME_INPUT_COMPONENT_METADATA, PDX_URL_INPUT_COMPONENT_METADATA, PDX_WEEK_INPUT_COMPONENT_METADATA, PDX_YEAR_INPUT_COMPONENT_METADATA, PasswordInputComponent, PdxColorPickerComponent, PdxMaterialRangeSliderComponent, PdxMaterialTimeRangeComponent, PdxYearInputComponent, PhoneInputComponent, PraxisErrorStateMatcher, PreloadStatusComponent, RETRY_DELAY, SearchInputComponent, SimpleBaseButtonComponent, SimpleBaseInputComponent, SimpleBaseSelectComponent, TextInputComponent, TimeInputComponent, UrlInputComponent, WeekInputComponent, configureDynamicFieldsLogger, createErrorStateMatcher, enableDebugForComponent, getErrorStateMatcherForField, inferErrorStateStrategy, initializeComponentSystem, initializeComponentSystemSync, isBaseDynamicFieldComponent, isLoadingCapableComponent, isValidJsonSchema, isValueBasedComponent, logger, mapJsonSchemaToFields, mapPropertyToFieldMetadata, normalizeFormMetadata, providePraxisDynamicFields, providePraxisDynamicFieldsCore, silenceComponent };
+export type { ActionContext, ActionHandler, ActionResult, BaseDynamicFieldComponent, BaseValidationConfig, ComponentLifecycleEvent, ComponentLoadResult, ComponentRegistration, ConfirmDialogData, ErrorStateStrategy, GradientSettings, IComponentRegistry, JsonSchema, JsonSchemaProperty, LoggerConfig, LoggerLevel, OptionSource, PaletteSettings, PopupSettings, PreloadStatus, RatingIconState, RegistryStats, SelectOption, ShortcutHandler, ShortcutInfo, SimpleSelectMetadata, TimeRangeValue, ValueChangeOptions };