@praxisui/table 8.0.0-beta.0 → 8.0.0-beta.100

package/{index.d.ts → types/praxisui-table.d.ts}

@@ -1,25 +1,27 @@
+import * as _praxisui_core from '@praxisui/core';
+import { TableToolbarAppearanceConfig, TableConfig, LoggerService, PraxisI18nService, TableToolbarAppearanceVariant, TableToolbarAppearanceDensity, TableToolbarAppearanceShape, TableToolbarAppearanceDivider, TableToolbarTokenName, GlobalConfigService, AsyncConfigStorage, FieldMetadata, SchemaIdParams, FormConfig, GenericCrudService, DynamicFormService, SchemaNormalizerService, ComponentKeyService, ComponentDocMeta, PraxisTextValue, PraxisAnalyticsProjection, PraxisDataQueryContext, ApiUrlConfig, PraxisQueryFilterExpression, RecordRelatedSurfaceContextPack, LoadingState, RestApiLinks, ColumnDefinition, RichBlockNode, ResourceCapabilityDigest, ConnectionStorage, LoadingOrchestrator, GlobalActionService, PraxisLoadingRenderer, TableDetailRichListNode, TableDetailCardGridNode, TableDetailCardGridCardNode, TableDetailTimelineNode, JsonLogicDataRecord, TableDetailListItemAction, TableDetailActionBarNode, TableDetailActionBarAction, TableDetailRefNode, TableDetailTemplateRefNode, TableDetailDiagramEmbedNode, TableDetailEmbedAction, PraxisExportScope, GlobalActionRef, PraxisRuntimeGlobalActionEffect, ResourceActionCatalogItem, ResourceSurfaceCatalogItem, JsonLogicExpression, GlobalActionCatalogEntry, IconPickerService, SurfaceOpenPayload, GlobalActionField, FieldDefinition, PraxisRuntimeConditionalEffectRule, PraxisJsonLogicService, TableConfigService, SettingsValueProvider as SettingsValueProvider$1, AnalyticsSchemaContractService, AnalyticsPresentationResolver, RichPresenterNode, RichComposeNode, ComponentAuthoringManifest, AiCapability, AiCapabilityCategory, AiValueKind, AiCapabilityCatalog } from '@praxisui/core';
 import * as i0 from '@angular/core';
-import { OnDestroy, EventEmitter, ElementRef, OnInit, OnChanges, AfterViewInit, DoCheck, DestroyRef, ChangeDetectorRef, NgZone, SimpleChanges, Provider, AfterContentInit } from '@angular/core';
+import { InjectionToken, OnDestroy, EventEmitter, ElementRef, Provider, OnInit, OnChanges, AfterViewInit, DoCheck, DestroyRef, ChangeDetectorRef, NgZone, SimpleChanges, ComponentRef, AfterContentInit, Injector } from '@angular/core';
 import { ActivatedRoute } from '@angular/router';
 import { MatTable, MatTableDataSource } from '@angular/material/table';
