@praxisui/table 0.0.1

package/index.d.ts

@@ -0,0 +1,1771 @@
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, AfterViewInit, OnDestroy, DoCheck, TemplateRef, EventEmitter, ElementRef, DestroyRef, ChangeDetectorRef, SimpleChanges, AfterContentInit, InjectionToken, Provider } from '@angular/core';
+import { MatTableDataSource } from '@angular/material/table';
+import { MatPaginator, PageEvent } from '@angular/material/paginator';
+import { MatSort, Sort } from '@angular/material/sort';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { SelectionModel } from '@angular/cdk/collections';
+import { SettingsPanelService, SettingsValueProvider, SettingsPanelRef } from '@praxisui/settings-panel';
+import * as _praxisui_core from '@praxisui/core';
+import { GlobalConfigService, TableConfig, ConfigStorage, SchemaIdParams, FieldMetadata, FormConfig, GenericCrudService, DynamicFormService, SchemaNormalizerService, ColumnDefinition, ConnectionStorage, IconPickerService, TableConfigService, ComponentDocMeta } from '@praxisui/core';
+import { DatePipe, DecimalPipe, CurrencyPipe, PercentPipe, UpperCasePipe, LowerCasePipe, TitleCasePipe } from '@angular/common';
+import { FormControl, FormGroup, AbstractControl, FormBuilder } from '@angular/forms';
+import { MatDialog } from '@angular/material/dialog';
+import { CdkOverlayOrigin, ConnectedPosition } from '@angular/cdk/overlay';
+import { SpecificationBridgeService, RuleBuilderConfig, RuleBuilderState } from '@praxisui/visual-builder';
+import { PraxisDialog } from '@praxisui/dialog';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as _angular_material_paginator_d_Zo1cMMo4 from '@angular/material/paginator.d-Zo1cMMo4';
+import { MatCheckboxChange } from '@angular/material/checkbox';
+
+type ColumnDataType = 'date' | 'number' | 'currency' | 'percentage' | 'string' | 'boolean' | 'custom';
+interface FormatterConfig {
+    type: ColumnDataType;
+    options: any;
+}
+interface DateFormatterOptions {
+    preset?: string;
+    customFormat?: string;
+}
+interface NumberFormatterOptions {
+    decimalPlaces?: 'fixed' | 'variable';
+    fixedDecimals?: number;
+    minDecimals?: number;
+    maxDecimals?: number;
+    thousandsSeparator?: boolean;
+    signDisplay?: 'auto' | 'always' | 'never' | 'exceptZero';
+}
+interface CurrencyFormatterOptions {
+    currencyCode?: string;
+    currencySymbol?: string;
+    symbolPosition?: 'before' | 'after';
+    symbolSpacing?: boolean;
+    decimalPlaces?: number;
+    thousandsSeparator?: boolean;
+}
+interface PercentageFormatterOptions {
+    decimalPlaces?: number;
+    showSymbol?: boolean;
+    multiplier?: boolean;
+}
+interface StringFormatterOptions {
+    transform?: 'none' | 'uppercase' | 'lowercase' | 'titlecase' | 'capitalize';
+    truncate?: boolean;
+    maxLength?: number;
+    truncateSuffix?: string;
+}
+interface BooleanFormatterOptions {
+    display?: 'true-false' | 'yes-no' | 'active-inactive' | 'on-off' | 'enabled-disabled' | 'custom';
+    trueValue?: string;
+    falseValue?: string;
+}
+interface FormatPreset {
+    label: string;
+    description: string;
+    value: string;
+    example: string;
+}
+declare const DATE_PRESETS: FormatPreset[];
+declare const NUMBER_PRESETS: FormatPreset[];
+declare const CURRENCY_PRESETS: FormatPreset[];
+declare const PERCENTAGE_PRESETS: FormatPreset[];
+declare const STRING_PRESETS: FormatPreset[];
+declare const BOOLEAN_PRESETS: FormatPreset[];
+
+declare class DataFormattingService {
+    private datePipe;
+    private decimalPipe;
+    private currencyPipe;
+    private percentPipe;
+    private upperCasePipe;
+    private lowerCasePipe;
+    private titleCasePipe;
+    private locale;
+    private groupSeparator;
+    private decimalSeparator;
+    constructor(datePipe: DatePipe, decimalPipe: DecimalPipe, currencyPipe: CurrencyPipe, percentPipe: PercentPipe, upperCasePipe: UpperCasePipe, lowerCasePipe: LowerCasePipe, titleCasePipe: TitleCasePipe, locale: string);
+    /**
+     * Apply formatting to a value based on column type and format string
+     */
+    formatValue(value: any, columnType: ColumnDataType, formatString: string): any;
+    /**
+     * Coerce value to the expected type for formatting
+     */
+    private coerceValueToType;
+    /**
+     * Format date values
+     */
+    private formatDate;
+    /**
+     * Format number values
+     */
+    private formatNumber;
+    /**
+     * Format currency values
+     */
+    private formatCurrency;
+    /**
+     * Format percentage values
+     */
+    private formatPercentage;
+    private removeGrouping;
+    /**
+     * Format string values
+     */
+    private formatString;
+    /**
+     * Apply string transformations
+     */
+    private applyStringTransform;
+    /**
+     * Format boolean values
+     */
+    private formatBoolean;
+    /**
+     * Check if formatting is needed for a column
+     */
+    needsFormatting(columnType: ColumnDataType, formatString: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataFormattingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataFormattingService>;
+}
+
+/**
+ * Provides default table configurations.
+ * Applications may override this service to supply product or tenant-specific defaults.
+ */
+declare class TableDefaultsProvider {
+    private readonly global;
+    constructor(global: GlobalConfigService);
+    /**
+     * Returns default configuration for a given table identifier.
+     * @param tableId Table identifier
+     */
+    getDefaults(tableId: string): TableConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableDefaultsProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableDefaultsProvider>;
+}
+
+type FilterConfig = {
+    quickField?: string;
+    alwaysVisibleFields?: string[];
+    placeholder?: string;
+    showAdvanced?: boolean;
+    mode?: 'auto' | 'filter' | 'card';
+    changeDebounceMs?: number;
+    allowSaveTags?: boolean;
+    placeBooleansInActions?: boolean;
+    showToggleLabels?: boolean;
+    alwaysMinWidth?: number;
+    alwaysColsMd?: number;
+    alwaysColsLg?: number;
+    autoSummary?: boolean;
+    confirmTagDelete?: boolean;
+    debugLayout?: boolean;
+    tagColor?: 'primary' | 'accent' | 'warn' | 'basic';
+    tagVariant?: 'filled' | 'outlined';
+    tagButtonColor?: 'primary' | 'accent' | 'warn' | 'basic';
+    actionsButtonColor?: 'primary' | 'accent' | 'warn' | 'basic';
+    actionsVariant?: 'standard' | 'outlined';
+    overlayVariant?: 'card' | 'frosted';
+    overlayBackdrop?: boolean;
+    advancedOpenMode?: 'overlay' | 'modal' | 'drawer';
+};
+declare class FilterConfigService {
+    private storage;
+    private readonly PREFIX;
+    constructor(storage: ConfigStorage);
+    /**
+     * Load a persisted filter configuration for the given key.
+     */
+    load(key: string): FilterConfig | undefined;
+    /**
+     * Persist a filter configuration for the given key.
+     */
+    save(key: string, config: FilterConfig): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilterConfigService>;
+}
+
+type FilterTag = {
+    id: string;
+    label: string;
+    patch: Record<string, any>;
+};
+type I18n = {
+    searchPlaceholder: string;
+    advanced: string;
+    clear: string;
+    apply: string;
+    edit: string;
+    noData: string;
+    quickFieldNotFound: string;
+    saveAsShortcut: string;
+    removeShortcut: string;
+    renameShortcut: string;
+    deleteShortcutConfirm: string;
+    retry: string;
+    errorLoadingFilters: string;
+    settings: string;
+    save: string;
+    cancel: string;
+};
+declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestroy, DoCheck {
+    private crud;
+    private configStorage;
+    private destroyRef;
+    private filterConfig;
+    private settingsPanel;
+    private snackBar;
+    private dialog;
+    private cdr;
+    private dynamicForm;
+    private schemaNormalizer;
+    resourcePath: string;
+    formId: string;
+    mode: 'auto' | 'filter' | 'card';
+    /** Controls outdated schema notifications visibility and channel (only effective in edit mode) */
+    notifyIfOutdated: 'inline' | 'snackbar' | 'both' | 'none';
+    /** Snooze duration for schema outdated notifications (ms), only in edit mode */
+    snoozeMs: number;
+    /** Auto open settings when schema is detected as outdated (only in edit mode) */
+    autoOpenSettingsOnOutdated: boolean;
+    /** Enable edit mode (gates notifications) */
+    editModeEnabled: boolean;
+    value?: Record<string, any>;
+    quickField?: string;
+    alwaysVisibleFields?: string[];
+    tags?: FilterTag[];
+    allowSaveTags?: boolean;
+    persistenceKey?: string;
+    i18n?: Partial<I18n>;
+    changeDebounceMs: number;
+    /** Controla a exibição do botão de configurações dentro do filtro */
+    showFilterSettings: boolean;
+    /** Data used to render the summary card when mode resolves to 'card'. */
+    summary?: any;
+    /** Custom template to render the summary card; receives the summary as $implicit. */
+    summaryTemplate?: TemplateRef<any>;
+    /** Mapping functions to build the native summary card. */
+    summaryMap?: {
+        avatar?: (s: any) => string;
+        title: (s: any) => string;
+        subtitle?: (s: any) => string;
+        badges?: Array<(s: any) => string>;
+    };
+    /** When true and mode='auto', generates a summary from active filters if no summary is provided. */
+    autoSummary: boolean;
+    /** Exibir confirmação ao excluir atalho (tag) */
+    confirmTagDelete: boolean;
+    /** Debug visual de layout/alinhamento */
+    debugLayout: boolean;
+    /** Move toggles/booleans simples para a área de ações */
+    placeBooleansInActions: boolean;
+    /** Mostrar rótulos dos toggles na área de ações */
+    showToggleLabels: boolean;
+    /** Config da grade dos alwaysVisible */
+    alwaysMinWidth: number;
+    alwaysColsMd: number;
+    alwaysColsLg: number;
+    /** Tag theming */
+    tagColor: 'primary' | 'accent' | 'warn' | 'basic';
+    tagVariant: 'filled' | 'outlined';
+    tagButtonColor: 'primary' | 'accent' | 'warn' | 'basic';
+    /** Action buttons theming */
+    actionsButtonColor: 'primary' | 'accent' | 'warn' | 'basic';
+    actionsVariant: 'standard' | 'outlined';
+    /** Overlay appearance */
+    overlayVariant: 'card' | 'frosted';
+    overlayBackdrop: boolean;
+    /** Advanced panel open mode */
+    advancedOpenMode: 'overlay' | 'modal' | 'drawer';
+    submit: EventEmitter<Record<string, any>>;
+    change: EventEmitter<Record<string, any>>;
+    clear: EventEmitter<void>;
+    modeChange: EventEmitter<"filter" | "card">;
+    requestSearch: EventEmitter<Record<string, any>>;
+    tagsChange: EventEmitter<FilterTag[]>;
+    metaChanged: EventEmitter<{
+        schemaId: string;
+        serverHash?: string;
+        context: SchemaIdParams;
+    }>;
+    /** Emits whenever schema outdated state changes (can be used by host) */
+    schemaStatusChange: EventEmitter<{
+        outdated: boolean;
+        serverHash?: string;
+        lastVerifiedAt?: string;
+        formId?: string;
+    }>;
+    quickControl: FormControl<any>;
+    quickForm: FormGroup<Record<string, AbstractControl<any, any, any>>>;
+    alwaysForm: FormGroup<Record<string, FormControl<unknown>>>;
+    quickFieldMeta?: FieldMetadata;
+    quickFieldMetaArray: FieldMetadata[];
+    alwaysVisibleMetas: FieldMetadata[];
+    toggleMetas: FieldMetadata[];
+    advancedConfig?: FormConfig;
+    displayedTags: FilterTag[];
+    private savedTags;
+    editingTagId?: string;
+    editingTagLabel: FormControl<string>;
+    schemaLoading: boolean;
+    schemaError: boolean;
+    private schemaMetas?;
+    private advancedChange$;
+    private alwaysFormReset$;
+    private dto;
+    modeState: 'filter' | 'card';
+    advancedOpen: boolean;
+    advancedValid: boolean;
+    activeFiltersCount: number;
+    saving: boolean;
+    i18nLabels: I18n;
+    placeholder?: string;
+    private configKey;
+    private pendingQuickValue?;
+    private autoSummaryData?;
+    private lastSchemaMeta?;
+    schemaOutdated: boolean;
+    anchorRef?: CdkOverlayOrigin;
+    quickHostRef?: ElementRef<HTMLElement>;
+    overlayOrigin?: CdkOverlayOrigin;
+    overlayWidth: number | string;
+    isMobile: boolean;
+    advancedTitleId: string;
+    advancedPanelId: string;
+    quickFieldMode: 'dynamic' | 'fallback';
+    private isViewInitialized;
+    private pendingQuickFieldSetup;
+    private isQuickFieldSetupInProgress;
+    private _dbgPrevQuickArrayRef;
+    private _dbgPrevAlwaysArrayRef;
+    private _dbgPrevToggleArrayRef;
+    private _dbgPrevQuickFormRef;
+    private _dbgPrevAlwaysFormRef;
+    private _dbgDoCheckCount;
+    private _dbgLastApplyMetasAt;
+    private _dbgLastQuickComponentsAt;
+    private _dbgLastAlwaysComponentsAt;
+    private _dbgLastToggleComponentsAt;
+    overlayPositions: ConnectedPosition[];
+    private quickSub?;
+    private advancedDebouncedSub?;
+    private lastSubmitAt;
+    private resizeObs?;
+    private mutationObs?;
+    private ignoreOutsideUntil;
+    private _resolvedPrefs;
+    private resolveSchemaPrefs;
+    constructor(crud: GenericCrudService<any>, configStorage: ConfigStorage, destroyRef: DestroyRef, filterConfig: FilterConfigService, settingsPanel: SettingsPanelService, snackBar: MatSnackBar, dialog: MatDialog, cdr: ChangeDetectorRef, dynamicForm: DynamicFormService, schemaNormalizer: SchemaNormalizerService);
+    private readonly global;
+    private readonly filterDrawerAdapter;
+    private loadSavedTagsFromStorage;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onWindowResize(): void;
+    private initDynamicObservers;
+    onDocumentEscClose(event: KeyboardEvent): void;
+    private updateOverlayWidth;
+    private computeIsMobile;
+    ngOnChanges(changes: SimpleChanges): void;
+    openSettings(): void;
+    switchToFilter(): void;
+    createTag(label?: string): void;
+    renameTag(tag: FilterTag, label?: string): void;
+    deleteTag(tag: FilterTag): void;
+    startEditTag(tag: FilterTag, $event?: Event): void;
+    commitEditTag(tag: FilterTag, $event?: Event): void;
+    cancelEditTag($event?: Event): void;
+    advancedForm?: FormGroup<Record<string, any>>;
+    private buildFilteredSchemaContext;
+    private loadSchemaViaClient;
+    loadSchema(): void;
+    private applySchemaMetas;
+    ngDoCheck(): void;
+    onQuickComponents(map: Map<string, any>): void;
+    onQuickFieldCreated(ev: any): void;
+    onAlwaysComponents(map: Map<string, any>): void;
+    onToggleComponents(map: Map<string, any>): void;
+    onAdvancedReady(event: {
+        formGroup: FormGroup<Record<string, any>>;
+    }): void;
+    onAdvancedChange(event: {
+        formData: Record<string, any>;
+    }): void;
+    onAdvancedValidityChange(valid: boolean): void;
+    onAdvancedSubmit(event: {
+        formData: Record<string, any>;
+    }): void;
+    private closeAdvanced;
+    get currentSummary(): any;
+    get currentSummaryMap(): {
+        avatar?: (s: any) => string;
+        title: (s: any) => string;
+        subtitle?: (s: any) => string;
+        badges?: Array<(s: any) => string>;
+    } | undefined;
+    private updateAutoSummary;
+    private defaultSummaryMap;
+    private formatValueForBadge;
+    getAdvancedAriaLabel(): string;
+    private getSchemaMetaKey;
+    private getOutdatedIgnoreKey;
+    private getOutdatedSnoozeKey;
+    private getOutdatedNotifiedKey;
+    private isOutdatedIgnored;
+    private getOutdatedSnoozeUntil;
+    private setOutdatedSnooze;
+    private setOutdatedIgnore;
+    private setOutdatedNotified;
+    private wasOutdatedNotified;
+    private verifyServerSchemaVersion;
+    private maybeShowOutdatedSnack;
+    /**
+     * Sets up Quick Field creating a control from metadata and wiring it to quickForm.
+     * Falls back to generic input if creation fails.
+     */
+    private setupQuickField;
+    /**
+     * Ensures fallback setup happens only once, preventing multiple executions.
+     */
+    private ensureFallbackSetup;
+    /**
+     * Fallback method - maintains current behavior with generic string input.
+     * This ensures the system continues working even if dynamic creation fails.
+     */
+    private setupQuickFieldFallback;
+    /**
+     * Applies pending quick value to typed control with proper conversion.
+     */
+    private applyPendingQuickValue;
+    getQuickFieldIcon(): string;
+    getQuickInputType(): string;
+    getQuickInputMode(): string | null;
+    ngOnDestroy(): void;
+    isUserTag(tag: FilterTag): boolean;
+    applyTag(tag: FilterTag): void;
+    onQuickNumericKeypress(event: KeyboardEvent): void;
+    onQuickBlurFormat(): void;
+    private bindQuickControlChanges;
+    private bindAdvancedDebounce;
+    onSubmit(): void;
+    onClear(): void;
+    quickHasValue(): boolean;
+    private isEventFromNestedOverlay;
+    onOverlayDetach(): void;
+    onOverlayOutsideClick(_event: MouseEvent): void;
+    private openAdvancedModal;
+    private openAdvancedDrawer;
+    toggleAdvanced(): void;
+    private saveConfig;
+    private mergeI18n;
+    private persist;
+    private clearPersisted;
+    private persistTags;
+    private syncFormsToDto;
+    onQuickClear(): void;
+    private updateDisplayedTags;
+    private evaluateMode;
+    onGlobalKeydown(event: KeyboardEvent): void;
+    private isEditableElement;
+    private focusQuick;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisFilter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisFilter, "praxis-filter", never, { "resourcePath": { "alias": "resourcePath"; "required": true; }; "formId": { "alias": "formId"; "required": true; }; "mode": { "alias": "mode"; "required": false; }; "notifyIfOutdated": { "alias": "notifyIfOutdated"; "required": false; }; "snoozeMs": { "alias": "snoozeMs"; "required": false; }; "autoOpenSettingsOnOutdated": { "alias": "autoOpenSettingsOnOutdated"; "required": false; }; "editModeEnabled": { "alias": "editModeEnabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "quickField": { "alias": "quickField"; "required": false; }; "alwaysVisibleFields": { "alias": "alwaysVisibleFields"; "required": false; }; "tags": { "alias": "tags"; "required": false; }; "allowSaveTags": { "alias": "allowSaveTags"; "required": false; }; "persistenceKey": { "alias": "persistenceKey"; "required": false; }; "i18n": { "alias": "i18n"; "required": false; }; "changeDebounceMs": { "alias": "changeDebounceMs"; "required": false; }; "showFilterSettings": { "alias": "showFilterSettings"; "required": false; }; "summary": { "alias": "summary"; "required": false; }; "summaryTemplate": { "alias": "summaryTemplate"; "required": false; }; "summaryMap": { "alias": "summaryMap"; "required": false; }; "autoSummary": { "alias": "autoSummary"; "required": false; }; "confirmTagDelete": { "alias": "confirmTagDelete"; "required": false; }; "debugLayout": { "alias": "debugLayout"; "required": false; }; "placeBooleansInActions": { "alias": "placeBooleansInActions"; "required": false; }; "showToggleLabels": { "alias": "showToggleLabels"; "required": false; }; "alwaysMinWidth": { "alias": "alwaysMinWidth"; "required": false; }; "alwaysColsMd": { "alias": "alwaysColsMd"; "required": false; }; "alwaysColsLg": { "alias": "alwaysColsLg"; "required": false; }; "tagColor": { "alias": "tagColor"; "required": false; }; "tagVariant": { "alias": "tagVariant"; "required": false; }; "tagButtonColor": { "alias": "tagButtonColor"; "required": false; }; "actionsButtonColor": { "alias": "actionsButtonColor"; "required": false; }; "actionsVariant": { "alias": "actionsVariant"; "required": false; }; "overlayVariant": { "alias": "overlayVariant"; "required": false; }; "overlayBackdrop": { "alias": "overlayBackdrop"; "required": false; }; "advancedOpenMode": { "alias": "advancedOpenMode"; "required": false; }; }, { "submit": "submit"; "change": "change"; "clear": "clear"; "modeChange": "modeChange"; "requestSearch": "requestSearch"; "tagsChange": "tagsChange"; "metaChanged": "metaChanged"; "schemaStatusChange": "schemaStatusChange"; }, never, never, true, never>;
+}
+
+interface ActionLike {
+    action?: string;
+    id?: string;
+    code?: string;
+    key?: string;
+    name?: string;
+    type?: string;
+    icon?: string;
+    label?: string;
+}
+declare function getActionId(action: ActionLike): string;
+
+interface RowActionConfig extends ActionLike {
+    /**
+     * Identifier of the action. Historically this property was named `id`
+     * in some configurations, so both `action` and `id` are supported.
+     */
+    icon: string;
+    label?: string;
+    priority?: number;
+    alwaysInline?: boolean;
+    visible?: (row: any) => boolean;
+    disabled?: (row: any) => boolean;
+    autoDelete?: boolean;
+    requiresConfirmation?: boolean;
+}
+interface RowActionsBehavior {
+    enabled: boolean;
+    maxInline: number | {
+        xs: number;
+        sm: number;
+        md: number;
+        lg: number;
+    } | 'auto';
+    autoStrategy?: 'measure' | 'breakpoint';
+}
+declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterContentInit, OnDestroy {
+    private crudService;
+    private cdr;
+    private settingsPanel;
+    private formattingService;
+    private specBridge;
+    private configStorage;
+    private connectionStorage;
+    private tableDefaultsProvider;
+    private snackBar;
+    private filterConfig;
+    private pxDialog;
+    private hostRef;
+    private global;
+    config: TableConfig;
+    resourcePath?: string;
+    filterCriteria: any;
+    /** Controls outdated schema notifications visibility and channel (only effective in edit mode) */
+    notifyIfOutdated: 'inline' | 'snackbar' | 'both' | 'none';
+    /** Snooze duration for schema outdated notifications (ms), only in edit mode */
+    snoozeMs: number;
+    /** Auto open settings when schema is detected as outdated (only in edit mode) */
+    autoOpenSettingsOnOutdated: boolean;
+    /** Controls toolbar visibility */
+    showToolbar: boolean;
+    /** Enables new toolbar layout */
+    toolbarV2: boolean;
+    /** Habilita exclusão automática */
+    autoDelete: boolean;
+    /** Enable edit mode */
+    editModeEnabled: boolean;
+    /** Dense mode reduces cell padding */
+    dense: boolean;
+    /** Identifier used for settings storage */
+    tableId: string;
+    /** Habilita visual de debug para alinhamento/layouot */
+    debugLayout: boolean;
+    /** Contexto opcional quando tabela está dentro do componente CRUD */
+    crudContext?: {
+        tableId: string;
+        resourcePath?: string;
+        defaults?: {
+            openMode?: 'modal' | 'route';
+            modal?: Record<string, any>;
+            back?: Record<string, any>;
+        };
+        actions?: Array<{
+            action: string;
+            label?: string;
+            formId?: string;
+            route?: string;
+            openMode?: 'modal' | 'route';
+        }>;
+        /** Nome do campo usado como identificador primário (default: 'id') */
+        idField?: string;
+    };
+    /** Nome do campo usado como identificador primário (default: 'id'). Tem precedência sobre crudContext.idField. */
+    idField?: string;
+    rowClick: EventEmitter<{
+        row: any;
+        index: number;
+    }>;
+    rowAction: EventEmitter<{
+        action: string;
+        row: any;
+    }>;
+    toolbarAction: EventEmitter<{
+        action: string;
+    }>;
+    bulkAction: EventEmitter<{
+        action: string;
+        rows: any[];
+    }>;
+    /** Emits on row double click according to behavior config */
+    rowDoubleClick: EventEmitter<{
+        action: string;
+        row: any;
+    }>;
+    /** Emits whenever schema outdated state changes (can be used by host) */
+    schemaStatusChange: EventEmitter<{
+        outdated: boolean;
+        serverHash?: string;
+        lastVerifiedAt?: string;
+        resourcePath?: string;
+    }>;
+    beforeDelete: EventEmitter<any>;
+    afterDelete: EventEmitter<any>;
+    deleteError: EventEmitter<{
+        row: any;
+        error: unknown;
+    }>;
+    beforeBulkDelete: EventEmitter<any[]>;
+    afterBulkDelete: EventEmitter<any[]>;
+    bulkDeleteError: EventEmitter<{
+        rows: any[];
+        error: unknown;
+    }>;
+    paginator?: MatPaginator;
+    sort?: MatSort;
+    actionsHeaderCell?: ElementRef<HTMLElement>;
+    projectedFilter?: PraxisFilter;
+    dataSource: MatTableDataSource<any, MatPaginator>;
+    displayedColumns: string[];
+    visibleColumns: ColumnDefinition[];
+    private dataSubject;
+    selection: SelectionModel<any>;
+    private pageIndex;
+    private pageSize;
+    private sortState;
+    private hasInitialized;
+    private breakpoints;
+    private measuredInline;
+    private resizeObserver?;
+    readonly getActionId: typeof getActionId;
+    getRowMenuIcon(): string;
+    getRowMenuButtonColor(): string | undefined;
+    getActionsHeaderAlign(): 'start' | 'center' | 'end';
+    getActionsHeaderLabel(): string | undefined;
+    getActionsHeaderIcon(): string | undefined;
+    getActionsHeaderTooltip(): string | undefined;
+    private styleSpecCache;
+    schemaError: boolean;
+    dataError: boolean;
+    errorMessage: string | null;
+    schemaOutdated: boolean;
+    private _resolvedPrefs;
+    private resolveSchemaPrefs;
+    private getOutdatedIgnoreKey;
+    private getOutdatedSnoozeKey;
+    private getOutdatedNotifiedKey;
+    private isOutdatedIgnored;
+    private getOutdatedSnoozeUntil;
+    private setOutdatedSnooze;
+    private setOutdatedIgnore;
+    private setOutdatedNotified;
+    private wasOutdatedNotified;
+    shouldShowOutdatedInline(): boolean;
+    private maybeShowOutdatedSnack;
+    onReconcileRequested(): void;
+    onIgnoreOutdated(): void;
+    onSnoozeOutdated(): void;
+    toggleRow(row: any): void;
+    masterToggle(): void;
+    isAllSelected(): boolean;
+    private isOverflowEnabled;
+    private getMaxInline;
+    private getBreakpointMaxInline;
+    private sortByPriority;
+    isActionVisible(a: any, row: any): boolean;
+    isActionDisabled(a: any, row: any): boolean;
+    trackAction: (_: number, a: RowActionConfig) => string;
+    getInlineRowActions(row: any): any[];
+    getOverflowRowActions(row: any): any[];
+    hasOverflowRowActions(row: any): boolean;
+    private updateMeasuredInline;
+    private setupResizeObserver;
+    private subscriptions;
+    private getIdField;
+    isVirtualized(): boolean;
+    getVirtItemHeight(): number;
+    getVirtBufferSize(): number;
+    getVirtMinHeight(): number | string | undefined;
+    getVirtMinHeightStyle(): string | null;
+    trackByRow: (index: number, row: any) => string | number;
+    private getRowId;
+    constructor(crudService: GenericCrudService<any>, cdr: ChangeDetectorRef, settingsPanel: SettingsPanelService, formattingService: DataFormattingService, specBridge: SpecificationBridgeService, configStorage: ConfigStorage, connectionStorage: ConnectionStorage, tableDefaultsProvider: TableDefaultsProvider, snackBar: MatSnackBar, filterConfig: FilterConfigService, pxDialog: PraxisDialog, hostRef: ElementRef<HTMLElement>, global: GlobalConfigService);
+    openQuickConnect(): void;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private isDebug;
+    private connectionKey;
+    private saveConnection;
+    disconnect(): void;
+    ngAfterViewInit(): void;
+    onPageChange(event: PageEvent): void;
+    onSortChange(event: Sort): void;
+    onRowClicked(row: any, index: number): void;
+    onRowDoubleClicked(row: any, index: number): void;
+    onRowAction(action: string, row: any, event: Event): void;
+    private showConfirmDialog;
+    private executeDeleteAction;
+    onToolbarAction(event: {
+        action: string;
+    }): void;
+    onAdvancedFilterSubmit(criteria: Record<string, any>): void;
+    onAdvancedFilterClear(): void;
+    openTableSettings(): void;
+    private applyTableConfig;
+    onResetPreferences(): void;
+    private applyDataSourceSettings;
+    private setupColumns;
+    private applyDefaultSortIfNone;
+    /**
+     * Performs a lightweight server schema verification using ETag/If-None-Match without
+     * downloading or storing the schema body. Updates config.meta (serverHash/lastVerifiedAt)
+     * and toggles schemaOutdated when a new hash is detected.
+     */
+    private verifyServerSchemaVersion;
+    private loadSchema;
+    private convertFieldToColumn;
+    /**
+     * Check if a value is a valid ColumnDataType
+     */
+    private isValidColumnDataType;
+    /**
+     * Infer column data type from field name patterns when API type is not available
+     * Refined logic to reduce false positives
+     */
+    private inferFieldTypeFromFieldName;
+    private fetchData;
+    retryData(): void;
+    reloadSchema(): void;
+    refetch(): void;
+    /**
+     * Get the cell value for a given row and column
+     * Handles the complete transformation pipeline:
+     * 1. _generatedValueGetter (calculated columns) or regular field access
+     * 2. valueMapping (convert values to display text)
+     * 3. format (data formatting like dates, numbers, currency)
+     */
+    getCellValue(rowData: any, column: ColumnDefinition): any;
+    getCellClasses(rowData: any, column: ColumnDefinition): string[] | undefined;
+    getCellNgStyle(rowData: any, column: ColumnDefinition): Record<string, string> | undefined;
+    private evaluateStyleRule;
+    getRowClasses(rowData: any): string[] | undefined;
+    getRowNgStyle(rowData: any): Record<string, string> | undefined;
+    /**
+     * Apply value mapping to transform raw values into display-friendly text
+     */
+    private applyValueMapping;
+    /**
+     * Safely access nested properties using dot notation
+     */
+    private getNestedPropertyValue;
+    /**
+     * Verifica se a ordenação está habilitada
+     */
+    getSortingEnabled(): boolean;
+    /**
+     * Verifica se a paginação está habilitada
+     */
+    getPaginationEnabled(): boolean;
+    /**
+     * Obtém o comprimento total da paginação
+     */
+    getPaginationLength(): number;
+    /**
+     * Obtém o tamanho da página
+     */
+    getPaginationPageSize(): number;
+    /**
+     * Obtém as opções de tamanho de página
+     */
+    getPaginationPageSizeOptions(): number[];
+    /**
+     * Verifica se deve mostrar botões primeira/última
+     */
+    getPaginationShowFirstLast(): boolean;
+    /**
+     * Verifica se uma funcionalidade está disponível
+     */
+    isFeatureAvailable(feature: string): boolean;
+    /**
+     * Obtém configurações de i18n para o filtro baseado na configuração da tabela
+     */
+    getFilterI18n(): Partial<I18n> | undefined;
+    getIconName(row: any, column: ColumnDefinition): string | null;
+    getIconColor(_row: any, column: ColumnDefinition): string | null;
+    getIconStyle(_row: any, column: ColumnDefinition): Record<string, string> | null;
+    getIconAriaLabel(_row: any, column: ColumnDefinition): string | null;
+    /**
+     * Lightweight, controlled evaluator for string/number expressions using row context.
+     * Accepts values like '= row.status === "OK" ? "primary" : "warn"'.
+     * Falls back safely on error.
+     */
+    private evaluateValueExpr;
+    private coerceExpected;
+    getImageSrc(row: any, column: ColumnDefinition): string | null;
+    getImageAlt(row: any, column: ColumnDefinition): string | null;
+    getImageWidth(column: ColumnDefinition): number | null;
+    getImageHeight(column: ColumnDefinition): number | null;
+    getImageShape(column: ColumnDefinition): 'square' | 'rounded' | 'circle' | undefined;
+    getImageFit(column: ColumnDefinition): 'cover' | 'contain' | undefined;
+    getImageLazy(_row: any, column: ColumnDefinition): boolean;
+    getBadgeText(row: any, column: ColumnDefinition): string | null;
+    getBadgeIcon(row: any, column: ColumnDefinition): string | null;
+    getBadgeClasses(row: any, column: ColumnDefinition): string[];
+    getEffectiveRendererType(row: any, column: ColumnDefinition): 'icon' | 'image' | 'badge' | null;
+    private applyAppearanceVariables;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisTable, "praxis-table", never, { "config": { "alias": "config"; "required": false; }; "resourcePath": { "alias": "resourcePath"; "required": false; }; "filterCriteria": { "alias": "filterCriteria"; "required": false; }; "notifyIfOutdated": { "alias": "notifyIfOutdated"; "required": false; }; "snoozeMs": { "alias": "snoozeMs"; "required": false; }; "autoOpenSettingsOnOutdated": { "alias": "autoOpenSettingsOnOutdated"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; "toolbarV2": { "alias": "toolbarV2"; "required": false; }; "autoDelete": { "alias": "autoDelete"; "required": false; }; "editModeEnabled": { "alias": "editModeEnabled"; "required": false; }; "dense": { "alias": "dense"; "required": false; }; "tableId": { "alias": "tableId"; "required": false; }; "debugLayout": { "alias": "debugLayout"; "required": false; }; "crudContext": { "alias": "crudContext"; "required": false; }; "idField": { "alias": "idField"; "required": false; }; }, { "rowClick": "rowClick"; "rowAction": "rowAction"; "toolbarAction": "toolbarAction"; "bulkAction": "bulkAction"; "rowDoubleClick": "rowDoubleClick"; "schemaStatusChange": "schemaStatusChange"; "beforeDelete": "beforeDelete"; "afterDelete": "afterDelete"; "deleteError": "deleteError"; "beforeBulkDelete": "beforeBulkDelete"; "afterBulkDelete": "afterBulkDelete"; "bulkDeleteError": "bulkDeleteError"; }, ["projectedFilter"], ["[advancedFilter]", "[toolbar]", "[advancedFilter]", "[toolbar]"], true, never>;
+}
+
+declare class PraxisTableToolbar {
+    config?: TableConfig;
+    debugLayout: boolean;
+    toolbarAction: EventEmitter<{
+        action: string;
+    }>;
+    reset: EventEmitter<void>;
+    readonly getActionId: typeof getActionId;
+    emitToolbarAction(event: Event, action: string): void;
+    getStartActions(): _praxisui_core.ToolbarAction[];
+    getOverflowActions(): (_praxisui_core.ToolbarAction | _praxisui_core.BulkAction)[];
+    getExportIcon(format: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisTableToolbar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisTableToolbar, "praxis-table-toolbar", never, { "config": { "alias": "config"; "required": false; }; "debugLayout": { "alias": "debugLayout"; "required": false; }; }, { "toolbarAction": "toolbarAction"; "reset": "reset"; }, never, ["[advancedFilter]", "[toolbar]", "[end-actions]"], true, never>;
+}
+
+interface JsonValidationResult {
+    isValid: boolean;
+    error?: string;
+    config?: TableConfig;
+}
+interface JsonEditorEvent {
+    type: 'apply' | 'format' | 'validation';
+    payload: JsonValidationResult;
+}
+declare class JsonConfigEditorComponent implements OnInit, OnDestroy {
+    private cdr;
+    config: TableConfig | null;
+    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
+    validationChange: EventEmitter<JsonValidationResult>;
+    editorEvent: EventEmitter<JsonEditorEvent>;
+    jsonText: string;
+    isValidJson: boolean;
+    jsonError: string;
+    unknownTopKeys: string[];
+    private destroy$;
+    private jsonTextChanges$;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onJsonTextChange(text: string): void;
+    applyJsonChanges(): void;
+    formatJson(): void;
+    /**
+     * Método público para atualizar o JSON externamente
+     */
+    updateJsonFromConfig(config: TableConfig): void;
+    /**
+     * Método público para obter a configuração atual validada
+     */
+    getCurrentConfig(): TableConfig | null;
+    /**
+     * Método público para verificar se há alterações
+     */
+    hasChanges(): boolean;
+    private validateJson;
+    private updateValidationState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonConfigEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JsonConfigEditorComponent, "json-config-editor", never, { "config": { "alias": "config"; "required": false; }; }, { "configChange": "configChange"; "validationChange": "validationChange"; "editorEvent": "editorEvent"; }, never, never, true, never>;
+}
+
+type FormulaType = 'none' | 'concatenation' | 'arithmetic' | 'nested_property' | 'conditional_mapping' | 'default_value';
+interface FieldSchema {
+    name: string;
+    label: string;
+    type: 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array';
+    path?: string;
+}
+interface FormulaDefinition {
+    type: FormulaType;
+    params: any;
+    _generatedExpression?: string;
+}
+interface ConcatenationParams {
+    fields: string[];
+    separator: string;
+    ignoreEmpty: boolean;
+}
+interface ArithmeticParams {
+    operator: '+' | '-' | '*' | '/';
+    operand1: string | number;
+    operand2: string | number;
+}
+interface NestedPropertyParams {
+    propertyPath: string;
+    fallbackValue?: any;
+}
+interface ConditionalMappingParams {
+    conditionField: string;
+    comparisonValue: any;
+    trueValue: any;
+    falseValue: any;
+    operator?: '===' | '!=' | '>' | '<' | '>=' | '<=';
+}
+interface DefaultValueParams {
+    originalField: string;
+    defaultValue: any;
+}
+type FormulaParams = ConcatenationParams | ArithmeticParams | NestedPropertyParams | ConditionalMappingParams | DefaultValueParams;
+interface FormulaTemplate {
+    type: FormulaType;
+    label: string;
+    description: string;
+    icon: string;
+    parameterSchema: FormulaParameterSchema[];
+}
+interface FormulaParameterSchema {
+    key: string;
+    label: string;
+    type: 'field' | 'text' | 'number' | 'boolean' | 'select' | 'value_input';
+    required: boolean;
+    options?: {
+        value: any;
+        label: string;
+    }[];
+    placeholder?: string;
+    hint?: string;
+    valueType?: 'string' | 'number' | 'boolean' | 'any';
+}
+declare const FORMULA_TEMPLATES: FormulaTemplate[];
+
+interface ColumnChange {
+    type: 'add' | 'remove' | 'update' | 'reorder' | 'global';
+    columnIndex?: number;
+    column?: ColumnDefinition;
+    columns?: ColumnDefinition[];
+    fullConfig?: TableConfig;
+}
+interface ExtendedColumnDefinition extends ColumnDefinition {
+    calculationType?: string;
+    calculationParams?: any;
+    _generatedValueGetter?: string;
+    valueMapping?: {
+        [key: string | number]: string;
+    };
+    format?: string;
+    conditionalStyles?: any[];
+    cellClassCondition?: any;
+    resizable?: boolean;
+    filterable?: boolean;
+}
+declare class ColumnsConfigEditorComponent implements OnInit, OnDestroy {
+    private cdr;
+    config: TableConfig;
+    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
+    columnChange: EventEmitter<ColumnChange>;
+    columns: ExtendedColumnDefinition[];
+    selectedColumnIndex: number;
+    selectedColumn: ExtendedColumnDefinition | null;
+    isV2Config: boolean;
+    availableDataSchema: FieldSchema[];
+    currentFieldSchemas: FieldSchema[];
+    sampleTableData: any[];
+    globalSortableEnabled: boolean;
+    globalAlignment: 'left' | 'center' | 'right' | null;
+    visibilityState: 'all' | 'none' | null;
+    globalResizable: boolean;
+    globalStickyEnabled: boolean;
+    private operationInProgress;
+    private columnOperationSubject;
+    private readonly destroyRef;
+    private destroy$;
+    onlyVisibleRendererFields: boolean;
+    uiRendererType: 'icon' | 'image' | 'badge' | null;
+    private _rendererApplyTimer;
+    rendererFieldOptions: Array<{
+        name: string;
+        label: string;
+        type?: string;
+        isVisible: boolean;
+    }>;
+    uiRendererConditional: boolean;
+    private refreshRendererFieldOptions;
+    getRendererFieldOptions(): Array<{
+        name: string;
+        label: string;
+        type?: string;
+        isVisible: boolean;
+    }>;
+    onRendererFieldToggleChange(): void;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private updateGlobalSettings;
+    private updateVisibilityState;
+    getVisibleColumnsCount(): number;
+    areAllColumnsVisible(): boolean;
+    areAllColumnsHidden(): boolean;
+    onVisibilityChange(state: 'all' | 'none'): void;
+    showAllColumns(): void;
+    hideAllColumns(): void;
+    applyGlobalSortable(enabled: boolean): void;
+    applyGlobalAlignment(alignment: 'left' | 'center' | 'right'): void;
+    applyGlobalResizable(enabled: boolean): void;
+    applyGlobalSticky(enabled: boolean): void;
+    private isColumnExplicitlySet;
+    selectColumn(index: number): void;
+    addNewColumn(): void;
+    removeColumn(index: number, event: Event): void;
+    onColumnReorder(event: CdkDragDrop<ExtendedColumnDefinition[]>): void;
+    private updateColumnOrders;
+    onColumnPropertyChange(): void;
+    isExistingColumn(column: ColumnDefinition): boolean;
+    isCalculatedColumn(column: ColumnDefinition): boolean;
+    hasValueGetterError(column: ColumnDefinition): boolean;
+    private generateAvailableDataSchema;
+    /**
+     * Map ColumnDataType to FieldSchema type
+     */
+    private mapColumnTypeToFieldType;
+    getColumnFormula(column: ColumnDefinition | null): FormulaDefinition | undefined;
+    onFormulaChange(formula: FormulaDefinition): void;
+    onGeneratedExpressionChange(expression: string): void;
+    getMappingCount(column: ColumnDefinition): number;
+    getMappingTooltip(column: ColumnDefinition): string;
+    getMappingPanelDescription(column: ColumnDefinition | null): string;
+    getColumnMapping(column: ColumnDefinition | null): {
+        [key: string | number]: string;
+    };
+    getRendererType(col: ColumnDefinition | null): 'icon' | 'image' | 'badge' | null;
+    onRendererTypeChange(type: 'icon' | 'image' | 'badge' | null): void;
+    onRendererModeClosed(): void;
+    onToggleRendererConditional(enabled: boolean): void;
+    getRendererTypeExpr(): string;
+    setRendererTypeExpr(val: string): void;
+    getRendererIconName(): string;
+    setRendererIconName(v: string): void;
+    getRendererIconNameField(): string;
+    setRendererIconNameField(v: string): void;
+    getRendererIconColor(): string;
+    setRendererIconColor(v: string): void;
+    getRendererIconSize(): number | null;
+    setRendererIconSize(v: number): void;
+    getRendererImageSrc(): string;
+    setRendererImageSrc(v: string): void;
+    getRendererImageSrcField(): string;
+    setRendererImageSrcField(v: string): void;
+    getRendererImageAlt(): string;
+    setRendererImageAlt(v: string): void;
+    getRendererImageAltField(): string;
+    setRendererImageAltField(v: string): void;
+    getRendererImageWidth(): number | null;
+    setRendererImageWidth(v: number): void;
+    getRendererImageHeight(): number | null;
+    setRendererImageHeight(v: number): void;
+    getRendererImageShape(): 'square' | 'rounded' | 'circle' | '';
+    setRendererImageShape(v: any): void;
+    getRendererImageFit(): 'cover' | 'contain' | '';
+    setRendererImageFit(v: any): void;
+    getRendererImageLazy(): boolean;
+    setRendererImageLazy(v: boolean): void;
+    getRendererBadgeText(): string;
+    setRendererBadgeText(v: string): void;
+    getRendererBadgeTextField(): string;
+    setRendererBadgeTextField(v: string): void;
+    getRendererBadgeColor(): string;
+    setRendererBadgeColor(v: string): void;
+    getRendererBadgeVariant(): string;
+    setRendererBadgeVariant(v: string): void;
+    getRendererBadgeIcon(): string;
+    setRendererBadgeIcon(v: string): void;
+    private ensureRenderer;
+    private readonly _emptyMappingRef;
+    getColumnKeyInputType(column: ColumnDefinition | null): 'text' | 'number' | 'boolean';
+    onMappingChange(mapping: {
+        [key: string | number]: string;
+    }): void;
+    get selectedColumnDataType(): ColumnDataType;
+    set selectedColumnDataType(value: ColumnDataType);
+    getColumnDataType(column: ColumnDefinition | null): ColumnDataType;
+    /**
+     * Infer column data type from field name patterns (shared logic with PraxisTable)
+     */
+    private inferFieldTypeFromFieldName;
+    onDataTypeChange(dataType: ColumnDataType): void;
+    showDataFormatter(column: ColumnDefinition | null): boolean;
+    getFormatterIcon(column: ColumnDefinition | null): string;
+    getFormatterPanelDescription(column: ColumnDefinition | null): string;
+    getColumnFormat(column: ColumnDefinition | null): string;
+    onFormatChange(format: string): void;
+    private emitConfigChange;
+    /**
+     * Public method to update columns from external source
+     */
+    updateColumnsFromConfig(config: TableConfig): void;
+    /**
+     * Public method to get current columns
+     */
+    getCurrentColumns(): ExtendedColumnDefinition[];
+    private initializeStyleRules;
+    private generateSampleData;
+    getStyleRulesPanelDescription(column: ColumnDefinition | null): string;
+    onConditionalStylesChanged(styles: any[]): void;
+    onRuleValidated(event: {
+        ruleId: string;
+        result: any;
+    }): void;
+    private updateFieldSchemasForStyleRules;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsConfigEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnsConfigEditorComponent, "columns-config-editor", never, { "config": { "alias": "config"; "required": false; }; }, { "configChange": "configChange"; "columnChange": "columnChange"; }, never, never, true, never>;
+}
+
+interface BehaviorConfigChange {
+    type: 'pagination' | 'sorting' | 'filtering' | 'selection' | 'interaction' | 'general';
+    property: string;
+    value: any;
+    fullConfig: TableConfig;
+}
+declare class BehaviorConfigEditorComponent implements OnInit, OnDestroy {
+    private fb;
+    config: TableConfig;
+    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
+    behaviorChange: EventEmitter<BehaviorConfigChange>;
+    behaviorForm: FormGroup;
+    isV2: boolean;
+    private destroy$;
+    constructor(fb: FormBuilder);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initializeForm;
+    private setupFormListeners;
+    /**
+     * Applies current form values to the configuration immediately.
+     * Useful to flush pending changes before external save operations.
+     */
+    applyFormChanges(): void;
+    private updateConfig;
+    private arrayToString;
+    private stringToArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BehaviorConfigEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BehaviorConfigEditorComponent, "behavior-config-editor", never, { "config": { "alias": "config"; "required": false; }; }, { "configChange": "configChange"; "behaviorChange": "behaviorChange"; }, never, never, true, never>;
+}
+
+interface ToolbarAction {
+    id: string;
+    label: string;
+    icon?: string;
+    type: 'button' | 'icon' | 'fab' | 'menu';
+    color?: 'primary' | 'accent' | 'warn';
+    /** Aparência do botão Material: filled (flat), outlined (stroked), elevated (raised), text, tonal */
+    appearance?: 'filled' | 'outlined' | 'elevated' | 'text' | 'tonal';
+    action: string;
+    position: 'start' | 'end';
+    order?: number;
+    disabled?: boolean;
+    visible?: boolean;
+    shortcut?: string;
+    tooltip?: string;
+    visibleWhen?: string;
+    children?: ToolbarAction[];
+}
+interface RowAction {
+    id: string;
+    label: string;
+    icon: string;
+    action: string;
+    color?: 'primary' | 'accent' | 'warn';
+    tooltip?: string;
+    requiresConfirmation?: boolean;
+    autoDelete?: boolean;
+    separator?: boolean;
+    conditional?: string;
+}
+interface BulkAction {
+    id: string;
+    label: string;
+    icon: string;
+    action: string;
+    color?: 'primary' | 'accent' | 'warn';
+    tooltip?: string;
+    requiresConfirmation?: boolean;
+    autoDelete?: boolean;
+    minSelections?: number;
+    maxSelections?: number;
+}
+interface ToolbarActionsChange {
+    type: 'toolbar' | 'rowActions' | 'bulkActions' | 'export';
+    property: string;
+    value: any;
+    fullConfig: TableConfig;
+}
+declare class ToolbarActionsEditorComponent implements OnInit, OnDestroy, OnChanges {
+    private fb;
+    private iconPicker;
+    config: TableConfig;
+    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
+    toolbarActionsChange: EventEmitter<ToolbarActionsChange>;
+    toolbarForm: FormGroup;
+    isV2: boolean;
+    toolbarActions: ToolbarAction[];
+    rowActions: RowAction[];
+    bulkActions: BulkAction[];
+    editingToolbarActionIndex: number | null;
+    editingRowActionIndex: number | null;
+    editingBulkActionIndex: number | null;
+    private destroy$;
+    constructor(fb: FormBuilder, iconPicker: IconPickerService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private initializeForm;
+    private setupFormListeners;
+    private loadActionsFromConfig;
+    private isAddLike;
+    private findAddToolbarIndex;
+    private ensureAddToolbarAction;
+    private removeAddToolbarAction;
+    private syncAddFormFromActions;
+    private updateConfig;
+    addToolbarAction(): void;
+    editToolbarAction(index: number): void;
+    removeToolbarAction(index: number): void;
+    dropToolbarAction(event: CdkDragDrop<ToolbarAction[]>): void;
+    updateToolbarActions(): void;
+    addRowAction(): void;
+    editRowAction(index: number): void;
+    removeRowAction(index: number): void;
+    dropRowAction(event: CdkDragDrop<RowAction[]>): void;
+    updateRowActions(): void;
+    addBulkAction(): void;
+    editBulkAction(index: number): void;
+    removeBulkAction(index: number): void;
+    dropBulkAction(event: CdkDragDrop<BulkAction[]>): void;
+    updateBulkActions(): void;
+    applyToolbarTemplate(tpl: 'crudAdd', mode: 'replace' | 'merge'): void;
+    applyRowActionsTemplate(tpl: 'crud' | 'editDelete' | 'viewOnly' | 'crudWithBulk', mode: 'replace' | 'merge'): void;
+    private mergeRowActions;
+    private mergeToolbarActions;
+    private mergeBulkActions;
+    pickAddButtonIcon(): Promise<void>;
+    pickActionIcon(index: number): Promise<void>;
+    pickRowActionIcon(index: number): Promise<void>;
+    pickBulkActionIcon(index: number): Promise<void>;
+    pickRowMenuIcon(): Promise<void>;
+    pickRowHeaderIcon(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarActionsEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarActionsEditorComponent, "toolbar-actions-editor", never, { "config": { "alias": "config"; "required": false; }; }, { "configChange": "configChange"; "toolbarActionsChange": "toolbarActionsChange"; }, never, never, true, never>;
+}
+
+interface MessagesLocalizationChange {
+    type: 'messages' | 'localization' | 'formatting';
+    property: string;
+    value: any;
+    fullConfig: TableConfig;
+}
+declare class MessagesLocalizationEditorComponent implements OnInit, OnDestroy {
+    private fb;
+    config: TableConfig;
+    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
+    messagesLocalizationChange: EventEmitter<MessagesLocalizationChange>;
+    messagesForm: FormGroup;
+    isV2: boolean;
+    private destroy$;
+    constructor(fb: FormBuilder);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private initializeForm;
+    private setupFormListeners;
+    private updateConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessagesLocalizationEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessagesLocalizationEditorComponent, "messages-localization-editor", never, { "config": { "alias": "config"; "required": false; }; }, { "configChange": "configChange"; "messagesLocalizationChange": "messagesLocalizationChange"; }, never, never, true, never>;
+}
+
+declare class PraxisTableConfigEditor implements OnInit, OnDestroy, SettingsValueProvider {
+    private cdr;
+    private configService;
+    private panelData;
+    private panelRef?;
+    behaviorEditor?: BehaviorConfigEditorComponent;
+    crudEditor?: any;
+    sections: {
+        id: string;
+        label: string;
+        icon: string;
+    }[];
+    activeSectionIndex: number;
+    private originalConfig;
+    editedConfig: TableConfig;
+    resourcePath: string;
+    private initialResourcePath;
+    idField: string;
+    private initialIdField;
+    crudContext?: {
+        tableId: string;
+        resourcePath?: string;
+        /** Nome do campo identificador do recurso (ex.: 'id', 'codigo'). */
+        idField?: string;
+        defaults?: {
+            openMode?: 'modal' | 'route';
+            modal?: Record<string, any>;
+            back?: Record<string, any>;
+        };
+        actions?: Array<{
+            action: string;
+            label?: string;
+            formId?: string;
+            route?: string;
+            openMode?: 'modal' | 'route';
+        }>;
+    };
+    serverIdField?: string;
+    private serverSchemaHash?;
+    idFieldDiverges: boolean;
+    schemaHashDiverges: boolean;
+    isV2Config: boolean;
+    canSave: boolean;
+    hasErrors: boolean;
+    hasSuccess: boolean;
+    statusMessage: string;
+    private isValidJson;
+    isDirty$: BehaviorSubject<boolean>;
+    isValid$: BehaviorSubject<boolean>;
+    isBusy$: BehaviorSubject<boolean>;
+    columnMetas: FieldMetadata[];
+    constructor(cdr: ChangeDetectorRef, configService: TableConfigService, panelData: any, panelRef?: SettingsPanelRef | undefined);
+    ngOnInit(): void;
+    onJsonConfigChange(newConfig: TableConfig): void;
+    onJsonValidationChange(result: JsonValidationResult): void;
+    onJsonEditorEvent(event: JsonEditorEvent): void;
+    onColumnsConfigChange(newConfig: TableConfig): void;
+    onColumnChange(change: ColumnChange): void;
+    onFilterSettingsChange(cfg: FilterConfig): void;
+    private updateColumnMetas;
+    private updateCanSaveState;
+    private showSuccess;
+    private showError;
+    private clearMessages;
+    /**
+     * Normaliza uma configuração de tabela para comparação consistente
+     * Remove propriedades undefined, ordena arrays e objetos de forma consistente
+     */
+    private normalizeTableConfig;
+    /**
+     * Realiza comparação profunda de objetos, ignorando ordem de propriedades
+     */
+    private deepEqual;
+    getSettingsValue(): TableConfig;
+    onResourcePathChange(val: string): void;
+    onIdFieldChange(val: string): void;
+    onReconcileIdField(): void;
+    onAcceptServerHash(): void;
+    onVisualRulesConfigChange(newConfig: TableConfig): void;
+    reset(): void;
+    onResetToDefaults(): void;
+    /**
+     * Called by the settings panel when the user chooses to persist changes.
+     *
+     * The returned configuration is sent back to the panel via
+     * `panelRef.save(returnedConfig)` and subsequently emitted on `saved$`.
+     * Returning the current `TableConfig` is therefore required for the table to
+     * apply the new settings.
+     */
+    onSave(): TableConfig | undefined;
+    /**
+     * Atualiza as flags de versão baseado na configuração atual
+     * Esta versão pode modificar a configuração, deve ser usada após mudanças
+     */
+    private updateConfigurationVersion;
+    /**
+     * Apenas detecta a versão da configuração sem modificá-la
+     * Usado durante inicialização para evitar marcar como dirty
+     */
+    private updateConfigurationVersionInfo;
+    /**
+     * Retorna a configuração atual (unified architecture)
+     */
+    getV1Config(): TableConfig;
+    /**
+     * Legacy migration handler. In the unified architecture this is a no-op
+     * and simply refreshes the configuration version information.
+     */
+    onMigrateToV2(): void;
+    /**
+     * Verifica se um recurso está disponível na versão atual
+     */
+    isFeatureAvailable(feature: string): boolean;
+    onBehaviorConfigChange(newConfig: TableConfig): void;
+    onBehaviorChange(change: BehaviorConfigChange): void;
+    onToolbarActionsConfigChange(newConfig: TableConfig): void;
+    onToolbarActionsChange(change: ToolbarActionsChange): void;
+    onMessagesLocalizationConfigChange(newConfig: TableConfig): void;
+    onMessagesLocalizationChange(change: MessagesLocalizationChange): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisTableConfigEditor, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisTableConfigEditor, "praxis-table-config-editor", never, {}, {}, never, never, true, never>;
+}
+
+interface FilterDrawerOpenConfig {
+    resourcePath: string;
+    formId: string;
+    config: any;
+    initialDto?: Record<string, any>;
+    title?: string;
+    onSubmit(dto: Record<string, any>): void;
+    onClose?(): void;
+}
+interface FilterDrawerAdapter {
+    open(config: FilterDrawerOpenConfig): Promise<void> | void;
+}
+declare const FILTER_DRAWER_ADAPTER: InjectionToken<FilterDrawerAdapter>;
+
+declare class DataFormatterComponent implements OnInit, OnChanges {
+    private cdr;
+    private formattingService;
+    columnType: ColumnDataType;
+    currentFormat: string;
+    formatChange: EventEmitter<string>;
+    datePresets: FormatPreset[];
+    numberPresets: FormatPreset[];
+    currencyPresets: FormatPreset[];
+    percentagePresets: FormatPreset[];
+    stringPresets: FormatPreset[];
+    booleanPresets: FormatPreset[];
+    selectedPreset: string;
+    customFormat: string;
+    decimalMode: string;
+    variableRange: string;
+    thousandsSeparator: boolean;
+    currencyCode: string;
+    currencyDecimals: string;
+    currencySymbol: boolean;
+    currencyThousands: boolean;
+    percentageDecimals: string;
+    percentageMultiplier: boolean;
+    stringTransform: string;
+    enableTruncate: boolean;
+    truncateLength: number;
+    truncateSuffix: string;
+    booleanDisplay: string;
+    customTrueValue: string;
+    customFalseValue: string;
+    previewValue: string;
+    constructor(cdr: ChangeDetectorRef, formattingService: DataFormattingService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getTypeIcon(): string;
+    getTypeLabel(): string;
+    getTypeDescription(): string;
+    private parseCurrentFormat;
+    private setDefaultValues;
+    private parseDateFormat;
+    private parseNumberFormat;
+    private parseCurrencyFormat;
+    private parsePercentageFormat;
+    private parseStringFormat;
+    private parseBooleanFormat;
+    onPresetChange(): void;
+    onCustomFormatChange(): void;
+    onDecimalModeChange(): void;
+    onFormatOptionChange(): void;
+    onTruncateToggle(): void;
+    onBooleanDisplayChange(): void;
+    private generateFormatString;
+    private generatePreview;
+    /**
+     * Get appropriate sample value for each data type
+     */
+    private getSampleValue;
+    /**
+     * Get the current format string based on component state
+     */
+    private getCurrentFormatString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataFormatterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataFormatterComponent, "data-formatter", never, { "columnType": { "alias": "columnType"; "required": false; }; "currentFormat": { "alias": "currentFormat"; "required": false; }; }, { "formatChange": "formatChange"; }, never, never, true, never>;
+}
+
+interface ValueMappingPair {
+    key: string | number | boolean;
+    value: string;
+    keyInput: string;
+    hasError?: boolean;
+    errorMessage?: string;
+}
+declare class ValueMappingEditorComponent implements OnInit, OnChanges {
+    private cdr;
+    private dialog;
+    private snackBar;
+    currentMapping: {
+        [key: string | number]: string;
+    };
+    keyInputType: 'text' | 'number' | 'boolean';
+    labelKey: string;
+    labelValue: string;
+    mappingChange: EventEmitter<{
+        [key: string]: string;
+        [key: number]: string;
+    }>;
+    mappingPairs: ValueMappingPair[];
+    dataSource: MatTableDataSource<ValueMappingPair, _angular_material_paginator_d_Zo1cMMo4.M>;
+    displayedColumns: string[];
+    showImportDialog: boolean;
+    importJsonText: string;
+    importError: string;
+    constructor(cdr: ChangeDetectorRef, dialog: MatDialog, snackBar: MatSnackBar);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private initializeMappingPairs;
+    private updateDataSource;
+    private parseKeyByType;
+    isKeyTruthy(pair: ValueMappingPair): boolean;
+    getKeyPlaceholder(): string;
+    addNewPair(): void;
+    removePair(index: number): void;
+    onKeyChange(index: number, value: string): void;
+    onBooleanKeyChange(index: number, change: MatCheckboxChange): void;
+    onValueChange(index: number, value: string): void;
+    private validateAndEmitMapping;
+    exportToJson(): void;
+    importFromJson(): void;
+    cancelImport(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValueMappingEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ValueMappingEditorComponent, "value-mapping-editor", never, { "currentMapping": { "alias": "currentMapping"; "required": false; }; "keyInputType": { "alias": "keyInputType"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "labelValue": { "alias": "labelValue"; "required": false; }; }, { "mappingChange": "mappingChange"; }, never, never, true, never>;
+}
+
+declare class FilterSettingsComponent implements OnChanges {
+    private fb;
+    metadata: FieldMetadata[];
+    settings: FilterConfig | undefined;
+    configKey?: string;
+    settingsChange: EventEmitter<FilterConfig>;
+    form: FormGroup<{
+        quickField: FormControl<string | null>;
+        alwaysVisibleFields: FormControl<string[]>;
+        placeholder: FormControl<string>;
+        showAdvanced: FormControl<boolean>;
+        mode: FormControl<'auto' | 'filter' | 'card'>;
+        changeDebounceMs: FormControl<number>;
+        allowSaveTags: FormControl<boolean>;
+        tagColor: FormControl<'primary' | 'accent' | 'warn' | 'basic'>;
+        tagVariant: FormControl<'filled' | 'outlined'>;
+        tagButtonColor: FormControl<'primary' | 'accent' | 'warn' | 'basic'>;
+        actionsButtonColor: FormControl<'primary' | 'accent' | 'warn' | 'basic'>;
+        actionsVariant: FormControl<'standard' | 'outlined'>;
+        placeBooleansInActions: FormControl<boolean>;
+        showToggleLabels: FormControl<boolean>;
+        alwaysMinWidth: FormControl<number>;
+        alwaysColsMd: FormControl<number>;
+        alwaysColsLg: FormControl<number>;
+        autoSummary: FormControl<boolean>;
+        confirmTagDelete: FormControl<boolean>;
+        debugLayout: FormControl<boolean>;
+        overlayVariant: FormControl<'card' | 'frosted'>;
+        overlayBackdrop: FormControl<boolean>;
+        advancedOpenMode: FormControl<'overlay' | 'modal' | 'drawer'>;
+    }>;
+    /**
+     * Emits true when form has changes and is valid, enabling the save button
+     */
+    canSave$: Observable<boolean>;
+    isDirty$: Observable<boolean>;
+    isValid$: Observable<boolean>;
+    isBusy$: Observable<boolean>;
+    private initialSettings;
+    private readonly storage;
+    private readonly injectedData;
+    /** Clears persisted preferences for this filter, falling back to globals. */
+    resetPreferences(): void;
+    constructor(fb: FormBuilder);
+    tags: FilterTag[];
+    exportJson: string;
+    newTagLabel: string;
+    newTagPatchText: string;
+    private tagsKey;
+    loadTags(): void;
+    saveTags(): void;
+    clearTags(): void;
+    removeTag(index: number): void;
+    renameTag(index: number, value: string): void;
+    importTags(): void;
+    addTag(): void;
+    addTagFromCurrent(): void;
+    dropAlwaysVisible(event: CdkDragDrop<string[]>): void;
+    presets: {
+        key: string;
+        label: string;
+        values: Partial<FilterConfig>;
+    }[];
+    applyPreset(key: string): void;
+    getFieldLabel(name: string): string;
+    hasCurrentDto(): boolean;
+    renameTagPrompt(index: number): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getSettingsValue(): FilterConfig;
+    reset(): void;
+    private clampDebounce;
+    private clampMinWidth;
+    private clampColsMd;
+    private clampColsLg;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterSettingsComponent, "filter-settings", never, { "metadata": { "alias": "metadata"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; "configKey": { "alias": "configKey"; "required": false; }; }, { "settingsChange": "settingsChange"; }, never, never, true, never>;
+}
+
+declare class TableVisualRulesEditorComponent {
+    config: TableConfig;
+    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
+    columns: ColumnDefinition[];
+    selectedField?: string;
+    selectedColumn?: ColumnDefinition | null;
+    scope: 'column' | 'row';
+    builderConfig: RuleBuilderConfig | null;
+    currentRulesState?: RuleBuilderState;
+    compiledRules: Array<{
+        condition: string;
+        cssClass?: string;
+        style?: Record<string, string>;
+        _styleText?: string;
+        display?: string;
+    }>;
+    private rulesUpdateTimer;
+    hasPending: boolean;
+    private effectsPaused;
+    private destroyed;
+    private suppressRulesUntil;
+    private lastCompiledJson;
+    private lastStateJson;
+    private lastColumnsSignature;
+    classPresets: {
+        label: string;
+        value: string;
+    }[];
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    onScopeChange(scope: 'column' | 'row'): void;
+    onSelectColumn(field: string): void;
+    private resolveSelectedTarget;
+    onRulesChanged(state: RuleBuilderState): void;
+    private applyRulesState;
+    onEffectChanged(): void;
+    onStyleTextChanged(r: any): void;
+    private mergeEffects;
+    private materializeCompiledRules;
+    private stringifyStyle;
+    private parseStyleText;
+    onPresetSelected(r: any, value: string): void;
+    private mergePendingIntoCompiled;
+    private prettifyCondition;
+    private createBuilderConfig;
+    private mapType;
+    private maybeRebuildBuilderConfig;
+    applyEffects(): void;
+    discardEffects(): void;
+    pauseEffects(on: boolean): void;
+    trackRule(index: number, r: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableVisualRulesEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableVisualRulesEditorComponent, "table-visual-rules-editor", never, { "config": { "alias": "config"; "required": false; }; }, { "configChange": "configChange"; }, never, never, true, never>;
+}
+
+interface ConditionalStyleRule {
+    condition: string;
+    cssClass?: string;
+    style?: {
+        [key: string]: string;
+    };
+    description?: string;
+}
+declare function ruleBuilderStateToConditionalStyles(state: RuleBuilderState | null | undefined): ConditionalStyleRule[];
+declare function conditionalStylesToBuilderState(styles: ConditionalStyleRule[] | null | undefined): RuleBuilderState;
+
+declare class FormulaGeneratorService {
+    /**
+     * Generates a safe JavaScript expression from a formula definition
+     */
+    generateExpression(formula: FormulaDefinition): string;
+    /**
+     * Validates a formula definition
+     */
+    validateFormula(formula: FormulaDefinition): {
+        valid: boolean;
+        errors: string[];
+    };
+    private generateConcatenationExpression;
+    private generateArithmeticExpression;
+    private generateNestedPropertyExpression;
+    private generateConditionalMappingExpression;
+    private generateDefaultValueExpression;
+    private validateConcatenationParams;
+    private validateArithmeticParams;
+    private validateNestedPropertyParams;
+    private validateConditionalMappingParams;
+    private validateDefaultValueParams;
+    private sanitizeFieldName;
+    private sanitizeStringValue;
+    private sanitizeValue;
+    private sanitizeOperator;
+    private parseOperand;
+    private generateSafePropertyPath;
+    private isValidPropertyPath;
+    /**
+     * Get a sample data object for testing formulas
+     */
+    getSampleData(): any;
+    /**
+     * Test a formula with sample data
+     */
+    testFormula(formula: FormulaDefinition, sampleData?: any): {
+        success: boolean;
+        result?: any;
+        error?: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormulaGeneratorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormulaGeneratorService>;
+}
+
+declare class VisualFormulaBuilderComponent implements OnInit, OnChanges {
+    private formulaGenerator;
+    private cdr;
+    availableDataSchema: FieldSchema[];
+    currentFormula?: FormulaDefinition;
+    formulaChange: EventEmitter<FormulaDefinition>;
+    generatedExpressionChange: EventEmitter<string>;
+    formulaTemplates: FormulaTemplate[];
+    selectedFormulaType: FormulaType;
+    selectedTemplate?: FormulaTemplate;
+    currentParams: any;
+    generatedExpressionValue: string;
+    validationErrors: string[];
+    valueInputStates: {
+        [key: string]: {
+            mode: 'field' | 'literal';
+            value: any;
+        };
+    };
+    showSampleData: boolean;
+    testResult?: {
+        success: boolean;
+        result?: any;
+        error?: string;
+    };
+    sampleDataJson: string;
+    constructor(formulaGenerator: FormulaGeneratorService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private initializeFromCurrentFormula;
+    onFormulaTypeChange(formulaType: FormulaType): void;
+    private updateSelectedTemplate;
+    onParameterChange(): void;
+    private generateAndEmitExpression;
+    get generatedExpression(): string;
+    isMultiSelectField(paramKey: string): boolean;
+    getFieldTypeIcon(fieldType: string): string;
+    testFormula(): void;
+    formatTestResult(result: any): string;
+    getValueInputMode(paramKey: string): 'field' | 'literal';
+    getValueInputValue(paramKey: string): any;
+    onValueInputModeChange(paramKey: string, mode: 'field' | 'literal'): void;
+    onValueInputFieldChange(paramKey: string, fieldName: string): void;
+    onValueInputLiteralChange(paramKey: string, value: string): void;
+    onValueInputBooleanChange(paramKey: string, change: MatCheckboxChange): void;
+    private updateParameterFromValueInput;
+    private initializeValueInputStates;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisualFormulaBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisualFormulaBuilderComponent, "visual-formula-builder", never, { "availableDataSchema": { "alias": "availableDataSchema"; "required": false; }; "currentFormula": { "alias": "currentFormula"; "required": false; }; }, { "formulaChange": "formulaChange"; "generatedExpressionChange": "generatedExpressionChange"; }, never, never, true, never>;
+}
+
+/** Metadata for PraxisTable component */
+declare const PRAXIS_TABLE_COMPONENT_METADATA: ComponentDocMeta;
+/**
+ * Provider que registra o metadata no ComponentMetadataRegistry durante o bootstrap.
+ */
+declare function providePraxisTableMetadata(): Provider;
+
+export { BOOLEAN_PRESETS, BehaviorConfigEditorComponent, CURRENCY_PRESETS, ColumnsConfigEditorComponent, DATE_PRESETS, DataFormatterComponent, DataFormattingService, FILTER_DRAWER_ADAPTER, FORMULA_TEMPLATES, FilterConfigService, FilterSettingsComponent, FormulaGeneratorService, JsonConfigEditorComponent, MessagesLocalizationEditorComponent, NUMBER_PRESETS, PERCENTAGE_PRESETS, PRAXIS_TABLE_COMPONENT_METADATA, PraxisFilter, PraxisTable, PraxisTableConfigEditor, PraxisTableToolbar, STRING_PRESETS, TableDefaultsProvider, TableVisualRulesEditorComponent, ToolbarActionsEditorComponent, ValueMappingEditorComponent, VisualFormulaBuilderComponent, conditionalStylesToBuilderState, getActionId, providePraxisTableMetadata, ruleBuilderStateToConditionalStyles };
+export type { ActionLike, ArithmeticParams, BehaviorConfigChange, BooleanFormatterOptions, BulkAction, ColumnChange, ColumnDataType, ConcatenationParams, ConditionalMappingParams, ConditionalStyleRule, CurrencyFormatterOptions, DateFormatterOptions, DefaultValueParams, FieldSchema, FilterConfig, FilterDrawerAdapter, FilterDrawerOpenConfig, FilterTag, FormatPreset, FormatterConfig, FormulaDefinition, FormulaParameterSchema, FormulaParams, FormulaTemplate, FormulaType, I18n, JsonEditorEvent, JsonValidationResult, MessagesLocalizationChange, NestedPropertyParams, NumberFormatterOptions, PercentageFormatterOptions, RowAction, RowActionConfig, RowActionsBehavior, StringFormatterOptions, ToolbarAction, ToolbarActionsChange, ValueMappingPair };