-import { MatPaginator, PageEvent } from '@angular/material/paginator';
+import * as _angular_material_paginator from '@angular/material/paginator';
+import { MatPaginatorSelectConfig, 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 { CdkDragDrop, CdkDragEnd, CdkDrag, CdkDropList } from '@angular/cdk/drag-drop';
 import { BehaviorSubject, Subscription, Observable } from 'rxjs';
 import { SettingsPanelService, SettingsValueProvider } from '@praxisui/settings-panel';
-import * as _praxisui_core from '@praxisui/core';
-import { TableConfig, LoggerService, GlobalConfigService, AsyncConfigStorage, FieldMetadata, SchemaIdParams, FormConfig, GenericCrudService, DynamicFormService, SchemaNormalizerService, ComponentKeyService, ComponentDocMeta, LoadingState, RestApiLinks, ColumnDefinition, RichBlockNode, ConnectionStorage, ResourceDiscoveryService, LoadingOrchestrator, PraxisLoadingRenderer, TableDetailRichListNode, TableDetailCardGridNode, TableDetailCardGridCardNode, TableDetailTimelineNode, JsonLogicDataRecord, TableDetailListItemAction, TableDetailActionBarNode, TableDetailActionBarAction, TableDetailRefNode, TableDetailTemplateRefNode, TableDetailDiagramEmbedNode, TableDetailEmbedAction, ResourceActionCatalogItem, JsonLogicExpression, GlobalActionSpec, IconPickerService, SurfaceOpenPayload, GlobalActionField, FieldDefinition, PraxisJsonLogicService, TableConfigService, PraxisTextValue, PraxisAnalyticsProjection, PraxisDataQueryContext, ApiUrlConfig, AnalyticsSchemaContractService, AnalyticsPresentationResolver, RichPresenterNode, RichComposeNode, PraxisI18nService, AiCapabilityCategory, AiValueKind, AiCapability, AiCapabilityCatalog } from '@praxisui/core';
 import { FormGroup, FormControl, FormBuilder } from '@angular/forms';
 import { MatDialog } from '@angular/material/dialog';
+import { BaseDynamicFieldComponent } from '@praxisui/dynamic-fields';
 import { CdkOverlayOrigin, ConnectedPosition } from '@angular/cdk/overlay';
+import { MatSelect } from '@angular/material/select';
 import { PraxisDialog } from '@praxisui/dialog';
+import { PraxisAssistantVoiceInputMode, PraxisAssistantTurnViewState, PraxisAssistantShellLayout, PraxisAssistantShellLabels, PraxisAssistantSessionSnapshot, PraxisAssistantShellQuickReply, PraxisAssistantRecommendedIntent, PraxisAssistantShellMessage } from '@praxisui/ai';
+import { HttpClient } from '@angular/common/http';
 import { MatTabChangeEvent } from '@angular/material/tabs';
-import * as _praxisui_table_rule_builder from '@praxisui/table-rule-builder';
 import { RuleEffectDefinition } from '@praxisui/table-rule-builder';
-import { HttpClient } from '@angular/common/http';
-import * as _angular_material_paginator_d_Zo1cMMo4 from '@angular/material/paginator.d-Zo1cMMo4';
 import { MatCheckboxChange } from '@angular/material/checkbox';
 
 interface ActionLike {
@@ -34,23 +36,32 @@ interface ActionLike {
 }
 declare function getActionId(action: ActionLike): string;
 
+declare const PRAXIS_TABLE_TOOLBAR_DEFAULT_APPEARANCE: InjectionToken<TableToolbarAppearanceConfig>;
+declare const PRAXIS_TABLE_TOOLBAR_TOKEN_PRESETS: InjectionToken<Record<string, TableToolbarAppearanceConfig>>;
+declare function providePraxisTableToolbarAppearance(appearance: TableToolbarAppearanceConfig, presets?: Record<string, TableToolbarAppearanceConfig>): Provider[];
 declare class PraxisTableToolbar implements OnDestroy {
     private hostRef;
     private logger?;
+    private i18n?;
+    private defaultAppearance?;
+    private tokenPresets?;
     config?: TableConfig;
+    appearance?: TableToolbarAppearanceConfig | null;
     backgroundColor: string | null;
     placement: 'header' | 'footer';
     showMain: boolean;
     showActionsGroup: boolean;
     showEndActions: boolean;
     showMobileActions: boolean;
-    showReset: boolean;
+    exportBusy: boolean;
     evaluationContext: Record<string, any> | null;
     toolbarAction: EventEmitter<{
         action: string;
         actionConfig?: any;
     }>;
-    reset: EventEmitter<void>;
+    exportAction: EventEmitter<{
+        format: string;
+    }>;
     readonly getActionId: typeof getActionId;
     private readonly jsonLogic;
     private readonly validToolbarActionTypes;
@@ -62,8 +73,25 @@ declare class PraxisTableToolbar implements OnDestroy {
     private readonly warnedShortcutConflicts;
     private fallbackLogger?;
     private fallbackLoggerEnvironment;
-    constructor(hostRef?: ElementRef<HTMLElement> | null, logger?: LoggerService | undefined);
+    constructor(hostRef?: ElementRef<HTMLElement> | null, logger?: LoggerService | undefined, i18n?: PraxisI18nService | undefined, defaultAppearance?: TableToolbarAppearanceConfig | undefined, tokenPresets?: Record<string, TableToolbarAppearanceConfig> | undefined);
+    getToolbarAriaLabel(): string;
+    getToolbarLeadingLabel(): string;
+    getToolbarActionsLabel(): string;
+    getToolbarConfigurationLabel(): string;
+    getExportDataLabel(): string;
+    getMoreActionsLabel(): string;
+    emitExportAction(event: Event, format: string): void;
+    private tx;
     ngOnDestroy(): void;
+    getToolbarVariant(): TableToolbarAppearanceVariant;
+    getToolbarDensity(): TableToolbarAppearanceDensity;
+    getToolbarShape(): TableToolbarAppearanceShape;
+    getToolbarDivider(): TableToolbarAppearanceDivider;
+    getToolbarToken(name: TableToolbarTokenName): string | null;
+    private resolveToolbarAppearance;
+    private resolveToolbarAppearancePreset;
+    private mergeToolbarAppearance;
+    private normalizeTokenValue;
     private getNestedPropertyValue;
     private cloneForEmit;
     private getLogger;
@@ -108,8 +136,8 @@ declare class PraxisTableToolbar implements OnDestroy {
     private warnShortcutConflict;
     private sortActions;
     getExportIcon(format: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisTableToolbar, [null, { optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisTableToolbar, "praxis-table-toolbar", never, { "config": { "alias": "config"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "showMain": { "alias": "showMain"; "required": false; }; "showActionsGroup": { "alias": "showActionsGroup"; "required": false; }; "showEndActions": { "alias": "showEndActions"; "required": false; }; "showMobileActions": { "alias": "showMobileActions"; "required": false; }; "showReset": { "alias": "showReset"; "required": false; }; "evaluationContext": { "alias": "evaluationContext"; "required": false; }; }, { "toolbarAction": "toolbarAction"; "reset": "reset"; }, never, ["[advancedFilter]", "[toolbar]", "[end-actions]"], true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisTableToolbar, [null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisTableToolbar, "praxis-table-toolbar", never, { "config": { "alias": "config"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "showMain": { "alias": "showMain"; "required": false; }; "showActionsGroup": { "alias": "showActionsGroup"; "required": false; }; "showEndActions": { "alias": "showEndActions"; "required": false; }; "showMobileActions": { "alias": "showMobileActions"; "required": false; }; "exportBusy": { "alias": "exportBusy"; "required": false; }; "evaluationContext": { "alias": "evaluationContext"; "required": false; }; }, { "toolbarAction": "toolbarAction"; "exportAction": "exportAction"; }, never, ["[advancedFilter]", "[toolbar]", "[end-actions]"], true, never>;
 }
 
 type ColumnDataType$1 = 'date' | 'number' | 'currency' | 'percentage' | 'string' | 'boolean' | 'custom';
@@ -210,6 +238,8 @@ declare class DataFormattingService {
      */
     formatValue(value: any, columnType: ColumnDataType$1, formatString: string, options?: DataFormattingOptions): any;
     private coerceValueToType;
+    private parseDateOnlyString;
+    private normalizeNumericDateInput;
     private formatDate;
     private formatNumber;
     private formatCurrency;
@@ -331,12 +361,15 @@ type I18n = {
     searchPlaceholder: string;
     advanced: string;
     advancedTitle?: string;
+    advancedOpening?: string;
+    advancedUnavailable?: string;
     clear: string;
     apply: string;
     add?: string;
     filtersAdd?: string;
     filtersSearch?: string;
     addCount?: string;
+    addUnavailable?: string;
     pendingCount?: string;
     activeFiltersCount?: string;
     selectAll?: string;
@@ -419,10 +452,13 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
     showAddButton: boolean;
     /** Controla a exibição do botão de limpar filtros */
     showClearButton: boolean;
-    /** Controla a exibição do botão de pesquisar/aplicar filtros */
+    /** Controla a exibição do botão de pesquisar/aplicar filtros em fluxos manuais. */
     showSearchButton: boolean;
     /** Exibir confirmação ao excluir atalho (tag) */
     confirmTagDelete: boolean;
+    private alwaysFieldComponentRefs;
+    private selectedFieldComponentRefs;
+    private toggleFieldComponentRefs;
     /** Move toggles/booleans simples para a área de ações */
     placeBooleansInActions: boolean;
     /** Mostrar rótulos dos toggles na área de ações */
@@ -509,6 +545,7 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
     private alwaysFormReset$;
     private dto;
     advancedOpen: boolean;
+    advancedOpening: boolean;
     advancedValid: boolean;
     activeFiltersCount: number;
     saving: boolean;
@@ -535,7 +572,8 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
         id: string;
         label: string;
     }>;
-    private addItemsUpdateQueued;
+    readonly addSearchFieldId = "__praxis_filter_add_search__";
+    readonly addSelectAllFieldId = "__praxis_filter_add_select_all__";
     private applySchemaQueued;
     private fallbackLogger?;
     private fallbackLoggerEnvironment;
@@ -550,6 +588,7 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
     private _dbgLastToggleComponentsAt;
     overlayPositions: ConnectedPosition[];
     private advancedDebouncedSub?;
+    private advancedOpenRequestId;
     private lastActiveElement?;
     private lastSubmitAt;
     private resizeObs?;
@@ -588,6 +627,8 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
     private resolveInputDto;
     private resolveInitialDto;
     private syncFormsFromDto;
+    private refreshProgrammaticFilterFieldDisplays;
+    private refreshProgrammaticFilterFieldDisplay;
     ngOnInit(): Promise<void>;
     ngAfterViewInit(): void;
     onWindowResize(): void;
@@ -597,6 +638,7 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
     private computeIsMobile;
     ngOnChanges(changes: SimpleChanges): void;
     private areStringArraysEqual;
+    private normalizeFieldIdList;
     private areMetadataOverrideMapsEqual;
     /** Force-sync settings coming from parent table config updates. */
     applyExternalSettings(cfg?: Partial<FilterConfig>): void;
@@ -639,7 +681,15 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
     retrySchemaLoad(): void;
     private applySchemaMetas;
     private applySchemaMetasNow;
+    private withFilterMaterialDesignPolicy;
+    private withAdvancedDatePickerTouchPolicy;
+    private isAdvancedDatePickerControl;
+    private buildAdvancedFilterColumn;
+    private isCompositeRangeFilterField;
     private pickMetasByOrder;
+    private hasRemoteOptionSource;
+    private normalizeFilterOptionEndpointMetadata;
+    private toOwningResourcePathForOptionsFilter;
     private withInferredFilterControlType;
     private isAllowedFilterControlType;
     private inferFilterControlType;
@@ -650,9 +700,9 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
     private mergeAlwaysVisibleMetadata;
     private mergeFieldMetadataOverride;
     ngDoCheck(): void;
-    onAlwaysComponents(map: Map<string, any>): void;
-    onSelectedComponents(map: Map<string, any>): void;
-    onToggleComponents(map: Map<string, any>): void;
+    onAlwaysComponents(map: Map<string, ComponentRef<BaseDynamicFieldComponent>>): void;
+    onSelectedComponents(map: Map<string, ComponentRef<BaseDynamicFieldComponent>>): void;
+    onToggleComponents(map: Map<string, ComponentRef<BaseDynamicFieldComponent>>): void;
     onFieldInteraction(event: Event): void;
     openSelectedFieldEditor(): void;
     private isLocalE2eAuthoringOptInEnabled;
@@ -670,11 +720,16 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
     onAdvancedValidityChange(valid: boolean): void;
     onAddOpened(opened: boolean): void;
     onAddQuery(q: string): void;
+    openAddSelect(select: MatSelect): void;
+    hasAddableFields(): boolean;
+    private getAddableItems;
     private updateAddItems;
     trackById(_idx: number, it: {
         id: string;
     }): string;
+    private isFilterFieldHidden;
     onAddSelectionChange(values: string[] | null | undefined): void;
+    private mergeSelectedFieldIds;
     private formatWithCount;
     getAddAriaLabel(): string;
     getAddTriggerLabel(): string;
@@ -719,9 +774,13 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
     private ensureAdvancedConfigReady;
     private focusSchemaRetryButton;
     private showAdvancedUnavailableFeedback;
+    private setAdvancedOpening;
+    private deferAdvancedOpen;
     private openAdvancedModal;
     private openAdvancedDrawer;
     toggleAdvanced(): void;
+    hasAdvancedFields(): boolean;
+    private getAdvancedCandidateMetas;
     private usesProvidedFieldMetadata;
     private applyProvidedFieldMetadata;
     private saveConfig;
@@ -733,6 +792,9 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
     private persistTags;
     private cleanFilterPayload;
     private upsertDtoValue;
+    private normalizeFilterFieldValue;
+    private getFilterFieldMetaByName;
+    private isEntityLookupFilterField;
     private isEffectivelyEmptyFilterValue;
     private syncFormsToDto;
     private updateDisplayedTags;
@@ -748,19 +810,85 @@ declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestro
 declare const PRAXIS_FILTER_COMPONENT_METADATA: ComponentDocMeta;
 declare function providePraxisFilterMetadata(): Provider;
 
+type AnalyticsTableRow = Record<string, string | number | boolean | null>;
+type AnalyticsTableContractSource = 'remote' | 'fallback';
+interface AnalyticsTableViewModel {
+    config: TableConfig;
+    data: AnalyticsTableRow[];
+}
+interface AnalyticsTableContractDefinition<TKey extends string = string> {
+    key: TKey;
+    projectionId: string;
+    path: string;
+    title: PraxisTextValue;
+    subtitle?: PraxisTextValue;
+    fallbackProjection: PraxisAnalyticsProjection;
+    fallbackRows?: AnalyticsTableRow[];
+}
+interface AnalyticsTableContractLoadOptions<TKey extends string = string> {
+    cacheNamespace?: string;
+    queryContexts?: Partial<Record<TKey, PraxisDataQueryContext | null>>;
+}
+interface AnalyticsTableContractLoadResult<TKey extends string = string> {
+    views: Record<TKey, AnalyticsTableViewModel>;
+    sources: Record<TKey, AnalyticsTableContractSource>;
+    errors: Partial<Record<TKey, string>>;
+}
+
+declare class AnalyticsTableStatsApiService {
+    private readonly http;
+    private readonly apiUrl;
+    private readonly statsBuilder;
+    constructor(http: HttpClient, apiUrl: ApiUrlConfig);
+    execute(projection: PraxisAnalyticsProjection, queryContext?: PraxisDataQueryContext | null): Promise<AnalyticsTableRow[]>;
+    private toTableRows;
+    private resolveTimeSeriesCategory;
+    private resolveBucketCategory;
+    private projectMetricValues;
+    private resolveMetricValue;
+    private buildStatsUrl;
+    private applyQueryContext;
+    private normalizeError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsTableStatsApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsTableStatsApiService>;
+}
+
+interface TableAiNavigationDestinationContext {
+    id?: string;
+    path: string;
+    label?: string;
+    description?: string;
+    source?: string;
+    tags?: string[];
+    materialized?: boolean;
+}
+interface TableAiNavigationContextPack {
+    source?: string;
+    destinations: TableAiNavigationDestinationContext[];
+}
+interface TableAiContext {
+    recordSurfaces?: RecordRelatedSurfaceContextPack | null;
+    navigationDestinations?: TableAiNavigationContextPack | null;
+}
 type SchemaFieldHint = {
     name: string;
     label?: string;
     type?: string;
     controlType?: string;
     numericFormat?: string;
+    format?: string;
     options?: Array<Record<string, unknown> | string | number | boolean>;
     optionLabelKey?: string;
     optionValueKey?: string;
     enumValues?: string[];
 };
+type FilterSchemaFieldHint = SchemaFieldHint & {
+    relatedColumnFields?: string[];
+    relatedColumnLabels?: string[];
+};
 type PraxisDataQueryContextBridge = {
     filters?: Record<string, unknown> | null;
+    filterExpression?: PraxisQueryFilterExpression | null;
     sort?: string[] | null;
     limit?: number | null;
     page?: {
@@ -829,6 +957,8 @@ type RowActionRuntimeOptions = {
 type RuntimeRowAction = {
     id: string;
     action: string;
+    globalAction?: GlobalActionRef;
+    effects?: PraxisRuntimeGlobalActionEffect[];
     label?: string;
     icon?: string;
     color?: string;
@@ -836,6 +966,7 @@ type RuntimeRowAction = {
     disabled?: boolean;
     overflow?: boolean;
     __praxisDiscoveredAction?: ResourceActionCatalogItem;
+    __praxisDiscoveredSurface?: ResourceSurfaceCatalogItem;
     __praxisCapabilityDenied?: boolean;
 };
 type ExpansionDetailRuntimeStatus = 'idle' | 'loading' | 'ready' | 'error' | 'blocked';
@@ -859,17 +990,25 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private connectionStorage;
     private hostRef;
     private global;
-    private resourceDiscovery;
+    private injector;
     private componentKeys;
     private loadingOrchestrator;
+    private globalActions;
     private loadingRenderer?;
     private route?;
     private logger?;
+    private analyticsStatsApi?;
     private static readonly CELL_ANIMATION_CHANGE_CACHE_LIMIT;
+    private static readonly AI_SELECTION_ROW_LIMIT;
+    private static readonly AI_SELECTION_ID_LIMIT;
+    private static readonly AI_SELECTION_FIELD_LIMIT;
     private static readonly ROW_DISCOVERY_SUCCESS_CACHE_TTL_MS;
     private static readonly ROW_DISCOVERY_ERROR_CACHE_TTL_MS;
     private static readonly ROW_DISCOVERY_CACHE_LIMIT;
     private static readonly ROW_DISCOVERY_MAX_CONCURRENT_REQUESTS;
+    private _resourceDiscovery?;
+    private _resourceSurfaceOpenAdapter?;
+    readonly paginatorSelectConfig: MatPaginatorSelectConfig;
     private static readonly ROW_ANIMATION_PRESETS;
     private static readonly ROW_ANIMATION_PRESET_ALIASES;
     config: TableConfig;
@@ -887,12 +1026,24 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     crudContext: any;
     filterCriteria: Record<string, any>;
     queryContext: PraxisDataQueryContextBridge | null;
+    aiContext: TableAiContext | null;
+    aiAssistantVoiceInputMode: PraxisAssistantVoiceInputMode;
+    aiAssistantVoiceLanguage: string;
+    advancedFilterValue: Record<string, any>;
+    advancedFilterRuntimeVisibleFields: string[];
+    private advancedFilterAlwaysVisibleCacheKey;
+    private advancedFilterAlwaysVisibleCache?;
+    private advancedFilterMetadataOverridesCacheKey;
+    private advancedFilterMetadataOverridesCacheSource?;
+    private advancedFilterMetadataOverridesCache?;
     rowClick: EventEmitter<any>;
+    widgetEvent: EventEmitter<any>;
     rowDoubleClick: EventEmitter<any>;
     rowExpansionChange: EventEmitter<RowExpansionChangeEvent>;
     rowAction: EventEmitter<any>;
     toolbarAction: EventEmitter<any>;
     bulkAction: EventEmitter<any>;
+    exportAction: EventEmitter<any>;
     columnReorder: EventEmitter<any>;
     columnReorderAttempt: EventEmitter<any>;
     beforeDelete: EventEmitter<any>;
@@ -902,9 +1053,11 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     afterBulkDelete: EventEmitter<any>;
     bulkDeleteError: EventEmitter<any>;
     schemaStatusChange: EventEmitter<any>;
+    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
     metadataChange: EventEmitter<any>;
     loadingStateChange: EventEmitter<LoadingState>;
     collectionLinksChange: EventEmitter<RestApiLinks | null>;
+    selectionChange: EventEmitter<any>;
     private latestLoadingState;
     paginator: MatPaginator;
     sort: MatSort;
@@ -929,6 +1082,8 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     readonly isExpansionDetailRow: (index: number, row: any) => boolean;
     columnReorderStatusMessage: string;
     columnReorderVisualStatusMessage: string;
+    exportBusy: boolean;
+    exportStatusMessage: string;
     private columnReorderStatusTimer;
     private columnReorderVisualStatusTimer;
     private columnReorderUndoSubscription;
@@ -941,6 +1096,8 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private lastResolvedDataMode;
     private localFilterFieldMetadataCache;
     private localFilterFieldMetadataCacheKey;
+    private remoteDataLoadSequence;
+    private analyticsLoadSequence;
     private uncontrolledExpandedRowKeys;
     private readonly expansionOpaqueRefCacheLimit;
     private expansionOpaqueRefByRowKey;
@@ -968,7 +1125,10 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private rowDiscoveryMarkForCheckScheduled;
     private lastRowDiscoveryScopeKey;
     private readonly i18n;
+    private readonly collectionExport;
+    private readonly paginatorIntl;
     private schemaFieldsSnapshot;
+    private filterSchemaFieldsSnapshot;
     private runtimeSchemaMeta;
     schemaError: boolean;
     dataError: boolean;
@@ -980,9 +1140,9 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     shouldShowToolbarTopPlacement(): boolean;
     shouldShowToolbarBottomPlacement(): boolean;
     shouldRenderFooterToolbar(): boolean;
+    hasTopToolbarStack(): boolean;
     shouldShowFooterToolbarMain(): boolean;
     shouldShowFooterToolbarEndActions(): boolean;
-    shouldShowFooterToolbarReset(): boolean;
     getToolbarActionsPosition(): 'top' | 'bottom' | 'both';
     getBulkActionsPosition(): 'toolbar' | 'floating' | 'both';
     shouldRenderFloatingBulkActions(): boolean;
@@ -1001,6 +1161,7 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     getColumnTextAlignStyle(column: ColumnDefinition): string | null;
     getColumnWidthStyle(column: ColumnDefinition): string | null;
     getColumnHeaderAttrStyle(column: ColumnDefinition): string | null;
+    getColumnHeaderNgStyle(column: ColumnDefinition): Record<string, string> | undefined;
     getColumnCellAttrStyle(column: ColumnDefinition): string | null;
     getTableElevationClassName(): string;
     private normalizeTableElevationLevel;
@@ -1017,6 +1178,7 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     hasBottomPaginator(): boolean;
     hasExplicitResourcePath(): boolean;
     hasLocalDataInput(): boolean;
+    hasAnalyticsProjectionInput(): boolean;
     getDataMode(): DataMode;
     isRemoteMode(): boolean;
     isLocalMode(): boolean;
@@ -1034,12 +1196,17 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     getTableSettingsTooltip(): string;
     getDisconnectLabel(): string;
     getDisconnectTooltip(): string;
+    private syncPaginatorIntl;
+    private configuredLocaleRuntimeText;
+    private formatPaginatorRangeLabel;
     getNoDataStateIcon(): string;
     getNoDataStatePrimaryAction(): any | null;
     getNoDataStateSecondaryActions(): any[];
     shouldRenderAdvancedFilter(): boolean;
     getAdvancedFilterResourcePath(): string;
     getAdvancedFilterPersistenceKey(): string;
+    getAdvancedFilterAlwaysVisibleFields(): string[] | undefined;
+    getAdvancedFilterAlwaysVisibleFieldMetadataOverrides(): Record<string, Record<string, any>>;
     getAdvancedFilterFieldMetadata(): FieldMetadata[] | null | undefined;
     private buildLocalFilterMetadata;
     private buildLocalFilterMetadataCacheKey;
@@ -1060,8 +1227,32 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     get hostColumnBordersClass(): boolean;
     trackByRow(index: number, item: any): any;
     getSchemaFieldsSnapshot(): SchemaFieldHint[];
+    getFilterSchemaFieldsSnapshot(): FilterSchemaFieldHint[];
+    getResourceCapabilityDigest(): ResourceCapabilityDigest | null;
+    ensureFilterSchemaFieldsSnapshot(): Promise<void>;
+    ensureAiAssistantRecordSurfaceContext(): Promise<void>;
+    getAiAssistantRecordSurfacesContext(): RecordRelatedSurfaceContextPack | null;
+    getAiAssistantSelectedRowsContext(): Record<string, any> | null;
+    private ensureAiAssistantRowCapabilitySnapshot;
+    private buildCapabilitySnapshotFromSurfaceCatalog;
+    private buildAiAssistantResourceSurfaceContexts;
+    private getAiAssistantRecordSurfaceProbeRows;
+    private buildRecordRelatedSurfaceContextFromResourceSurface;
+    private humanizeResourceSurfaceLabel;
     aiAdapter: any;
     private aiAdapterLoadStarted;
+    private aiAssistantOpenAfterAdapterLoad;
+    aiAssistantOpen: boolean;
+    aiAssistantPrompt: string;
+    aiAssistantViewState: PraxisAssistantTurnViewState | null;
+    aiAssistantLayout: PraxisAssistantShellLayout;
+    readonly aiAssistantLabels: Partial<PraxisAssistantShellLabels>;
+    private aiAssistantController;
+    private aiAssistantStateSubscription;
+    private readonly aiApi;
+    private readonly assistantSessions;
+    private readonly aiTurnOrchestrator;
+    private readonly aiAssistantSessionEffect;
     private computedContextCache;
     private computedFieldNames;
     private readonly jsonLogic;
@@ -1099,6 +1290,10 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private recomputeLocalView;
     private resolveLocalSortField;
     private setSchemaFieldsSnapshot;
+    private setFilterSchemaFieldsSnapshot;
+    private inferFilterSchemaSourceFields;
+    private resolveFilterSchemaRelatedColumns;
+    private normalizeFieldAlias;
     private normalizeSchemaOptions;
     private normalizeEnumValues;
     private normalizeSchemaKey;
@@ -1108,10 +1303,61 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private tableConfigKey;
     private filterConfigKey;
     private ensureConfigDefaults;
+    private mergePersistedTableConfigWithInput;
+    private reconcileHostDeclaredTableContract;
+    private reconcileHostDeclaredColumns;
+    private reconcileHostDeclaredRowActions;
+    private reconcileHostDeclaredExport;
+    private normalizePersistedExportFormats;
+    private normalizePersistedRowActionIds;
+    private normalizePersistedColumnIds;
+    private clonePlainObject;
     private setShowToolbar;
     private shouldExposeToolbar;
-    constructor(cdr: ChangeDetectorRef, settingsPanel: SettingsPanelService, crudService: GenericCrudService<any, any>, tableDefaultsProvider: TableDefaultsProvider, filterConfig: FilterConfigService, formattingService: DataFormattingService, pxDialog: PraxisDialog, snackBar: MatSnackBar, asyncConfigStorage: AsyncConfigStorage, connectionStorage: ConnectionStorage, hostRef: ElementRef<HTMLElement>, global: GlobalConfigService, resourceDiscovery: ResourceDiscoveryService, componentKeys: ComponentKeyService, loadingOrchestrator: LoadingOrchestrator, loadingRenderer?: PraxisLoadingRenderer | undefined, route?: ActivatedRoute | undefined, logger?: LoggerService | undefined);
+    constructor(cdr: ChangeDetectorRef, settingsPanel: SettingsPanelService, crudService: GenericCrudService<any, any>, tableDefaultsProvider: TableDefaultsProvider, filterConfig: FilterConfigService, formattingService: DataFormattingService, pxDialog: PraxisDialog, snackBar: MatSnackBar, asyncConfigStorage: AsyncConfigStorage, connectionStorage: ConnectionStorage, hostRef: ElementRef<HTMLElement>, global: GlobalConfigService, injector: Injector, componentKeys: ComponentKeyService, loadingOrchestrator: LoadingOrchestrator, globalActions: GlobalActionService, loadingRenderer?: PraxisLoadingRenderer | undefined, route?: ActivatedRoute | undefined, logger?: LoggerService | undefined, analyticsStatsApi?: AnalyticsTableStatsApiService | undefined);
+    private get resourceDiscovery();
+    private get resourceSurfaceOpenAdapter();
     private ensureAiAdapterLoaded;
+    openAiAssistant(): void;
+    aiAssistantTriggerTestId(position: string): string;
+    hasMinimizedAiAssistantSession(): boolean;
+    aiAssistantTriggerIcon(): string;
+    aiAssistantTriggerBadge(): string;
+    aiAssistantTriggerLabel(): string;
+    aiAssistantTriggerTooltip(): string;
+    openAiAssistantFromSession(session: PraxisAssistantSessionSnapshot): void;
+    closeAiAssistant(): void;
+    onAiAssistantPromptChange(prompt: string): void;
+    onAiAssistantSubmit(prompt: string): void;
+    onAiAssistantApply(): void;
+    private shouldMinimizeAiAssistantAfterApply;
+    private isMaterializedRowActionPatch;
+    private asPlainRecord;
+    onAiAssistantRetry(): void;
+    onAiAssistantCancel(): void;
+    onAiAssistantQuickReply(reply: PraxisAssistantShellQuickReply): void;
+    getAiAssistantRecommendedIntents(): readonly PraxisAssistantRecommendedIntent[];
+    private getAiAssistantCapabilityDiscoveryRecommendations;
+    onAiAssistantRecommendedIntent(intent: PraxisAssistantRecommendedIntent): void;
+    private getAiAssistantRecommendationResponseContract;
+    onAiAssistantEditMessage(message: PraxisAssistantShellMessage): void;
+    onAiAssistantResendMessage(message: PraxisAssistantShellMessage): void;
+    onAiAssistantLayoutChange(layout: PraxisAssistantShellLayout): void;
+    private initializeAiAssistantController;
+    private buildAiAssistantContextItems;
+    private interpolateAiAssistantContextValue;
+    private aiAssistantSelectedRecordsValue;
+    private buildAiAssistantContextSnapshot;
+    private syncAiAssistantSession;
+    private assistantContextRuntimeLocale;
+    private refreshAiAssistantContextAfterSelectionChange;
+    private hasAiAssistantSessionState;
+    private resolveAiAssistantSessionId;
+    private resolveAiAssistantOwnerId;
+    private resolveAiAssistantRouteKey;
+    private resolveAiAssistantSummary;
+    private resolveAiAssistantBadge;
+    private resolveAiAssistantIcon;
     private emitLoadingState;
     private hasResolvedRemoteDataLoad;
     private isTableDataLoading;
@@ -1137,6 +1383,9 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     onPageChange(event: PageEvent): void;
     onSortChange(event: Sort): void;
     onRowClicked(row: any, index: number, event?: MouseEvent): void;
+    requestRecordSurfaceOpen(surface: Record<string, unknown>): boolean;
+    private resolveResourceRecordSurfaceContext;
+    private openResourceRecordSurface;
     isRowExpansionRuntimeEnabled(): boolean;
     isExpansionIconTriggerEnabled(): boolean;
     isRowExpandable(row: any, index?: number): boolean;
@@ -1315,6 +1564,7 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private sanitizeDomIdToken;
     private areStringSetsEqual;
     private shouldToggleExpansionOnRowClick;
+    private shouldSelectRowOnRowClick;
     private getExpansionMotionPreset;
     private getExpansionMotionDurationMs;
     private getExpansionMotionEasingCurve;
@@ -1328,22 +1578,67 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private emitRowActionEvent;
     private showConfirmDialog;
     private executeDeleteAction;
+    private dispatchRowAction;
     private cloneForEmit;
     private interpolateActionMessageTemplate;
     private buildActionFeedbackContext;
     private resolveActionFeedbackMessage;
     private showActionFeedbackMessage;
     private emitEventWithActionFeedback;
+    private executeConfiguredGlobalAction;
+    private resolveConfiguredGlobalActionRef;
+    private resolveActionGlobalActionRef;
+    private resolveGlobalActionPayload;
+    private buildGlobalActionTemplateContext;
+    private resolveGlobalActionTemplateValue;
+    private isDeferredTemplateExpressionKey;
+    private interpolateGlobalActionTemplate;
+    private shouldEmitLocalForGlobalAction;
     private resolveBulkValidationMessage;
     private hasValidBulkSelectionCount;
     private showBulkConfirmDialog;
     onToolbarAction(event: {
         action: string;
         actionConfig?: any;
-    }): void;
+    }): Promise<void>;
+    private resolveBulkExportFormat;
+    private isBulkExportActionKey;
+    private normalizeExportFormat;
+    private isExportFormatEnabled;
+    private getFirstEnabledExportFormat;
+    onExportAction(event: {
+        format: string;
+        scope?: PraxisExportScope;
+    }): Promise<void>;
+    canRunExportAction(format: unknown): boolean;
+    private shouldBlockSelectedExportWithoutSelection;
+    private buildTableExportRequest;
+    private resolveEffectiveExportScope;
+    private resolveTableExportLoadedItems;
+    private computeLocalExportRows;
+    private buildTableExportFields;
+    private buildTableExportFormatOptions;
+    private buildTableExportLocalization;
+    private resolveColumnExportFormat;
+    private buildColumnExportPresentation;
+    private resolveColumnExportCurrency;
+    private downloadExportResult;
+    private triggerExportDownload;
+    private resolveExportFileName;
+    private getExportFileExtension;
+    private getExportMimeType;
+    private showExportFeedback;
     onAdvancedFilterSubmit(criteria: Record<string, any>): void;
     onAdvancedFilterChange(criteria: Record<string, any>): void;
     onAdvancedFilterClear(): void;
+    private applyAdvancedFilterCriteria;
+    private setAdvancedFilterCriteria;
+    private syncAdvancedFilterValueFromCriteria;
+    private deriveRuntimeVisibleAdvancedFilterFields;
+    private isEmptyAdvancedFilterCriterionValue;
+    private mergeAdvancedFilterFieldIds;
+    private getRuntimePromotedAdvancedFilterFields;
+    private toPlainRecord;
     private saveConfigWithAck;
     private clearConfigWithAck;
     private persistHorizontalScrollInput;
@@ -1362,6 +1657,7 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private applyDataSourceSettings;
     private sanitizeColumns;
     private setupColumns;
+    private preserveSchemaDrivenColumnsIfConfigOmittedColumns;
     private isDataColumnField;
     private computeVisibleDataColumnsForDrag;
     getVisibleDataColumnsForDrag(): ColumnDefinition[];
@@ -1370,6 +1666,7 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     isColumnDraggable(column: ColumnDefinition | null | undefined): boolean;
     private resolveColumnReorderHeader;
     private isEnglishLocale;
+    private isEnglishLocaleValue;
     private isColumnDragDebugEnabled;
     private logColumnDragDebug;
     private resolveTableMessageTemplate;
@@ -1405,7 +1702,18 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
      */
     private verifyServerSchemaVersion;
     private loadSchema;
+    private loadFilterSchemaSnapshot;
     private convertFieldToColumn;
+    private applySchemaFieldPresentation;
+    private resolveSchemaCurrencyFormat;
+    private resolveSchemaBooleanFormat;
+    private resolveSchemaValueMapping;
+    private resolveSchemaOptionsValueMapping;
+    private normalizePresentationToken;
+    private firstNonEmptyString;
+    private firstFiniteNumber;
+    private humanizeSchemaEnumValue;
+    private capitalizeSchemaEnumPart;
     /**
      * Apply automatic renderer hints based on schema field metadata.
      * Runs only on initial bootstrap (when columns are derived from schema).
@@ -1428,11 +1736,14 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private buildRowDiscoveryOptions;
     private getRowLinks;
     private resolveRowDiscoveryHref;
+    private resolveRowSurfaceDiscoveryHref;
     private prefetchRowDiscovery;
     private ensureRowDiscovery;
     private ensureRowCapabilitySnapshot;
     private ensureRowActionCatalog;
     private getCachedRowCapabilitySnapshot;
+    private getAiAssistantRowDiscoveryLinks;
+    private mergeRowCapabilitySnapshots;
     private hasResolvedRowActionCatalog;
     isRowDiscoveryPending(row: any): boolean;
     private getCachedRowActionCatalog;
@@ -1473,6 +1784,8 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private pruneRowDiscoveryCaches;
     private pruneRowDiscoveryCache;
     private fetchData;
+    private resolveAnalyticsProjection;
+    private fetchAnalyticsProjectionData;
     private getEffectiveFilterCriteria;
     retryData(): void;
     reloadSchema(): void;
@@ -1485,9 +1798,35 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
      * 3. format (data formatting like dates, numbers, currency)
      */
     getCellValue(rowData: any, column: ColumnDefinition): any;
+    private applyImplicitRuntimeCellPresentation;
+    private shouldHumanizeRuntimeEnumCell;
+    private resolveCellFormattingType;
+    private normalizeReadonlyEntityLookupCellValue;
+    private toEntityLookupDisplayToken;
+    private isEntityLookupDisplayCandidate;
+    private toEntityLookupDisplayPrimitive;
     private resolveImplicitFormat;
     getCellClasses(rowData: any, column: ColumnDefinition): string[] | undefined;
     getCellNgStyle(rowData: any, column: ColumnDefinition): Record<string, string> | undefined;
+    private normalizeInlineStyleRecord;
+    private normalizeConditionalStyleRules;
+    private normalizeConditionalStyleRecord;
+    getCellTooltip(rowData: any, column: ColumnDefinition): string | null;
+    getCellTooltipPosition(rowData: any, column: ColumnDefinition): 'above' | 'below' | 'left' | 'right' | 'before' | 'after';
+    private resolveConditionalStyleTooltipText;
+    private resolveRendererTooltipText;
+    private normalizeTooltipPosition;
+    private normalizeConditionalStyleEffects;
+    private hasConditionalStyleEffectPayload;
+    private resolveConditionalStyleClasses;
+    private resolveConditionalStyleObject;
+    private compileConditionalStyleEffect;
+    private normalizeConditionalRendererRules;
+    private normalizeObjectRecord;
+    private buildColumnRendererOverrideFromEffects;
+    private buildColumnRendererFromEffect;
+    private resolveRuleAnimationFromEffects;
+    private resolveRowTooltipFromEffects;
     private resetComputedContextCache;
     private ensureEffectiveCellRenderCache;
     private ensureCellAnimationPreviousValuesByRowId;
@@ -1499,6 +1838,11 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private buildComputedSignature;
     private stringifyDependencyValue;
     private buildComputedValueMap;
+    private collectComputedColumns;
+    private evaluateCanonicalComputedColumns;
+    private collectComputedExpressionDependencies;
+    private collectJsonLogicVarDependencies;
+    private resolveJsonLogicVarPath;
     private buildEvaluationContext;
     private getJsonLogicEvaluationOptions;
     private resolveJsonLogicUserTimeZone;
@@ -1637,6 +1981,7 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private buildEffectiveCellRenderCacheKey;
     private getEffectiveCellRenderResult;
     private getEffectiveRenderer;
+    private resolveEffectiveRendererTooltip;
     getLinkHref(row: any, column: ColumnDefinition): string | null;
     getLinkText(row: any, column: ColumnDefinition): string;
     getLinkRichContentNodes(row: any, column: ColumnDefinition): RichBlockNode[];
@@ -1658,6 +2003,7 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private buildRendererActionRuntimeOptions;
     onButtonClick(row: any, column: ColumnDefinition, event: Event): void;
     getChipText(row: any, column: ColumnDefinition): string | null;
+    private getRendererTextFieldValue;
     getChipRichContentNodes(row: any, column: ColumnDefinition): RichBlockNode[];
     getChipIcon(row: any, column: ColumnDefinition): string | null;
     getChipClasses(row: any, column: ColumnDefinition): string[];
@@ -1680,6 +2026,7 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private deriveAvatarInitials;
     getAvatarInitials(row: any, column: ColumnDefinition): string;
     getAvatarRichContentNodes(row: any, column: ColumnDefinition): RichBlockNode[];
+    private getAvatarRichContentStyle;
     getAvatarShape(row: any, column: ColumnDefinition): 'square' | 'rounded' | 'circle' | undefined;
     getAvatarStyle(row: any, column: ColumnDefinition): Record<string, string> | null;
     getToggleState(row: any, column: ColumnDefinition): boolean;
@@ -1735,6 +2082,7 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private reconcileSelectionAfterDataChange;
     private getComparableRowIdentity;
     getIdField(): string;
+    private resolveConfigMetaIdField;
     private syncRuntimeSchemaMetaFromConfig;
     private getEffectiveMetadataSnapshot;
     getActionId(action: any): string;
@@ -1751,6 +2099,22 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     masterToggle(): void;
     isAllSelected(): boolean;
     toggleRow(row: any): void;
+    private selectRowFromUserInteraction;
+    private emitSelectionChange;
+    private getSelectedRowsSnapshot;
+    private getAiAssistantSelectionFields;
+    private buildAiAssistantSelectionFilterCandidates;
+    private inferAiAssistantFilterCriterionKind;
+    private buildAiAssistantRangeFilterCandidate;
+    private buildAiAssistantSetFilterCandidate;
+    private resolveAiAssistantSetFilterDisplayValue;
+    private aiAssistantSetFilterDisplayFieldCandidates;
+    private resolveAiAssistantFilterSourceFields;
+    private normalizeAiAssistantNumericRangeValue;
+    private normalizeAiAssistantDateRangeValue;
+    private sanitizeAiAssistantSelectedRow;
+    private safeStringifyAiAssistantValue;
+    private isSensitiveAiAssistantField;
     private getRowActionsConfig;
     getActionsHeaderAlign(): string;
     getActionsHeaderTooltip(): string | undefined;
@@ -1775,11 +2139,24 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private splitVisibleRowActionsFromVisible;
     private decorateConfiguredRowAction;
     private getDiscoveredRowWorkflowActions;
+    private getDiscoveredRowSurfaceActionsFromSnapshot;
     private getDiscoveredRowWorkflowActionsFromCatalog;
     private supportsRowCrudAction;
     private isCapabilityManagedCrudRowAction;
     private findItemWorkflowAction;
+    private findItemSurface;
+    private isRowSurfaceAction;
+    private isResourceSurfaceCatalogItem;
+    private toRecordSurfaceActionConfig;
+    private resolveConfiguredSurfaceOpenAction;
+    private recordSurfaceActionAliases;
+    private normalizeSurfaceActionAlias;
+    private isWritableRowSurface;
+    private isReadableRowSurface;
+    private getDiscoveredSurfaceIcon;
+    private getDiscoveredSurfaceColor;
     private getUnavailableWorkflowMessage;
+    private getUnavailableSurfaceMessage;
     private normalizeActionId;
     private isActionVisible;
     trackAction(index: number, item: any): any;
@@ -1793,8 +2170,8 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     getRowMenuIcon(): string;
     private scheduleRowDiscoveryMarkForCheck;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisTable, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisTable, "praxis-table", never, { "config": { "alias": "config"; "required": false; }; "resourcePath": { "alias": "resourcePath"; "required": false; }; "data": { "alias": "data"; "required": false; }; "tableId": { "alias": "tableId"; "required": true; }; "componentInstanceId": { "alias": "componentInstanceId"; "required": false; }; "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "autoDelete": { "alias": "autoDelete"; "required": false; }; "notifyIfOutdated": { "alias": "notifyIfOutdated"; "required": false; }; "snoozeMs": { "alias": "snoozeMs"; "required": false; }; "autoOpenSettingsOnOutdated": { "alias": "autoOpenSettingsOnOutdated"; "required": false; }; "crudContext": { "alias": "crudContext"; "required": false; }; "filterCriteria": { "alias": "filterCriteria"; "required": false; }; "queryContext": { "alias": "queryContext"; "required": false; }; "enableCustomization": { "alias": "enableCustomization"; "required": false; }; "dense": { "alias": "dense"; "required": false; }; }, { "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "rowExpansionChange": "rowExpansionChange"; "rowAction": "rowAction"; "toolbarAction": "toolbarAction"; "bulkAction": "bulkAction"; "columnReorder": "columnReorder"; "columnReorderAttempt": "columnReorderAttempt"; "beforeDelete": "beforeDelete"; "afterDelete": "afterDelete"; "deleteError": "deleteError"; "beforeBulkDelete": "beforeBulkDelete"; "afterBulkDelete": "afterBulkDelete"; "bulkDeleteError": "bulkDeleteError"; "schemaStatusChange": "schemaStatusChange"; "metadataChange": "metadataChange"; "loadingStateChange": "loadingStateChange"; "collectionLinksChange": "collectionLinksChange"; }, ["toolbar", "projectedFilter"], ["[advancedFilter]", "[toolbar]", "[advancedFilter]", "[toolbar]", "[advancedFilter]", "[toolbar]"], true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisTable, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisTable, "praxis-table", never, { "config": { "alias": "config"; "required": false; }; "resourcePath": { "alias": "resourcePath"; "required": false; }; "data": { "alias": "data"; "required": false; }; "tableId": { "alias": "tableId"; "required": true; }; "componentInstanceId": { "alias": "componentInstanceId"; "required": false; }; "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "autoDelete": { "alias": "autoDelete"; "required": false; }; "notifyIfOutdated": { "alias": "notifyIfOutdated"; "required": false; }; "snoozeMs": { "alias": "snoozeMs"; "required": false; }; "autoOpenSettingsOnOutdated": { "alias": "autoOpenSettingsOnOutdated"; "required": false; }; "crudContext": { "alias": "crudContext"; "required": false; }; "filterCriteria": { "alias": "filterCriteria"; "required": false; }; "queryContext": { "alias": "queryContext"; "required": false; }; "aiContext": { "alias": "aiContext"; "required": false; }; "aiAssistantVoiceInputMode": { "alias": "aiAssistantVoiceInputMode"; "required": false; }; "aiAssistantVoiceLanguage": { "alias": "aiAssistantVoiceLanguage"; "required": false; }; "horizontalScroll": { "alias": "horizontalScroll"; "required": false; }; "enableCustomization": { "alias": "enableCustomization"; "required": false; }; "dense": { "alias": "dense"; "required": false; }; }, { "rowClick": "rowClick"; "widgetEvent": "widgetEvent"; "rowDoubleClick": "rowDoubleClick"; "rowExpansionChange": "rowExpansionChange"; "rowAction": "rowAction"; "toolbarAction": "toolbarAction"; "bulkAction": "bulkAction"; "exportAction": "exportAction"; "columnReorder": "columnReorder"; "columnReorderAttempt": "columnReorderAttempt"; "beforeDelete": "beforeDelete"; "afterDelete": "afterDelete"; "deleteError": "deleteError"; "beforeBulkDelete": "beforeBulkDelete"; "afterBulkDelete": "afterBulkDelete"; "bulkDeleteError": "bulkDeleteError"; "schemaStatusChange": "schemaStatusChange"; "configChange": "configChange"; "metadataChange": "metadataChange"; "loadingStateChange": "loadingStateChange"; "collectionLinksChange": "collectionLinksChange"; "selectionChange": "selectionChange"; }, ["toolbar", "projectedFilter"], ["[advancedFilter]", "[toolbar]", "[advancedFilter]", "[toolbar]", "[advancedFilter]", "[toolbar]"], true, never>;
     static ngAcceptInputType_enableCustomization: unknown;
 }
 
@@ -1807,7 +2184,6 @@ interface EditorDocument<TConfig, TBindings = unknown> {
 type TableHorizontalScroll = 'auto' | 'wrap' | 'none';
 interface TableBindings {
     resourcePath?: string | null;
-    idField?: string;
     horizontalScroll?: TableHorizontalScroll;
 }
 interface TableAuthoringDocument extends EditorDocument<TableConfig, TableBindings> {
@@ -1864,7 +2240,6 @@ interface TableApplyPlan {
     };
     diff?: {
         resourcePathChanged?: boolean;
-        idFieldChanged?: boolean;
         horizontalScrollChanged?: boolean;
         requiresDataRefresh?: boolean;
     };
@@ -2337,6 +2712,8 @@ interface ToolbarAction {
     /** Material button appearance: filled (flat), outlined (stroked), elevated (raised), text, tonal */
     appearance?: 'filled' | 'outlined' | 'elevated' | 'text' | 'tonal';
     action: string;
+    globalAction?: GlobalActionRef;
+    effects?: PraxisRuntimeGlobalActionEffect[];
     position: 'start' | 'end';
     order?: number;
     disabled?: boolean;
@@ -2344,7 +2721,7 @@ interface ToolbarAction {
     shortcut?: string;
     shortcutScope?: 'toolbar' | 'global';
     tooltip?: string;
-    visibleWhen?: string;
+    visibleWhen?: JsonLogicExpression | null;
     children?: ToolbarAction[];
 }
 interface RowAction {
@@ -2352,11 +2729,15 @@ interface RowAction {
     label: string;
     icon: string;
     action: string;
+    globalAction?: GlobalActionRef;
+    effects?: PraxisRuntimeGlobalActionEffect[];
     color?: 'primary' | 'accent' | 'warn';
     tooltip?: string;
     requiresConfirmation?: boolean;
     autoDelete?: boolean;
     separator?: boolean;
+    visibleWhen?: JsonLogicExpression | null;
+    disabledWhen?: JsonLogicExpression | null;
     conditional?: string;
 }
 interface BulkAction {
@@ -2364,6 +2745,8 @@ interface BulkAction {
     label: string;
     icon: string;
     action: string;
+    globalAction?: GlobalActionRef;
+    effects?: PraxisRuntimeGlobalActionEffect[];
     color?: 'primary' | 'accent' | 'warn';
     tooltip?: string;
     requiresConfirmation?: boolean;
@@ -2377,6 +2760,25 @@ interface ToolbarActionsChange {
     value: any;
     fullConfig: TableConfig;
 }
+type GlobalActionCatalogOption = GlobalActionCatalogEntry & {
+    param?: {
+        required?: boolean;
+        label?: string;
+        placeholder?: string;
+        hint?: string;
+    };
+};
+type EditableTableAction = {
+    id?: string;
+    label?: string;
+    action?: string;
+    globalAction?: GlobalActionRef;
+    effects?: PraxisRuntimeGlobalActionEffect[];
+    position?: string;
+    appearance?: string;
+    visibleWhen?: JsonLogicExpression | null;
+    disabledWhen?: JsonLogicExpression | null;
+};
 type ToolbarShortcutScope = 'toolbar' | 'global';
 interface InternalActionSpec {
     id: string;
@@ -2397,14 +2799,14 @@ declare class ToolbarActionsEditorComponent implements OnInit, OnDestroy, OnChan
     editingToolbarActionIndex: number | null;
     editingRowActionIndex: number | null;
     editingBulkActionIndex: number | null;
-    readonly globalActionCatalog: GlobalActionSpec[];
+    private readonly i18n;
+    readonly globalActionCatalog: GlobalActionCatalogOption[];
     get internalActionCatalog(): InternalActionSpec[];
     readonly customActionValue = "__custom__";
     readonly validShortcutScopes: ToolbarShortcutScope[];
     private readonly actionFieldDrafts;
     private readonly actionFieldErrors;
     private readonly warnedInvalidShortcutScopes;
-    private readonly i18n;
     private destroy$;
     constructor(fb: FormBuilder, iconPicker: IconPickerService);
     tx(key: string, fallback: string): string;
@@ -2433,56 +2835,37 @@ declare class ToolbarActionsEditorComponent implements OnInit, OnDestroy, OnChan
     private removeAddToolbarAction;
     private syncAddFormFromActions;
     private updateConfig;
-    getActionSelectValue(value?: string): string;
-    getActionParam(value?: string): string;
-    getActionCustomValue(value?: string): string;
+    getActionSelectValue(action?: EditableTableAction): string;
+    getActionParam(action?: EditableTableAction): string;
+    isRequiredGlobalActionParamMissing(action: EditableTableAction, spec: GlobalActionCatalogOption): boolean;
+    getActionCustomValue(action?: EditableTableAction): string;
     isInternalAction(value?: string): boolean;
-    getActionSpecById(id: string): GlobalActionSpec | undefined;
-    onActionSelectChange(action: {
-        action?: string;
-    }, value: string, kind: 'toolbar' | 'row' | 'bulk'): void;
-    onActionParamChange(action: {
-        action?: string;
-    }, value: string, kind: 'toolbar' | 'row' | 'bulk'): void;
-    onActionCustomChange(action: {
-        action?: string;
-    }, value: string, kind: 'toolbar' | 'row' | 'bulk'): void;
+    getActionSpecById(id: string): GlobalActionCatalogOption | undefined;
+    onActionSelectChange(action: EditableTableAction, value: string, kind: 'toolbar' | 'row' | 'bulk'): void;
+    onActionParamChange(action: EditableTableAction, value: string, kind: 'toolbar' | 'row' | 'bulk'): void;
+    onActionCustomChange(action: EditableTableAction, value: string, kind: 'toolbar' | 'row' | 'bulk'): void;
+    getCanonicalGlobalActionRef(action?: EditableTableAction): GlobalActionRef | undefined;
+    private setCanonicalGlobalActionRef;
     private touchActionList;
-    private parseActionValue;
+    getActionJsonLogicText(action: EditableTableAction, key: 'visibleWhen' | 'disabledWhen'): string;
+    onActionJsonLogicChange(action: EditableTableAction, key: 'visibleWhen' | 'disabledWhen', value: string, kind: 'toolbar' | 'row' | 'bulk'): void;
+    getActionConditionError(action: EditableTableAction, key: 'visibleWhen' | 'disabledWhen'): string;
     isGlobalActionId(id?: string): boolean;
-    getGlobalActionSchema(action: {
-        action?: string;
-    }): _praxisui_core.GlobalActionUiSchema | undefined;
-    getSurfaceOpenActionPayload(action: {
-        action?: string;
-    }): SurfaceOpenPayload;
-    onSurfaceOpenActionPayloadChange(action: {
-        action?: string;
-    }, payload: SurfaceOpenPayload, kind: 'toolbar' | 'row' | 'bulk'): void;
-    shouldShowGlobalActionField(action: {
-        action?: string;
-    }, field: GlobalActionField): boolean;
-    hasActionFieldError(action: {
-        action?: string;
-    }, key: string): boolean;
-    getActionFieldError(action: {
-        action?: string;
-    }, key: string): string;
-    getGlobalActionFieldValue(action: {
-        action?: string;
-    }, field: GlobalActionField): any;
-    onGlobalActionFieldChange(action: {
-        action?: string;
-    }, field: GlobalActionField, value: any, kind: 'toolbar' | 'row' | 'bulk'): void;
-    private getActionParamInfo;
-    private parseMethodAndUrl;
+    getGlobalActionSchema(action: EditableTableAction): _praxisui_core.GlobalActionUiSchema | undefined;
+    getSurfaceOpenActionPayload(action: EditableTableAction): SurfaceOpenPayload;
+    onSurfaceOpenActionPayloadChange(action: EditableTableAction, payload: SurfaceOpenPayload, kind: 'toolbar' | 'row' | 'bulk'): void;
+    shouldShowGlobalActionField(action: EditableTableAction, field: GlobalActionField): boolean;
+    isGlobalActionFieldRequired(action: EditableTableAction, field: GlobalActionField): boolean;
+    isGlobalActionFieldMissing(action: EditableTableAction, field: GlobalActionField): boolean;
+    hasActionFieldError(action: EditableTableAction, key: string): boolean;
+    getActionFieldError(action: EditableTableAction, key: string): string;
+    getGlobalActionFieldValue(action: EditableTableAction, field: GlobalActionField): any;
+    onGlobalActionFieldChange(action: EditableTableAction, field: GlobalActionField, value: any, kind: 'toolbar' | 'row' | 'bulk'): void;
     private stringifyJson;
     private normalizeSurfaceOpenPayload;
     private setActionFieldError;
     private clearActionFieldError;
     private collectGlobalActionFieldValues;
-    private serializeGlobalActionParam;
-    private buildPrimaryParam;
     private buildGlobalActionPayload;
     getToolbarActionShortcutScope(action: ToolbarAction): ToolbarShortcutScope;
     onToolbarActionShortcutScopeChange(action: ToolbarAction, value: ToolbarShortcutScope | string): void;
@@ -2674,6 +3057,7 @@ declare class FilterSettingsComponent implements OnChanges, AfterViewInit, OnDes
     }[];
     getContrastWarning(): string | null;
     applyPreset(key: string): void;
+    isPresetActive(key: string): boolean;
     hasBooleanFieldMetadata(): boolean;
     getFieldLabel(name: string): string;
     onAlwaysVisibleFieldSearchChange(value: string): void;
@@ -2837,12 +3221,10 @@ declare class RuleCompilerService {
     static ɵprov: i0.ɵɵInjectableDeclaration<RuleCompilerService>;
 }
 
-type RuleItem = {
-    condition: JsonLogicExpression;
+type RuleItem = Omit<PraxisRuntimeConditionalEffectRule<RuleEffectDefinition>, 'effects'> & {
     cssClass?: string;
     style?: Record<string, string>;
-    description?: string;
-    effects?: _praxisui_table_rule_builder.RuleEffectDefinition;
+    effects?: RuleEffectDefinition[];
     enabled?: boolean;
 };
 declare class TableRulesEditorComponent implements OnChanges, OnInit, OnDestroy {
@@ -2912,6 +3294,7 @@ declare class TableRulesEditorComponent implements OnChanges, OnInit, OnDestroy
     onColumnSelect(field: string): void;
     private initFromConfig;
     private loadColumnRules;
+    private normalizePersistedRules;
     rebuildCondition(): void;
     onDraftChange(): void;
     applyTextPreset(preset: string): void;
@@ -2938,6 +3321,8 @@ declare class TableRulesEditorComponent implements OnChanges, OnInit, OnDestroy
     onExportRules(): void;
     onImportRules(): void;
     private sanitizeRule;
+    private normalizeRuleEffects;
+    getPrimaryEffect(r: RuleItem | null | undefined): RuleEffectDefinition | undefined;
     getAnimationLabel(r: RuleItem): string | null;
     private normalizeRendererAnimation;
     private buildRendererOverrideFromRule;
@@ -3044,6 +3429,8 @@ declare class PraxisTableConfigEditor implements OnInit, OnDestroy, SettingsValu
     private cdr;
     private configService;
     private readonly i18n;
+    private readonly globalActionCatalogSource;
+    private readonly globalActionCatalog;
     filterSettingsEditor?: FilterSettingsComponent;
     behaviorEditor?: BehaviorConfigEditorComponent;
     rulesEditor?: TableRulesEditorComponent;
@@ -3106,6 +3493,7 @@ declare class PraxisTableConfigEditor implements OnInit, OnDestroy, SettingsValu
     private hasLocalDataInput;
     private filterDtoLoadSeq;
     private lastKnownFilterSettings;
+    private globalActionValidationIssues;
     private readonly panelData;
     private readonly crudService;
     private readonly panelRef;
@@ -3132,6 +3520,9 @@ declare class PraxisTableConfigEditor implements OnInit, OnDestroy, SettingsValu
     onRulesConfigChange(newCfg: TableConfig): void;
     private updateColumnMetas;
     private updateCanSaveState;
+    private collectGlobalActionValidationIssues;
+    private findGlobalActionCatalogEntry;
+    private buildGlobalActionCatalog;
     private subscribeCrudEditorChanges;
     private showSuccess;
     private showError;
@@ -3140,6 +3531,7 @@ declare class PraxisTableConfigEditor implements OnInit, OnDestroy, SettingsValu
      * Normaliza uma configuração de tabela para comparação consistente
      * Remove propriedades undefined, ordena arrays e objetos de forma consistente
      */
+    private withCanonicalIdField;
     private normalizeTableConfig;
     /**
      * Realiza comparação profunda de objetos, ignorando ordem de propriedades
@@ -3202,6 +3594,107 @@ declare class PraxisTableConfigEditor implements OnInit, OnDestroy, SettingsValu
     static ɵcmp: i0.ɵɵComponentDeclaration<PraxisTableConfigEditor, "praxis-table-config-editor", never, {}, {}, never, never, true, never>;
 }
 
+interface PraxisTableWidgetEditorInputs {
+    config?: TableConfig | null;
+    resourcePath?: string | null;
+    horizontalScroll?: 'auto' | 'wrap' | 'none';
+    tableId?: string;
+    componentInstanceId?: string;
+    [key: string]: unknown;
+}
+interface PraxisTableWidgetEditorValue {
+    inputs: PraxisTableWidgetEditorInputs;
+}
+declare class PraxisTableWidgetConfigEditor implements SettingsValueProvider$1, AfterViewInit, OnDestroy {
+    inputs: PraxisTableWidgetEditorInputs | null;
+    widgetKey?: string;
+    tableEditor?: PraxisTableConfigEditor;
+    readonly isDirty$: BehaviorSubject<boolean>;
+    readonly isValid$: BehaviorSubject<boolean>;
+    readonly isBusy$: BehaviorSubject<boolean>;
+    private readonly subscription;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    getSettingsValue(): PraxisTableWidgetEditorValue;
+    onSave(): PraxisTableWidgetEditorValue;
+    reset(): void;
+    private initializeChildEditor;
+    private buildValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisTableWidgetConfigEditor, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisTableWidgetConfigEditor, "praxis-table-widget-config-editor", never, { "inputs": { "alias": "inputs"; "required": false; }; "widgetKey": { "alias": "widgetKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface PraxisFilterWidgetEditorInputs {
+    resourcePath?: string | null;
+    fieldMetadata?: FieldMetadata[] | null;
+    filterId?: string;
+    formId?: string;
+    componentInstanceId?: string;
+    alwaysVisibleFields?: string[];
+    alwaysVisibleFieldMetadataOverrides?: Record<string, Record<string, unknown>>;
+    selectedFieldIds?: string[];
+    allowSaveTags?: boolean;
+    changeDebounceMs?: number;
+    placeBooleansInActions?: boolean;
+    showToggleLabels?: boolean;
+    alwaysMinWidth?: number;
+    alwaysColsMd?: number;
+    alwaysColsLg?: number;
+    confirmTagDelete?: boolean;
+    tagColor?: 'primary' | 'accent' | 'warn' | 'basic';
+    tagVariant?: 'filled' | 'outlined';
+    tagButtonColor?: 'primary' | 'accent' | 'warn' | 'basic';
+    actionsButtonColor?: 'primary' | 'accent' | 'warn' | 'basic';
+    actionsVariant?: 'standard' | 'outlined';
+    useInlineSearchableSelectVariant?: boolean;
+    useInlineRangeVariant?: boolean;
+    useInlineDateVariant?: boolean;
+    useInlineDateRangeVariant?: boolean;
+    useInlineTimeVariant?: boolean;
+    useInlineTimeRangeVariant?: boolean;
+    useInlineTreeSelectVariant?: boolean;
+    overlayVariant?: 'card' | 'frosted';
+    overlayBackdrop?: boolean;
+    advancedOpenMode?: 'modal' | 'drawer';
+    advancedClearButtonsEnabled?: boolean;
+    persistenceKey?: string;
+    showFilterSettings?: boolean;
+    enableCustomization?: boolean;
+    [key: string]: unknown;
+}
+interface PraxisFilterWidgetEditorValue {
+    inputs: PraxisFilterWidgetEditorInputs;
+}
+declare class PraxisFilterWidgetConfigEditor implements SettingsValueProvider$1, OnDestroy {
+    widgetKey?: string;
+    set inputs(value: PraxisFilterWidgetEditorInputs | null);
+    get inputs(): PraxisFilterWidgetEditorInputs | null;
+    set filterSettings(component: FilterSettingsComponent | undefined);
+    metadata: FieldMetadata[];
+    settings: FilterConfig;
+    configKey?: string;
+    readonly isDirty$: BehaviorSubject<boolean>;
+    readonly isValid$: BehaviorSubject<boolean>;
+    readonly isBusy$: BehaviorSubject<boolean>;
+    private currentInputs;
+    private settingsEditor?;
+    private subscription;
+    ngOnDestroy(): void;
+    getSettingsValue(): PraxisFilterWidgetEditorValue;
+    onSave(): PraxisFilterWidgetEditorValue;
+    reset(): void;
+    private buildValue;
+    private buildSettingsFromInputs;
+    private projectSettingsToInputs;
+    private normalizeSettings;
+    private normalizeAdvancedOpenMode;
+    private normalizeOverlayVariant;
+    private cloneStringArray;
+    private cloneRecord;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisFilterWidgetConfigEditor, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisFilterWidgetConfigEditor, "praxis-filter-widget-config-editor", never, { "widgetKey": { "alias": "widgetKey"; "required": false; }; "inputs": { "alias": "inputs"; "required": false; }; }, {}, never, never, true, never>;
+}
+
 declare class DataFormatterComponent implements OnInit, OnChanges {
     private cdr;
     private formattingService;
@@ -3270,31 +3763,6 @@ declare class DataFormatterComponent implements OnInit, OnChanges {
     static ɵcmp: i0.ɵɵComponentDeclaration<DataFormatterComponent, "data-formatter", never, { "columnType": { "alias": "columnType"; "required": false; }; "currentFormat": { "alias": "currentFormat"; "required": false; }; }, { "formatChange": "formatChange"; }, never, never, true, never>;
 }
 
-type AnalyticsTableRow = Record<string, string | number | boolean | null>;
-type AnalyticsTableContractSource = 'remote' | 'fallback';
-interface AnalyticsTableViewModel {
-    config: TableConfig;
-    data: AnalyticsTableRow[];
-}
-interface AnalyticsTableContractDefinition<TKey extends string = string> {
-    key: TKey;
-    projectionId: string;
-    path: string;
-    title: PraxisTextValue;
-    subtitle?: PraxisTextValue;
-    fallbackProjection: PraxisAnalyticsProjection;
-    fallbackRows?: AnalyticsTableRow[];
-}
-interface AnalyticsTableContractLoadOptions<TKey extends string = string> {
-    cacheNamespace?: string;
-    queryContexts?: Partial<Record<TKey, PraxisDataQueryContext | null>>;
-}
-interface AnalyticsTableContractLoadResult<TKey extends string = string> {
-    views: Record<TKey, AnalyticsTableViewModel>;
-    sources: Record<TKey, AnalyticsTableContractSource>;
-    errors: Partial<Record<TKey, string>>;
-}
-
 interface AnalyticsTableConfigAdapterOptions {
     title?: PraxisTextValue;
     subtitle?: PraxisTextValue;
@@ -3308,24 +3776,6 @@ declare class AnalyticsTableConfigAdapterService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsTableConfigAdapterService>;
 }
 
-declare class AnalyticsTableStatsApiService {
-    private readonly http;
-    private readonly apiUrl;
-    private readonly statsBuilder;
-    constructor(http: HttpClient, apiUrl: ApiUrlConfig);
-    execute(projection: PraxisAnalyticsProjection, queryContext?: PraxisDataQueryContext | null): Promise<AnalyticsTableRow[]>;
-    private toTableRows;
-    private resolveTimeSeriesCategory;
-    private resolveBucketCategory;
-    private projectMetricValues;
-    private resolveMetricValue;
-    private buildStatsUrl;
-    private applyQueryContext;
-    private normalizeError;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsTableStatsApiService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsTableStatsApiService>;
-}
-
 declare class AnalyticsTableContractService {
     private readonly analyticsSchema;
     private readonly resolver;
@@ -3361,6 +3811,15 @@ declare function buildTableApplyPlan(doc: TableAuthoringDocument, runtime?: Tabl
 }): TableApplyPlan;
 declare function serializeTableAuthoringDocument(doc: TableAuthoringDocument): unknown;
 
+/**
+ * Manifesto de authoring canônico para o componente praxis-table.
+ * Este arquivo define o contrato executável para que agentes de IA editem tabelas.
+ *
+ * @version 2.0.0
+ * @status COMPLIANT - Alinhado com o contrato v2 e TableConfig canônico.
+ */
+declare const PRAXIS_TABLE_AUTHORING_MANIFEST: ComponentAuthoringManifest;
+
 declare class PraxisTableInlineAuthoringEditorComponent implements OnChanges {
     private readonly i18n;
     config: TableConfig;
@@ -3372,6 +3831,9 @@ declare class PraxisTableInlineAuthoringEditorComponent implements OnChanges {
     toolbarVisible: boolean;
     density: 'compact' | 'comfortable' | 'spacious';
     toolbarActionsPosition: 'top' | 'bottom' | 'both';
+    toolbarAppearanceVariant: 'flat' | 'outlined' | 'elevated' | 'integrated';
+    toolbarAppearanceShape: 'square' | 'rounded' | 'pill';
+    toolbarAppearanceDivider: 'none' | 'start' | 'between-groups';
     toolbarHeight: number;
     toolbarActionsBackgroundColor: string;
     paginationEnabled: boolean;
@@ -3399,6 +3861,9 @@ declare class PraxisTableInlineAuthoringEditorComponent implements OnChanges {
     setToolbarVisible(value: boolean): void;
     setDensity(value: 'compact' | 'comfortable' | 'spacious'): void;
     setToolbarActionsPosition(value: 'top' | 'bottom' | 'both'): void;
+    setToolbarAppearanceVariant(value: 'flat' | 'outlined' | 'elevated' | 'integrated'): void;
+    setToolbarAppearanceShape(value: 'square' | 'rounded' | 'pill'): void;
+    setToolbarAppearanceDivider(value: 'none' | 'start' | 'between-groups'): void;
     setToolbarHeight(value: number | string): void;
     setToolbarActionsBackgroundColor(value: string): void;
     setPaginationEnabled(value: boolean): void;
@@ -3426,6 +3891,7 @@ declare class PraxisTableInlineAuthoringEditorComponent implements OnChanges {
     tx(key: string, fallback: string): string;
     private emitConfig;
     private patchToolbar;
+    private patchToolbarAppearance;
     private patchBehavior;
     private patchPagination;
     private patchSorting;
@@ -3461,7 +3927,7 @@ declare class ValueMappingEditorComponent implements OnInit, OnChanges {
         [key: number]: string;
     }>;
     mappingPairs: ValueMappingPair[];
-    dataSource: MatTableDataSource<ValueMappingPair, _angular_material_paginator_d_Zo1cMMo4.M>;
+    dataSource: MatTableDataSource<ValueMappingPair, _angular_material_paginator.MatPaginator>;
     displayedColumns: string[];
     showImportDialog: boolean;
     importJsonText: string;
@@ -3607,7 +4073,6 @@ declare function providePraxisTableMetadata(): Provider;
 declare module '@praxisui/core' {
     interface AiCapabilityCategoryMap {
         meta: true;
-        bindings: true;
         columns: true;
         renderer: true;
         conditional: true;
@@ -3621,6 +4086,7 @@ declare module '@praxisui/core' {
         toolbar: true;
         actions: true;
         export: true;
+        runtime: true;
         performance: true;
         messages: true;
         localization: true;
@@ -3682,5 +4148,336 @@ interface CapabilityCatalog extends AiCapabilityCatalog {
 }
 declare const TABLE_COMPONENT_AI_CAPABILITIES: CapabilityCatalog;
 
-export { AnalyticsTableConfigAdapterService, AnalyticsTableContractService, AnalyticsTableStatsApiService, BOOLEAN_PRESETS, BehaviorConfigEditorComponent, CURRENCY_PRESETS, ColumnsConfigEditorComponent, DATE_PRESETS, DataFormatterComponent, DataFormattingService, FORMULA_TEMPLATES, FilterConfigService, FilterSettingsComponent, FormulaGeneratorService, JsonConfigEditorComponent, MessagesLocalizationEditorComponent, NUMBER_PRESETS, PERCENTAGE_PRESETS, PRAXIS_FILTER_COMPONENT_METADATA, PRAXIS_TABLE_COMPONENT_METADATA, PraxisFilter, PraxisTable, PraxisTableConfigEditor, PraxisTableInlineAuthoringEditorComponent, PraxisTableToolbar, STRING_PRESETS, TABLE_AI_CAPABILITIES, TABLE_COMPONENT_AI_CAPABILITIES, TASK_PRESETS, TableDefaultsProvider, TableRulesEditorComponent, ToolbarActionsEditorComponent, ValueMappingEditorComponent, VisualFormulaBuilderComponent, buildTableApplyPlan, createTableAuthoringDocument, getActionId, getEnum, getTableCapabilities, isTableRendererSupportedByRichContentP0, mapTableRendererToRichContentP0, normalizeTableAuthoringDocument, parseLegacyOrTableDocument, providePraxisFilterMetadata, providePraxisTableMetadata, serializeTableAuthoringDocument, toCanonicalTableConfig, validateTableAuthoringDocument };
-export type { ActionLike, AnalyticsTableConfigAdapterOptions, AnalyticsTableContractDefinition, AnalyticsTableContractLoadOptions, AnalyticsTableContractLoadResult, AnalyticsTableContractSource, AnalyticsTableRow, AnalyticsTableViewModel, ArithmeticParams, BehaviorConfigChange, BooleanFormatterOptions, BulkAction, Capability$1 as Capability, CapabilityCatalog$1 as CapabilityCatalog, CapabilityCategory$1 as CapabilityCategory, ColumnChange, ColumnDataType$1 as ColumnDataType, ConcatenationParams, ConditionalMappingParams, CurrencyFormatterOptions, DataFormattingOptions, DataMode, DateFormatterOptions, DefaultValueParams, EditorDiagnostic, EditorDocument, FieldSchema, FilterConfig, FilterTag, FormatPreset, FormatterConfig, FormulaDefinition, FormulaParameterSchema, FormulaParams, FormulaTemplate, FormulaType, I18n, JsonEditorEvent, JsonValidationResult, MessagesLocalizationChange, NestedPropertyParams, NumberFormatterOptions, PercentageFormatterOptions, ResourcePathIntent, RowAction, RowExpansionChangeBase, RowExpansionChangeEvent, RowExpansionReasonCode, RowExpansionTrigger, StringFormatterOptions, TableApplyPlan, TableAuthoringDocument, TableBindings, Capability as TableComponentCapability, CapabilityCatalog as TableComponentCapabilityCatalog, CapabilityCategory as TableComponentCapabilityCategory, ValueKind as TableComponentValueKind, TableHorizontalScroll, TableProjectionContext, TableRichContentP0Node, TableRuntimeContext, TableValidationContext, ToolbarAction, ToolbarActionsChange, ValueKind$1 as ValueKind, ValueMappingPair };
+type ComponentEditPlanCapability = {
+    path: string;
+    category: string;
+    valueKind: string;
+    description: string;
+    allowedValues?: readonly string[];
+    critical?: boolean;
+};
+declare const TABLE_COMPONENT_EDIT_PLAN_KIND = "praxis.table.component-edit-plan";
+declare const TABLE_COMPONENT_EDIT_PLAN_BATCH_KIND = "praxis.table.component-edit-plan.batch";
+declare const TABLE_COMPONENT_EDIT_PLAN_VERSION = "1.0";
+type TableComponentEditChangeKind = 'add_column' | 'set_column_format' | 'set_column_header' | 'set_column_visibility' | 'set_column_filterable' | 'set_column_sortable' | 'set_column_width' | 'set_column_order' | 'set_column_align' | 'set_column_style' | 'set_column_header_style' | 'set_column_sticky' | 'set_column_conditional_style' | 'set_row_conditional_style' | 'set_column_computed' | 'set_column_value_mapping' | 'set_column_renderer' | 'set_column_badge_renderer' | 'set_column_conditional_badge_renderers' | 'set_row_conditional_renderer' | 'configure_table_filtering' | 'configure_advanced_filters' | 'add_advanced_filter_fields' | 'remove_advanced_filter_fields' | 'configure_table_pagination' | 'configure_table_selection' | 'configure_table_sorting' | 'configure_toolbar' | 'add_toolbar_action' | 'add_row_action' | 'add_bulk_action' | 'configure_export' | 'set_table_density' | 'set_toolbar_visibility';
+type TableComponentEditOperationId = 'column.add' | 'column.format.set' | 'column.header.set' | 'column.visibility.set' | 'column.filterable.set' | 'column.sortable.set' | 'column.width.set' | 'column.order.set' | 'column.align.set' | 'column.style.set' | 'column.headerStyle.set' | 'column.sticky.set' | 'column.renderer.set' | 'column.valueMapping.set' | 'column.conditionalStyle.add' | 'row.styleRule.add' | 'column.conditionalRenderer.add' | 'column.computed.add' | 'row.conditionalRenderer.add' | 'behavior.filtering.configure' | 'filter.advanced.configure' | 'filter.advanced.fields.add' | 'filter.advanced.fields.remove' | 'behavior.pagination.configure' | 'behavior.selection.configure' | 'behavior.sorting.configure' | 'toolbar.configure' | 'toolbar.action.add' | 'rowAction.add' | 'bulkAction.add' | 'export.configure' | 'appearance.density.set' | 'toolbar.visibility.set';
+declare const TABLE_COMPONENT_EDIT_PLAN_ALLOWED_CHANGE_KINDS: readonly ["add_column", "set_column_format", "set_column_header", "set_column_visibility", "set_column_filterable", "set_column_sortable", "set_column_width", "set_column_order", "set_column_align", "set_column_style", "set_column_header_style", "set_column_sticky", "set_column_conditional_style", "set_row_conditional_style", "set_column_computed", "set_column_value_mapping", "set_column_renderer", "set_column_badge_renderer", "set_column_conditional_badge_renderers", "set_row_conditional_renderer", "configure_table_filtering", "configure_advanced_filters", "add_advanced_filter_fields", "remove_advanced_filter_fields", "configure_table_pagination", "configure_table_selection", "configure_table_sorting", "configure_toolbar", "add_toolbar_action", "add_row_action", "add_bulk_action", "configure_export", "set_table_density", "set_toolbar_visibility"];
+declare const TABLE_COMPONENT_EDIT_PLAN_EXPECTED_PATHS: Record<TableComponentEditChangeKind, string>;
+interface TableComponentEditPlan {
+    kind?: typeof TABLE_COMPONENT_EDIT_PLAN_KIND;
+    version?: typeof TABLE_COMPONENT_EDIT_PLAN_VERSION | string;
+    componentId?: 'praxis-table' | string;
+    changeKind: TableComponentEditChangeKind | string;
+    operationId?: TableComponentEditOperationId | string;
+    capabilityPath?: string;
+    configPath?: string;
+    field?: string;
+    targetField?: string;
+    target?: unknown;
+    input?: unknown;
+    params?: unknown;
+    value?: unknown;
+    condition?: unknown;
+    style?: unknown;
+    cssClass?: unknown;
+    description?: unknown;
+    explanation?: string;
+}
+interface TableComponentEditPlanCompileResult {
+    patch?: Partial<TableConfig>;
+    explanation?: string;
+    warnings: string[];
+    failureCodes: string[];
+}
+declare function getTableComponentEditPlanCapabilities(): ComponentEditPlanCapability[];
+declare const TABLE_COMPONENT_EDIT_PLAN_JSON_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://praxisui.dev/schemas/table/component-edit-plan.v1.schema.json";
+    readonly title: "Praxis Table Component Edit Plan";
+    readonly description: "Declarative, versioned contract for AI-authored table column edits.";
+    readonly oneOf: readonly [{
+        readonly $ref: "#/$defs/singlePlanEnvelope";
+    }, {
+        readonly $ref: "#/$defs/batchPlanEnvelope";
+    }];
+    readonly $defs: {
+        readonly changeKind: {
+            readonly type: "string";
+            readonly enum: readonly ["add_column", "set_column_format", "set_column_header", "set_column_visibility", "set_column_filterable", "set_column_sortable", "set_column_width", "set_column_order", "set_column_align", "set_column_style", "set_column_header_style", "set_column_sticky", "set_column_conditional_style", "set_row_conditional_style", "set_column_computed", "set_column_value_mapping", "set_column_renderer", "set_column_badge_renderer", "set_column_conditional_badge_renderers", "set_row_conditional_renderer", "configure_table_filtering", "configure_advanced_filters", "add_advanced_filter_fields", "remove_advanced_filter_fields", "configure_table_pagination", "configure_table_selection", "configure_table_sorting", "configure_toolbar", "add_toolbar_action", "add_row_action", "add_bulk_action", "configure_export", "set_table_density", "set_toolbar_visibility"];
+        };
+        readonly capabilityPath: {
+            readonly type: "string";
+            readonly enum: string[];
+        };
+        readonly jsonLogicExpression: {
+            readonly type: "object";
+            readonly minProperties: 1;
+            readonly additionalProperties: true;
+        };
+        readonly badge: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly text: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly textField: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly color: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly variant: {
+                    readonly type: "string";
+                    readonly enum: readonly ["filled", "outlined", "soft"];
+                };
+                readonly icon: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly tooltip: {
+                    readonly $ref: "#/$defs/tooltip";
+                };
+            };
+            readonly anyOf: readonly [{
+                readonly required: readonly ["text"];
+            }, {
+                readonly required: readonly ["textField"];
+            }];
+        };
+        readonly tooltip: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["text"];
+            readonly properties: {
+                readonly text: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly position: {
+                    readonly type: "string";
+                    readonly enum: readonly ["top", "right", "bottom", "left", "above", "below", "before", "after"];
+                };
+                readonly bgColor: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly delayMs: {
+                    readonly type: "number";
+                };
+            };
+        };
+        readonly operation: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "praxis.table.component-edit-plan";
+                };
+                readonly version: {
+                    readonly const: "1.0";
+                };
+                readonly componentId: {
+                    readonly const: "praxis-table";
+                };
+                readonly operationId: {
+                    readonly enum: readonly ["column.add", "column.format.set", "column.header.set", "column.visibility.set", "column.filterable.set", "column.sortable.set", "column.width.set", "column.order.set", "column.align.set", "column.style.set", "column.headerStyle.set", "column.sticky.set", "column.renderer.set", "column.valueMapping.set", "column.conditionalStyle.add", "row.styleRule.add", "column.conditionalRenderer.add", "column.computed.add", "row.conditionalRenderer.add", "behavior.filtering.configure", "filter.advanced.configure", "filter.advanced.fields.add", "filter.advanced.fields.remove", "behavior.pagination.configure", "behavior.selection.configure", "behavior.sorting.configure", "toolbar.configure", "toolbar.action.add", "rowAction.add", "bulkAction.add", "export.configure", "appearance.density.set", "toolbar.visibility.set"];
+                };
+                readonly target: true;
+                readonly input: true;
+                readonly params: true;
+                readonly changeKind: {
+                    readonly $ref: "#/$defs/changeKind";
+                };
+                readonly capabilityPath: {
+                    readonly $ref: "#/$defs/capabilityPath";
+                };
+                readonly configPath: {
+                    readonly $ref: "#/$defs/capabilityPath";
+                };
+                readonly field: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly targetField: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly value: true;
+                readonly condition: true;
+                readonly style: true;
+                readonly cssClass: true;
+                readonly description: {
+                    readonly type: "string";
+                };
+                readonly explanation: {
+                    readonly type: "string";
+                };
+            };
+            readonly anyOf: readonly [{
+                readonly required: readonly ["changeKind", "field", "value"];
+            }, {
+                readonly required: readonly ["operationId", "target", "input"];
+            }, {
+                readonly required: readonly ["operationId", "input"];
+            }];
+            readonly allOf: readonly [{
+                readonly if: {
+                    readonly properties: {
+                        readonly changeKind: {
+                            readonly const: "set_column_conditional_style";
+                        };
+                    };
+                    readonly required: readonly ["changeKind"];
+                };
+                readonly then: {
+                    readonly properties: {
+                        readonly value: {
+                            readonly type: "object";
+                            readonly required: readonly ["condition"];
+                            readonly properties: {
+                                readonly condition: {
+                                    readonly $ref: "#/$defs/jsonLogicExpression";
+                                };
+                                readonly cssClass: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                                readonly style: {
+                                    readonly type: "object";
+                                    readonly minProperties: 1;
+                                };
+                                readonly description: {
+                                    readonly type: "string";
+                                };
+                            };
+                            readonly anyOf: readonly [{
+                                readonly required: readonly ["cssClass"];
+                            }, {
+                                readonly required: readonly ["style"];
+                            }];
+                        };
+                    };
+                };
+            }, {
+                readonly if: {
+                    readonly properties: {
+                        readonly changeKind: {
+                            readonly const: "set_column_conditional_badge_renderers";
+                        };
+                    };
+                    readonly required: readonly ["changeKind"];
+                };
+                readonly then: {
+                    readonly properties: {
+                        readonly value: {
+                            readonly oneOf: readonly [{
+                                readonly $ref: "#/$defs/conditionalBadgeRules";
+                            }, {
+                                readonly type: "object";
+                                readonly required: readonly ["rules"];
+                                readonly properties: {
+                                    readonly rules: {
+                                        readonly $ref: "#/$defs/conditionalBadgeRules";
+                                    };
+                                };
+                                readonly additionalProperties: false;
+                            }];
+                        };
+                    };
+                };
+            }];
+        };
+        readonly conditionalBadgeRules: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["condition"];
+                readonly anyOf: readonly [{
+                    readonly required: readonly ["badge"];
+                }, {
+                    readonly required: readonly ["renderer"];
+                }, {
+                    readonly required: readonly ["value"];
+                }, {
+                    readonly required: readonly ["tooltip"];
+                }];
+                readonly properties: {
+                    readonly condition: {
+                        readonly $ref: "#/$defs/jsonLogicExpression";
+                    };
+                    readonly badge: {
+                        readonly $ref: "#/$defs/badge";
+                    };
+                    readonly renderer: {
+                        readonly type: "object";
+                        readonly minProperties: 1;
+                        readonly additionalProperties: true;
+                    };
+                    readonly tooltip: {
+                        readonly $ref: "#/$defs/tooltip";
+                    };
+                    readonly value: {
+                        readonly $ref: "#/$defs/badge";
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                    };
+                    readonly enabled: {
+                        readonly type: "boolean";
+                    };
+                };
+            };
+        };
+        readonly singlePlanEnvelope: {
+            readonly allOf: readonly [{
+                readonly $ref: "#/$defs/operation";
+            }, {
+                readonly type: "object";
+                readonly properties: {
+                    readonly kind: {
+                        readonly const: "praxis.table.component-edit-plan";
+                    };
+                };
+            }];
+        };
+        readonly batchPlanEnvelope: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["kind", "version", "componentId", "operations"];
+            readonly properties: {
+                readonly kind: {
+                    readonly const: "praxis.table.component-edit-plan.batch";
+                };
+                readonly version: {
+                    readonly const: "1.0";
+                };
+                readonly componentId: {
+                    readonly const: "praxis-table";
+                };
+                readonly operations: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly $ref: "#/$defs/operation";
+                    };
+                };
+                readonly explanation: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+};
+declare function coerceTableComponentEditPlans(value: unknown): TableComponentEditPlan[] | null;
+declare function coerceTableComponentEditPlan(value: unknown): TableComponentEditPlan | null;
+declare function compileTableComponentEditPlans(plans: TableComponentEditPlan[], currentConfig: TableConfig): TableComponentEditPlanCompileResult;
+declare function compileTableComponentEditPlan(plan: TableComponentEditPlan, currentConfig: TableConfig): TableComponentEditPlanCompileResult;
+
+export { AnalyticsTableConfigAdapterService, AnalyticsTableContractService, AnalyticsTableStatsApiService, BOOLEAN_PRESETS, BehaviorConfigEditorComponent, CURRENCY_PRESETS, ColumnsConfigEditorComponent, DATE_PRESETS, DataFormatterComponent, DataFormattingService, FORMULA_TEMPLATES, FilterConfigService, FilterSettingsComponent, FormulaGeneratorService, JsonConfigEditorComponent, MessagesLocalizationEditorComponent, NUMBER_PRESETS, PERCENTAGE_PRESETS, PRAXIS_FILTER_COMPONENT_METADATA, PRAXIS_TABLE_AUTHORING_MANIFEST, PRAXIS_TABLE_COMPONENT_METADATA, PRAXIS_TABLE_TOOLBAR_DEFAULT_APPEARANCE, PRAXIS_TABLE_TOOLBAR_TOKEN_PRESETS, PraxisFilter, PraxisFilterWidgetConfigEditor, PraxisTable, PraxisTableConfigEditor, PraxisTableInlineAuthoringEditorComponent, PraxisTableToolbar, PraxisTableWidgetConfigEditor, STRING_PRESETS, TABLE_AI_CAPABILITIES, TABLE_COMPONENT_AI_CAPABILITIES, TABLE_COMPONENT_EDIT_PLAN_ALLOWED_CHANGE_KINDS, TABLE_COMPONENT_EDIT_PLAN_BATCH_KIND, TABLE_COMPONENT_EDIT_PLAN_EXPECTED_PATHS, TABLE_COMPONENT_EDIT_PLAN_JSON_SCHEMA, TABLE_COMPONENT_EDIT_PLAN_KIND, TABLE_COMPONENT_EDIT_PLAN_VERSION, TASK_PRESETS, TableDefaultsProvider, TableRulesEditorComponent, ToolbarActionsEditorComponent, ValueMappingEditorComponent, VisualFormulaBuilderComponent, buildTableApplyPlan, coerceTableComponentEditPlan, coerceTableComponentEditPlans, compileTableComponentEditPlan, compileTableComponentEditPlans, createTableAuthoringDocument, getActionId, getEnum, getTableCapabilities, getTableComponentEditPlanCapabilities, isTableRendererSupportedByRichContentP0, mapTableRendererToRichContentP0, normalizeTableAuthoringDocument, parseLegacyOrTableDocument, providePraxisFilterMetadata, providePraxisTableMetadata, providePraxisTableToolbarAppearance, serializeTableAuthoringDocument, toCanonicalTableConfig, validateTableAuthoringDocument };
+export type { ActionLike, AnalyticsTableConfigAdapterOptions, AnalyticsTableContractDefinition, AnalyticsTableContractLoadOptions, AnalyticsTableContractLoadResult, AnalyticsTableContractSource, AnalyticsTableRow, AnalyticsTableViewModel, ArithmeticParams, BehaviorConfigChange, BooleanFormatterOptions, BulkAction, Capability$1 as Capability, CapabilityCatalog$1 as CapabilityCatalog, CapabilityCategory$1 as CapabilityCategory, ColumnChange, ColumnDataType$1 as ColumnDataType, ConcatenationParams, ConditionalMappingParams, CurrencyFormatterOptions, DataFormattingOptions, DataMode, DateFormatterOptions, DefaultValueParams, EditorDiagnostic, EditorDocument, FieldSchema, FilterConfig, FilterTag, FormatPreset, FormatterConfig, FormulaDefinition, FormulaParameterSchema, FormulaParams, FormulaTemplate, FormulaType, I18n, JsonEditorEvent, JsonValidationResult, MessagesLocalizationChange, NestedPropertyParams, NumberFormatterOptions, PercentageFormatterOptions, PraxisFilterWidgetEditorInputs, PraxisFilterWidgetEditorValue, PraxisTableWidgetEditorInputs, PraxisTableWidgetEditorValue, ResourcePathIntent, RowAction, RowExpansionChangeBase, RowExpansionChangeEvent, RowExpansionReasonCode, RowExpansionTrigger, StringFormatterOptions, TableAiContext, TableAiNavigationContextPack, TableAiNavigationDestinationContext, TableApplyPlan, TableAuthoringDocument, TableBindings, Capability as TableComponentCapability, CapabilityCatalog as TableComponentCapabilityCatalog, CapabilityCategory as TableComponentCapabilityCategory, TableComponentEditChangeKind, TableComponentEditPlan, TableComponentEditPlanCompileResult, ValueKind as TableComponentValueKind, TableHorizontalScroll, TableProjectionContext, TableRichContentP0Node, TableRuntimeContext, TableValidationContext, ToolbarAction, ToolbarActionsChange, ValueKind$1 as ValueKind, ValueMappingPair };