import * as _praxisui_core from '@praxisui/core';
import { TableToolbarAppearanceConfig, TableConfig, TableToolbarAppearanceDensity, ToolbarActionEvent, PraxisExportScope, LoggerService, PraxisI18nService, TableToolbarAppearanceVariant, TableToolbarAppearanceShape, TableToolbarAppearanceDivider, TableToolbarTokenName, ToolbarAction as ToolbarAction$1, GlobalConfigService, AsyncConfigStorage, LocalStorageConfigService, ApiUrlEntry, FieldMetadata, SchemaIdParams, FormConfig, GenericCrudService, DynamicFormService, SchemaNormalizerService, ComponentKeyService, ComponentDocMeta, PraxisTextValue, PraxisAnalyticsProjection, PraxisDataQueryContext, ApiUrlConfig, PraxisQueryFilterExpression, RecordRelatedSurfaceContextPack, PraxisResourceEvent, LoadingState, RestApiLinks, ColumnDefinition, RichBlockNode, ResourceCapabilityDigest, ConnectionStorage, LoadingOrchestrator, GlobalActionService, EnterpriseRuntimeContextService, PraxisLoadingRenderer, PraxisRuntimeComponentObservationEnvelope, TableDetailRichListNode, TableDetailCardGridNode, TableDetailCardGridCardNode, TableDetailTimelineNode, JsonLogicDataRecord, TableDetailListItemAction, TableDetailActionBarNode, TableDetailActionBarAction, TableDetailRefNode, TableDetailTemplateRefNode, TableDetailDiagramEmbedNode, TableDetailEmbedAction, GlobalActionRef, PraxisRuntimeGlobalActionEffect, ResourceActionCatalogItem, ResourceSurfaceCatalogItem, ResourceCapabilityOperation, JsonLogicExpression, PraxisPresentationVisualizationKind, PraxisTableCellVisualizationConstraint, GlobalActionCatalogEntry, IconPickerService, SurfaceOpenPayload, GlobalActionField, FieldDefinition, PraxisRuntimeConditionalEffectRule, PraxisJsonLogicService, TableConfigService, SettingsValueProvider as SettingsValueProvider$1, ResourceQuickConnectComponent, AnalyticsSchemaContractService, AnalyticsPresentationResolver, RichPresenterNode, RichComposeNode, ComponentAuthoringManifest, AiCapability, AiCapabilityCategory, AiValueKind, AiCapabilityCatalog } from '@praxisui/core';
import * as i0 from '@angular/core';
import { InjectionToken, AfterViewInit, OnDestroy, EventEmitter, ElementRef, Provider, OnInit, OnChanges, DoCheck, DestroyRef, ChangeDetectorRef, NgZone, SimpleChanges, ComponentRef, AfterViewChecked, AfterContentInit, Injector, Type } from '@angular/core';
import { ActivatedRoute } from '@angular/router';
import { SafeHtml } from '@angular/platform-browser';
import { MatTable, MatTableDataSource } from '@angular/material/table';
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 { MatMenuTrigger } from '@angular/material/menu';
import { MatSnackBar } from '@angular/material/snack-bar';
import { SelectionModel } from '@angular/cdk/collections';
import { CdkDragDrop, CdkDragEnd, CdkDrag, CdkDropList } from '@angular/cdk/drag-drop';
import { Observable, BehaviorSubject, Subscription } from 'rxjs';
import { SettingsPanelService, SettingsValueProvider } from '@praxisui/settings-panel';
import { FormGroup, FormControl, FormBuilder } from '@angular/forms';
import { MatDialog } from '@angular/material/dialog';
import { PdxCollectionSearchComponent, OptionDisplayResolverService, BaseDynamicFieldComponent } from '@praxisui/dynamic-fields';
import { CdkOverlayOrigin, ConnectedPosition } from '@angular/cdk/overlay';
import { PraxisDialog } from '@praxisui/dialog';
import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
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 { RuleEffectDefinition } from '@praxisui/table-rule-builder';
import { MatCheckboxChange } from '@angular/material/checkbox';

interface ActionLike {
    action?: string;
    id?: string;
    code?: string;
    key?: string;
    name?: string;
    type?: string;
    icon?: string;
    label?: string;
}
declare function getActionId(action: ActionLike): string;

declare const PRAXIS_TABLE_TOOLBAR_APPEARANCE_PRESETS: Record<string, TableToolbarAppearanceConfig>;
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 AfterViewInit, OnDestroy {
    private hostRef;
    private logger?;
    private i18n?;
    private defaultAppearance?;
    private tokenPresets?;
    private toolbarRoot?;
    private toolbarIdentity?;
    private fullActionsGroup?;
    private endActionsGroup?;
    activeOverflowMenuTrigger?: MatMenuTrigger;
    private activeOverflowMenuTriggerElement?;
    readonly actionsCompacted: i0.WritableSignal<boolean>;
    private actionCapacityObserver?;
    private actionCapacityMutationObserver?;
    private actionCapacityFrame;
    config?: TableConfig;
    appearance?: TableToolbarAppearanceConfig | null;
    backgroundColor: string | null;
    placement: 'header' | 'footer';
    /** Stable runtime scope used only to recover focus after a host re-renders. */
    focusScope: string;
    showMain: boolean;
    showActionsGroup: boolean;
    showEndActions: boolean;
    showMobileActions: boolean;
    exportBusy: boolean;
    exportStatusMessage: string;
    evaluationContext: Record<string, any> | null;
    activeQuickFilterId: string | null;
    activeDensity: TableToolbarAppearanceDensity | null;
    /** @internal Used by PraxisTable so toolbar menu decisions materialize through the table runtime. */
    columnVisibilityController?: (field: string, visible: boolean) => void;
    toolbarAction: EventEmitter<Pick<ToolbarActionEvent<Record<string, unknown>>, "action" | "actionConfig" | "focusOrigin">>;
    exportAction: EventEmitter<{
        format: string;
        scope?: PraxisExportScope;
        localOnly?: boolean;
    }>;
    columnVisibilityToggle: EventEmitter<{
        field: string;
        visible: boolean;
    }>;
    quickFilterChange: EventEmitter<{
        id: string;
        filter: Record<string, unknown>;
        active: boolean;
    }>;
    densityChange: EventEmitter<TableToolbarAppearanceDensity>;
    readonly getActionId: typeof getActionId;
    private readonly jsonLogic;
    private readonly validToolbarActionTypes;
    private readonly warnedInvalidToolbarActionTypes;
    private readonly warnedMenuWithoutChildren;
    private readonly warnedVisibleWhenFallback;
    private readonly warnedDisabledWhenFallback;
    private readonly warnedInvalidShortcuts;
    private readonly warnedInvalidShortcutScopes;
    private readonly warnedShortcutConflicts;
    private fallbackLogger?;
    private fallbackLoggerEnvironment;
    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;
    getCompactActionsGroupLabel(): string;
    getCompactExportGroupLabel(): string;
    getCompactViewGroupLabel(): string;
    getToolbarConfigurationLabel(): string;
    getToolbarIdentityLabel(): string;
    getToolbarIdentityTooltip(): string | null;
    hasToolbarIdentity(): boolean;
    getToolbarTitle(): string;
    getToolbarSubtitle(): string;
    getToolbarIcon(): string | null;
    getToolbarTextAlign(): 'start' | 'center' | 'end';
    getExportDataLabel(): string;
    getVisibleExcelExportLabel(): string;
    getVisibleExcelExportDescription(): string;
    getVisibleExcelExportAriaLabel(): string;
    getExportFormatLabel(format: unknown): string;
    getExportFormatTooltip(format: unknown): string;
    getExportFormatAriaLabel(format: unknown): string;
    getMoreActionsLabel(): string;
    getFocusOriginKey(part: string): string;
    emitExportAction(event: Event, format: string): void;
    emitVisibleExcelExportAction(event: Event): void;
    isExcelExportFormat(format: unknown): boolean;
    isVisibleExcelExportEnabled(format: unknown): boolean;
    private normalizeExportFormat;
    getColumnsVisibilityLabel(): string;
    getQuickFilters(): Array<{
        id: string;
        label: string;
        filter: Record<string, unknown>;
        icon?: string;
    }>;
    shouldShowQuickFilters(): boolean;
    getQuickFiltersLabel(): string;
    getQuickFilterLabel(filter: {
        label: unknown;
        id: string;
    }): string;
    isQuickFilterActive(id: string): boolean;
    emitQuickFilterChange(event: Event, filter: {
        id: string;
        filter: Record<string, unknown>;
    }): void;
    isDensityToggleEnabled(): boolean;
    getDensityToggleLabel(): string;
    getDensityOptions(): TableToolbarAppearanceDensity[];
    isDensityActive(density: TableToolbarAppearanceDensity): boolean;
    getDensityLabel(density: TableToolbarAppearanceDensity): string;
    getDensityIcon(density: TableToolbarAppearanceDensity): string;
    emitDensityChange(event: Event, density: TableToolbarAppearanceDensity): void;
    getColumnsVisibilityIcon(): string;
    isColumnsVisibilityEnabled(): boolean;
    getVisibleColumnsCount(): number;
    isColumnVisibilityToggleDisabled(column: {
        visible?: boolean;
    } | null | undefined): boolean;
    onColumnVisibilityMenuToggle(event: Event, field: string, currentlyVisible: boolean): void;
    toggleColumnVisibility(field: string, visible: boolean): void;
    private tx;
    private interpolateText;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private scheduleActionCapacityCheck;
    private updateActionCapacity;
    private getIdentityRequiredWidth;
    private readPixelValue;
    getToolbarVariant(): TableToolbarAppearanceVariant;
    getToolbarDensity(): TableToolbarAppearanceDensity;
    getToolbarShape(): TableToolbarAppearanceShape;
    getToolbarDivider(): TableToolbarAppearanceDivider;
    getToolbarLayoutAlignment(): 'start' | 'center' | 'end' | 'space-between';
    getToolbarLayoutPadding(): string | null;
    shouldShowLayoutSeparator(): boolean;
    getToolbarToken(name: TableToolbarTokenName): string | null;
    private resolveToolbarAppearance;
    private resolveToolbarAppearancePreset;
    private mergeToolbarAppearance;
    private normalizeTokenValue;
    private getNestedPropertyValue;
    private cloneForEmit;
    private getLogger;
    private warnLog;
    emitToolbarAction(event: Event, action: string, actionConfig?: ToolbarAction$1, focusOrigin?: HTMLElement): void;
    setActiveOverflowMenuTrigger(trigger: MatMenuTrigger, origin?: unknown): void;
    emitOverflowToolbarAction(event: Event, action: string, actionConfig?: ToolbarAction$1): void;
    getStartActions(): any[];
    getNonStartActions(): any[];
    hasBusinessActions(): boolean;
    hasCompactCommands(): boolean;
    getOverflowActions(): any[];
    getActionType(action: any): 'button' | 'icon' | 'fab' | 'menu';
    getActionChildren(action: any): any[];
    getVisibleActionChildren(action: any): any[];
    isMenuWithoutChildren(action: any): boolean;
    getActionColor(action: any): any;
    getActionAriaLabel(action: any): string;
    isActionDisabled(action: any): boolean;
    getActionTooltip(action: any): string | null;
    getActionDisabledReason(action: any): string | null;
    getCompactOverflowCommonDisabledReason(): string | null;
    getCompactActionSpecificDisabledReason(action: any): string | null;
    getActionAriaDisabled(action: any): 'true' | null;
    onDocumentKeydown(event: KeyboardEvent): void;
    getBulkActionsPosition(): 'toolbar' | 'floating' | 'both';
    shouldRenderToolbarBulkActions(): boolean;
    getBulkToolbarActions(): any[];
    private isBulkToolbarAction;
    private getVisibleToolbarActions;
    private resolveVisibleToolbarAction;
    private isActionVisible;
    private evaluateVisibleWhen;
    private evaluateDisabledWhen;
    private resolveDisabledWhenFallback;
    private isJsonLogicExpression;
    private resolveVisibleWhenFallback;
    private resolveVisibleWhenFallbackPolicy;
    private resolveRuntimeEnvironment;
    private buildEvaluationContext;
    private getSelectedCount;
    private getBulkActionMinSelections;
    private getBulkActionMaxSelections;
    private isSelectionTargetAction;
    private getTargetMinSelections;
    private getTargetMaxSelections;
    private resolveDisabledActionReason;
    private warnVisibleWhenFallback;
    private warnDisabledWhenFallback;
    private collectShortcutBindings;
    private resolveShortcutScope;
    private normalizeShortcutCombo;
    private getShortcutComboFromEvent;
    private normalizeShortcutKey;
    private isEditableElement;
    private isEventInsideToolbar;
    private wasShortcutAlreadyHandled;
    private markShortcutHandled;
    private warnInvalidShortcut;
    private warnInvalidShortcutScope;
    private warnShortcutConflict;
    private sortActions;
    getExportIcon(format: string): string;
    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; }; "focusScope": { "alias": "focusScope"; "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; }; "exportStatusMessage": { "alias": "exportStatusMessage"; "required": false; }; "evaluationContext": { "alias": "evaluationContext"; "required": false; }; "activeQuickFilterId": { "alias": "activeQuickFilterId"; "required": false; }; "activeDensity": { "alias": "activeDensity"; "required": false; }; "columnVisibilityController": { "alias": "columnVisibilityController"; "required": false; }; }, { "toolbarAction": "toolbarAction"; "exportAction": "exportAction"; "columnVisibilityToggle": "columnVisibilityToggle"; "quickFilterChange": "quickFilterChange"; "densityChange": "densityChange"; }, never, ["[advancedFilter]", "[toolbar]", "[end-actions]"], true, never>;
}

type ColumnDataType$1 = 'date' | 'number' | 'currency' | 'percentage' | 'string' | 'boolean' | 'custom';
interface FormatterConfig {
    type: ColumnDataType$1;
    options: any;
}
interface DateFormatterOptions {
    preset?: string;
    customFormat?: string;
}
interface NumberFormatterOptions {
    decimalPlaces?: 'fixed' | 'variable';
    fixedDecimals?: number;
    minDecimals?: number;
    maxDecimals?: number;
    thousandsSeparator?: boolean;
    signDisplay?: 'auto' | 'always' | 'never' | 'exceptZero';
}
interface CurrencyFormatterOptions {
    currencyCode?: string;
    currencySymbol?: string;
    symbolPosition?: 'before' | 'after';
    symbolSpacing?: boolean;
    decimalPlaces?: number;
    thousandsSeparator?: boolean;
}
interface PercentageFormatterOptions {
    decimalPlaces?: number;
    showSymbol?: boolean;
    multiplier?: boolean;
}
interface StringFormatterOptions {
    transform?: 'none' | 'uppercase' | 'lowercase' | 'titlecase' | 'capitalize';
    truncate?: boolean;
    maxLength?: number;
    truncateSuffix?: string;
}
interface BooleanFormatterOptions {
    display?: 'true-false' | 'yes-no' | 'active-inactive' | 'on-off' | 'enabled-disabled' | 'custom';
    trueValue?: string;
    falseValue?: string;
}
interface FormatPreset {
    label: string;
    description: string;
    value: string;
    example: string;
}
declare const DATE_PRESETS: FormatPreset[];
declare const NUMBER_PRESETS: FormatPreset[];
declare const CURRENCY_PRESETS: FormatPreset[];
declare const PERCENTAGE_PRESETS: FormatPreset[];
declare const STRING_PRESETS: FormatPreset[];
declare const BOOLEAN_PRESETS: FormatPreset[];

interface FormattingLocalization {
    locale?: string;
    dateTime?: {
        dateFormat?: string;
        timeFormat?: string;
        dateTimeFormat?: string;
    };
    number?: {
        decimalSeparator?: string;
        thousandsSeparator?: string;
        defaultPrecision?: number;
        negativeSign?: string;
        negativeSignPosition?: 'before' | 'after';
    };
    currency?: {
        code?: string;
        symbol?: string;
        position?: 'before' | 'after';
        spacing?: boolean;
        precision?: number;
    };
    formatting?: {
        percentageFormat?: string;
    };
}
interface DataFormattingOptions {
    locale?: string;
    localization?: FormattingLocalization | null;
}
declare class DataFormattingService {
    private readonly hostLocale;
    private readonly localePipeCache;
    private readonly numericSeparatorCache;
    private readonly upperCasePipe;
    private readonly lowerCasePipe;
    private readonly titleCasePipe;
    constructor(hostLocale: string);
    /**
     * Apply formatting to a value based on column type and format string.
     * Formatting can honor a runtime locale/localization override before
     * falling back to the host LOCALE_ID.
     */
    formatValue(value: any, columnType: ColumnDataType$1, formatString: string, options?: DataFormattingOptions): any;
    private coerceValueToType;
    private parseDateOnlyString;
    private normalizeNumericDateInput;
    private formatDate;
    private formatNumber;
    private formatCurrency;
    private formatPercentage;
    private formatString;
    private applyStringTransform;
    private isMaskFormat;
    private applyMask;
    private formatBoolean;
    needsFormatting(columnType: ColumnDataType$1, formatString: string | null | undefined): boolean;
    getHostLocale(): string;
    private resolveFormattingContext;
    private getLocalePipeBundle;
    private getNumericSeparators;
    private parseDigitsInfo;
    private getNumberOverrides;
    private normalizeNumericInput;
    private composeNumericParts;
    private escapeRegExp;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataFormattingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DataFormattingService>;
}

/**
 * Provides default table configurations.
 * Applications may override this service to supply product or tenant-specific defaults.
 */
declare class TableDefaultsProvider {
    private readonly global;
    constructor(global: GlobalConfigService);
    /**
     * Returns default configuration for a given table identifier.
     * @param tableId Table identifier
     */
    getDefaults(_tableId: string): TableConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableDefaultsProvider, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TableDefaultsProvider>;
}

type FilterConfig = {
    alwaysVisibleFields?: string[];
    /**
     * Deep metadata overrides for any field rendered by the filter runtime.
     * This is used by runtime authoring to project field-level patches without
     * mutating the canonical schema metadata returned by the source.
     */
    fieldMetadataOverrides?: Record<string, Record<string, any>>;
    /**
     * Deep metadata overrides for always-visible fields.
     * Source of truth remains the filter DTO; this map applies controlled
     * overrides per field after DTO normalization.
     */
    alwaysVisibleFieldMetadataOverrides?: Record<string, Record<string, any>>;
    /** User-selected extra field ids to show before pinned always-visible */
    selectedFieldIds?: string[];
    showAdvanced?: boolean;
    mode?: 'filter';
    changeDebounceMs?: number;
    allowSaveTags?: boolean;
    /** Governed shortcuts shipped with the table config; user shortcuts remain persisted separately. */
    tags?: Array<{
        id: string;
        label: string;
        patch: Record<string, any>;
    }>;
    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';
    /**
     * Opt-in para mapear searchable-select na variante compacta inline.
     * Padrão recomendado: false em cenários corporativos com catálogos grandes/remotos.
     */
    /** Opt-out para mapear searchable-select/async-select/autocomplete na variante compacta inline. */
    useInlineSearchableSelectVariant?: boolean;
    /** Opt-out para mapear rangeSlider na variante compacta inline (single/range). */
    useInlineRangeVariant?: boolean;
    /** Opt-out para mapear date/dateInput/datepicker na variante compacta inline. */
    useInlineDateVariant?: boolean;
    /** Opt-out para mapear dateRange/daterange na variante compacta inline. */
    useInlineDateRangeVariant?: boolean;
    /** Opt-out para mapear time/timePicker na variante compacta inline. */
    useInlineTimeVariant?: boolean;
    /** Opt-out para mapear timeRange/timerange na variante compacta inline. */
    useInlineTimeRangeVariant?: boolean;
    /** Opt-out para mapear treeSelect/multiSelectTree na variante compacta inline. */
    useInlineTreeSelectVariant?: boolean;
    overlayVariant?: 'card' | 'frosted';
    overlayBackdrop?: boolean;
    advancedOpenMode?: 'overlay' | 'modal' | 'drawer';
    /** Habilita botão de limpar nos campos do formulário avançado. */
    advancedClearButtonsEnabled?: boolean;
    logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
    enablePerformanceMetrics?: boolean;
};
declare class FilterConfigService {
    private storage;
    private localStorage;
    private readonly PREFIX;
    constructor(storage: AsyncConfigStorage, localStorage: LocalStorageConfigService);
    /**
     * Load a persisted filter configuration for the given key.
     */
    load(key: string): Promise<FilterConfig | undefined>;
    /**
     * Persist a filter configuration for the given key.
     */
    save(key: string, config: FilterConfig): Promise<void>;
    /**
     * Clear the persisted filter configuration from both remote storage and the
     * local fallback cache so reset/reopen cannot revive stale preferences.
     */
    clear(key: string): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FilterConfigService>;
}

declare const PRAXIS_FILTER_VIEW_CONTEXT_SCHEMA_VERSION: "praxis.filter-view-context.v1";
interface PraxisFilterViewField {
    field: string;
    fieldLabel: string;
    rawValue: unknown;
    displayValue: string;
    displayResolved: boolean;
}
/**
 * Presentation projection of a filter DTO.
 *
 * `filter` remains the canonical backend payload. The other properties are
 * display evidence for page composition and must not be sent as query fields.
 */
interface PraxisFilterViewContext {
    schemaVersion: typeof PRAXIS_FILTER_VIEW_CONTEXT_SCHEMA_VERSION;
    filter: Record<string, unknown>;
    labels: Record<string, string>;
    fieldLabels: Record<string, string>;
    fields: PraxisFilterViewField[];
}

type FilterTag = {
    id: string;
    label: string;
    patch: Record<string, any>;
};
type ManagedFilterItem = {
    id: string;
    label: string;
    /** Domain guidance preserved from FieldMetadata for the field-manager tooltip. */
    description?: string;
};
type I18n = {
    searchPlaceholder: string;
    advanced: string;
    advancedTitle?: string;
    advancedOpening?: string;
    advancedUnavailable?: string;
    clear: string;
    apply: string;
    add?: string;
    filtersAdd?: string;
    filtersSearch?: string;
    addCount?: string;
    addCountSingular?: string;
    manageFieldsTitle?: string;
    manageFieldsDescription?: string;
    close?: string;
    clearSearch?: string;
    /** @deprecated Prefer selectedFieldsCount/selectedFieldsCountSingular. */
    selectedFieldsSuffix?: string;
    selectedFieldsCount?: string;
    selectedFieldsCountSingular?: string;
    selectedFieldsSectionTitle?: string;
    fixedFieldsSectionTitle?: string;
    fixedFieldDescription?: string;
    availableFieldsSectionTitle?: string;
    manageFieldsApply?: string;
    selectAllResults?: string;
    noFilterFieldsFound?: string;
    fieldSelectionConflict?: string;
    removingActiveFields?: string;
    fieldPendingAddition?: string;
    fieldPendingRemoval?: string;
    fieldAddedAnnouncement?: string;
    fieldRemovedAnnouncement?: string;
    fieldSelectionSummaryAnnouncement?: string;
    addUnavailable?: string;
    pendingCount?: string;
    activeFiltersCount?: string;
    selectAll?: string;
    selectAllPartial?: string;
    edit: string;
    noData: string;
    quickFieldNotFound: string;
    saveAsShortcut: string;
    removeShortcut: string;
    renameShortcut: string;
    deleteShortcutConfirm: string;
    retry: string;
    errorLoadingFilters: string;
    settings: string;
    settingsAriaLabel?: string;
    tagActionsAriaLabel?: string;
    save: string;
    cancel: string;
    shortcutsLabel?: string;
    shortcutSaved: string;
    readonlyShortcut: string;
    shortcutRemoved: string;
    undo: string;
};
declare class PraxisFilter implements OnInit, OnChanges, AfterViewInit, OnDestroy, DoCheck {
    private crud;
    private configStorage;
    private destroyRef;
    private filterConfig;
    private settingsPanel;
    private snackBar;
    private dialog;
    private praxisDialog;
    private cdr;
    private ngZone;
    private dynamicForm;
    private optionDisplayResolver;
    private viewContextCrud;
    private schemaNormalizer;
    private componentKeys;
    private route?;
    private logger?;
    addManagerOrigin?: ElementRef<HTMLButtonElement>;
    addManagerSearch?: PdxCollectionSearchComponent;
    resourcePath: string;
    /** Resolved API entry carried by detached hosts when route-scoped API_URL is not inherited. */
    apiUrlEntry?: ApiUrlEntry | null;
    /**
     * Optional static metadata for offline/showcase usage.
     * When this input is provided (including an empty array), server schema loading is bypassed.
     */
    fieldMetadata?: FieldMetadata[] | null;
    filterId?: string;
    formId?: string;
    componentInstanceId?: string;
    mode: 'filter';
    /** Controls outdated schema notifications visibility and channel (only effective in edit mode) */
    notifyIfOutdated: 'inline' | 'snackbar' | 'both' | 'none';
    /** Snooze duration for schema outdated notifications (ms), only in edit mode */
    snoozeMs: number;
    /** Auto open settings when schema is detected as outdated (only in edit mode) */
    autoOpenSettingsOnOutdated: boolean;
    /** Enable edit mode (gates notifications) */
    enableCustomization: boolean;
    value?: Record<string, any>;
    alwaysVisibleFields?: string[];
    /**
     * Optional metadata overrides for always-visible fields.
     * Keys are field names from the filter DTO schema.
     */
    alwaysVisibleFieldMetadataOverrides: Record<string, Record<string, any>> | undefined;
    /** Runtime field-level metadata overrides applied by the metadata editor. */
    private fieldMetadataOverrides;
    /** Additional selected field ids to render before pinned always-visible */
    selectedFieldIds: string[];
    tags?: FilterTag[];
    allowSaveTags?: boolean;
    persistenceKey?: string;
    disablePersistence: boolean;
    i18n?: Partial<I18n>;
    changeDebounceMs: number;
    /** Controla a exibição do botão de preferências dentro do filtro */
    showFilterSettings: boolean;
    /** Controla a exibição do botão de filtro avançado */
    showAdvancedButton: boolean;
    /** Controla a exibição do botão de adicionar campos */
    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 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 */
    showToggleLabels: boolean;
    /** Usa variante compacta de select no modo inline para ganhar espaço */
    useInlineSelectVariant: boolean;
    /** Habilita variante inline para searchable-select, async-select e autocomplete. */
    useInlineSearchableSelectVariant: boolean;
    /** Usa variante compacta de multi-select no modo inline para ganhar espaço */
    useInlineMultiSelectVariant: boolean;
    /** Usa variante compacta de input/search no modo inline para ganhar espaço */
    useInlineInputVariant: boolean;
    /** Usa variante compacta de toggle no modo inline para ganhar espaço */
    useInlineToggleVariant: boolean;
    /** Usa variante compacta de range slider (modo simples) para ganhar espaço */
    useInlineRangeVariant: boolean;
    /** Usa variante compacta de date/dateInput/datepicker no modo inline para ganhar espaço */
    useInlineDateVariant: boolean;
    /** Usa variante compacta de dateRange/daterange no modo inline para ganhar espaço */
    useInlineDateRangeVariant: boolean;
    /** Usa variante compacta de time/timePicker no modo inline para ganhar espaço */
    useInlineTimeVariant: boolean;
    /** Usa variante compacta de timeRange/timerange no modo inline para ganhar espaço */
    useInlineTimeRangeVariant: boolean;
    /** Usa variante compacta de treeSelect no modo inline para ganhar espaço */
    useInlineTreeSelectVariant: boolean;
    /** Config da grade dos alwaysVisible */
    alwaysMinWidth: number;
    alwaysColsMd: number;
    alwaysColsLg: number;
    /** Tag theming */
    tagColor: 'primary' | 'accent' | 'warn' | 'basic';
    tagVariant: 'filled' | 'outlined';
    tagButtonColor: 'primary' | 'accent' | 'warn' | 'basic';
    /** Action buttons theming */
    actionsButtonColor: 'primary' | 'accent' | 'warn' | 'basic';
    actionsVariant: 'standard' | 'outlined';
    /** Overlay appearance */
    overlayVariant: 'card' | 'frosted';
    overlayBackdrop: boolean;
    /** Advanced panel open mode */
    advancedOpenMode: 'modal' | 'drawer';
    /** Habilita botão de limpar nos campos do formulário avançado */
    advancedClearButtonsEnabled?: boolean;
    submit: EventEmitter<Record<string, any>>;
    change: EventEmitter<Record<string, any>>;
    clear: EventEmitter<void>;
    modeChange: EventEmitter<"filter">;
    requestSearch: EventEmitter<Record<string, any>>;
    /** Presentation projection; never use this object as a backend filter DTO. */
    contextChange: EventEmitter<PraxisFilterViewContext>;
    tagsChange: EventEmitter<FilterTag[]>;
    /** Emits when user-selected field ids change */
    selectedFieldIdsChange: EventEmitter<string[]>;
    metaChanged: EventEmitter<{
        schemaId: string;
        serverHash?: string;
        context: SchemaIdParams;
    }>;
    /** Emits whenever schema outdated state changes (can be used by host) */
    schemaStatusChange: EventEmitter<{
        outdated: boolean;
        serverHash?: string;
        lastVerifiedAt?: string;
        formId?: string;
    }>;
    alwaysForm: FormGroup<Record<string, FormControl<unknown>>>;
    alwaysVisibleMetas: FieldMetadata[];
    /** User-selected field metadata rendered before pinned (always) */
    selectedMetas: FieldMetadata[];
    compactSelectedMetas: FieldMetadata[];
    compactAlwaysVisibleMetas: FieldMetadata[];
    gridSelectedMetas: FieldMetadata[];
    gridAlwaysVisibleMetas: FieldMetadata[];
    toggleMetas: FieldMetadata[];
    activeEditableFieldName: string | null;
    advancedConfig?: FormConfig;
    displayedTags: FilterTag[];
    private savedTags;
    editingTagId?: string;
    editingTagLabel: FormControl<string>;
    schemaLoading: boolean;
    schemaError: boolean;
    private schemaMetas?;
    private viewContextRevision;
    private advancedChange$;
    private alwaysFormReset$;
    private dto;
    advancedOpen: boolean;
    advancedOpening: boolean;
    advancedValid: boolean;
    activeFiltersCount: number;
    saving: boolean;
    i18nLabels: I18n;
    private configKey;
    private lastSchemaMeta?;
    private schemaLoadVersion;
    private readonly storedSchemaMetaCache;
    private schemaMetaIndexCache?;
    private schemaMetaIndexLoadPromise?;
    private verifySchemaInFlight;
    private lastSchemaVerificationByContext;
    schemaOutdated: boolean;
    anchorRef?: CdkOverlayOrigin;
    addAnchor?: CdkOverlayOrigin;
    advancedButton?: ElementRef<HTMLElement>;
    overlayOrigin?: CdkOverlayOrigin;
    overlayWidth: number | string;
    isMobile: boolean;
    advancedTitleId: string;
    advancedPanelId: string;
    addQuery: string;
    addItems: ManagedFilterItem[];
    addDraftSelectedFieldIds: string[];
    addInitialSelectedFieldIds: string[];
    addManagerAnnouncement: string;
    addManagerOpen: boolean;
    addManagerConflict: boolean;
    addManagerItemMotion: {
        id: string;
        type: 'added' | 'removed';
    } | null;
    readonly addManagerTitleId: string;
    readonly addManagerDescriptionId: string;
    readonly addManagerViewportMargin = 8;
    readonly addOverlayPositions: ConnectedPosition[];
    private applySchemaQueued;
    private shortcutPromptOpen;
    private fallbackLogger?;
    private fallbackLoggerEnvironment;
    private isViewInitialized;
    private _dbgPrevAlwaysArrayRef;
    private _dbgPrevToggleArrayRef;
    private _dbgPrevAlwaysFormRef;
    private _dbgDoCheckCount;
    private _dbgLastApplyMetasAt;
    private _dbgLastQuickComponentsAt;
    private _dbgLastAlwaysComponentsAt;
    private _dbgLastToggleComponentsAt;
    overlayPositions: ConnectedPosition[];
    private advancedDebouncedSub?;
    private advancedOpenRequestId;
    private lastActiveElement?;
    private lastSubmitAt;
    private resizeObs?;
    private mutationObs?;
    private _resolvedPrefs;
    private resolveSchemaPrefs;
    private domIdSeed;
    private componentKeyId;
    private isPersistenceDisabled;
    private resolveConfigKey;
    getComponentKeyId(): string | null;
    private filterTagsKey;
    private filterDtoKey;
    private filterSchemaMetaKey;
    private filterSchemaMetaIndexKey;
    private filterSchemaMetaKeyForSchemaId;
    private filterSchemaIgnoreKey;
    private filterSchemaSnoozeKey;
    private filterSchemaNotifiedKey;
    constructor(crud: GenericCrudService<any>, configStorage: AsyncConfigStorage, destroyRef: DestroyRef, filterConfig: FilterConfigService, settingsPanel: SettingsPanelService, snackBar: MatSnackBar, dialog: MatDialog, praxisDialog: PraxisDialog, cdr: ChangeDetectorRef, ngZone: NgZone, dynamicForm: DynamicFormService, optionDisplayResolver: OptionDisplayResolverService, viewContextCrud: GenericCrudService<any>, schemaNormalizer: SchemaNormalizerService, componentKeys: ComponentKeyService, route?: ActivatedRoute | undefined, logger?: LoggerService | undefined);
    private readonly global;
    private resolveRuntimeEnvironment;
    private getLogger;
    get activeEditableFieldMeta(): FieldMetadata | null;
    get activeEditableFieldLabel(): string | null;
    isFieldAuthoringEnabled(): boolean;
    private buildFilterLogOptions;
    private isFilterDebugEnabled;
    private logFilterDebug;
    private logFilterWarn;
    private readonly filterDrawerAdapter;
    private lastSavedConfigJson;
    private setSchemaLoading;
    private setActiveFiltersCount;
    private loadSavedTagsFromStorage;
    private resolveInputDto;
    private emitSubmitDto;
    private emitChangeDto;
    private emitViewContext;
    private resolveViewContextFieldMetadata;
    private formatViewContextFallback;
    private resolveInitialDto;
    private syncFormsFromDto;
    private refreshProgrammaticFilterFieldDisplays;
    private getProgrammaticRefreshFieldNames;
    private refreshProgrammaticFilterFieldDisplay;
    ngOnInit(): Promise<void>;
    ngAfterViewInit(): void;
    onWindowResize(): void;
    private initDynamicObservers;
    onDocumentEscClose(event: KeyboardEvent): void;
    private updateOverlayWidth;
    private computeIsMobile;
    ngOnChanges(changes: SimpleChanges): void;
    private configureCrud;
    private areStringArraysEqual;
    private normalizeFieldIdList;
    private areMetadataOverrideMapsEqual;
    /** Force-sync settings coming from parent table config updates. */
    applyExternalSettings(cfg?: Partial<FilterConfig>): void;
    openSettings(): void;
    createTag(label?: string): void;
    renameTag(tag: FilterTag, label?: string): void;
    deleteTag(tag: FilterTag): void;
    removeFilter(tag: FilterTag): void;
    startEditTag(tag: FilterTag, $event?: Event): void;
    commitEditTag(tag: FilterTag, $event?: Event): void;
    cancelEditTag($event?: Event): void;
    advancedForm?: FormGroup<Record<string, any>>;
    isActiveTag(tag: FilterTag): boolean;
    private equalsDto;
    private normalizeForCompare;
    private buildFilteredSchemaContext;
    private toSchemaIdContext;
    private resetSchemaStateForContextChange;
    private clearSchemaMetaPersistence;
    private clearConfigStorageKey;
    private loadStoredSchemaMeta;
    private rememberSchemaMetaContext;
    private ensureSchemaMetaIndexLoaded;
    private saveStoredSchemaMeta;
    private stableSerialize;
    private normalizeStoredSchemaMetaForComparison;
    private schemaVerificationContextKey;
    private getSchemaMetaKeyForContext;
    private isStoredSchemaMetaForContext;
    private isSameSchemaContext;
    private resolveLocalSchemaHashForContext;
    private persistSchemaMeta;
    private syncSchemaMeta;
    private resolveFallbackSchemaHash;
    private isExplicitlyFilterable;
    private pickSafeGenericFallbackDefs;
    private loadSchemaViaClient;
    private loadSchemaViaCrudFallback;
    loadSchema(): void;
    /**
     * A Dynamic Page may finish binding resource identity while an earlier schema
     * request is still in flight. Discarding that response must also release the
     * loading state and start a request for the effective context; otherwise the
     * advanced-filter affordance remains permanently busy.
     */
    private restartSchemaLoadForCurrentContext;
    retrySchemaLoad(): void;
    private applySchemaMetas;
    private applySchemaMetasNow;
    private withFilterMaterialDesignPolicy;
    private withAdvancedDatePickerTouchPolicy;
    private isAdvancedDatePickerControl;
    private buildAdvancedFilterColumn;
    private isLongTextFilterField;
    private isCompositeRangeFilterField;
    private pickMetasByOrder;
    private hasRemoteOptionSource;
    private normalizeFilterOptionEndpointMetadata;
    private toOwningResourcePathForOptionsFilter;
    private withInferredFilterControlType;
    private isAllowedFilterControlType;
    private inferFilterControlType;
    private cloneAlwaysVisibleMetadataOverrides;
    private cloneFieldMetadataOverrides;
    private sanitizeAlwaysVisibleMetadataOverrides;
    private sanitizeMetadataOverrideValue;
    private mergeAlwaysVisibleMetadata;
    private mergeFieldMetadataOverride;
    ngDoCheck(): 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;
    private openFieldMetadataEditorInternal;
    private applyFieldMetadataPatch;
    private buildFieldMetadataEditorSeed;
    private getEditableFieldMeta;
    private resolveFieldNameFromEvent;
    onAdvancedReady(event: {
        formGroup: FormGroup<Record<string, any>>;
    }): void;
    onAdvancedChange(event: {
        formData: Record<string, any>;
    }): void;
    onAdvancedValidityChange(valid: boolean): void;
    onAddOpened(opened: boolean): void;
    toggleAddManager(): void;
    closeAddManager(): void;
    focusAddManagerSearch(): void;
    toggleManagedField(fieldId: string, checked: boolean): void;
    isAddManagerItemInMotion(fieldId: string, type: 'added' | 'removed'): boolean;
    private startAddManagerItemMotion;
    applyAddManager(): void;
    isAddManagerDirty(): boolean;
    getAddManagerChangeCount(): number;
    getAddManagerSelectedFieldsSummary(): string;
    getAddManagerVisibleSelectedFieldsSummary(): string;
    private getAddManagerFieldsSummary;
    getAddManagerSelectedItems(): ManagedFilterItem[];
    getAddManagerFixedItems(): ManagedFilterItem[];
    getAddManagerFixedFieldAriaLabel(item: ManagedFilterItem): string;
    getAddManagerAvailableItems(): ManagedFilterItem[];
    isAddManagerFieldSelected(fieldId: string): boolean;
    isAddManagerFieldPendingAddition(fieldId: string): boolean;
    isAddManagerFieldPendingRemoval(fieldId: string): boolean;
    getAddManagerFieldPendingLabel(fieldId: string): string;
    getAddManagerFieldAriaDescription(item: ManagedFilterItem): string | null;
    private announceManagedFieldChange;
    getRemovedActiveFieldLabels(): string[];
    private hasMeaningfulFilterValue;
    onAddQuery(q: string): void;
    hasAddableFields(): boolean;
    hasManageableFilterFields(): boolean;
    private getManageableFilterItems;
    /**
     * Uses authored field metadata only. The manager must not invent domain help
     * while an operator decides among similar filters (for example, date variants).
     */
    private getManagedFieldDescription;
    private updateAddItems;
    trackById(_idx: number, it: {
        id: string;
    }): string;
    private isFilterFieldHidden;
    onAddSelectionChange(values: string[] | null | undefined): void;
    private normalizeManagedFieldSelection;
    private mergeSelectedFieldIds;
    private formatWithCount;
    private getVisibleFieldCount;
    getAddAriaLabel(): string;
    getAddTriggerLabel(): string;
    getAddTooltip(): string;
    getActiveFiltersLabel(): string;
    isAllSelected(): boolean;
    isSomeSelected(): boolean;
    toggleSelectAll(): void;
    private clearRemovedSelectedFieldValues;
    onAdvancedSubmit(event: {
        formData: Record<string, any>;
    }): void;
    private closeAdvanced;
    /** Salva o estado atual dos filtros como um atalho (tag) do usuário */
    saveCurrentAsTag(): void;
    /** Persistência centralizada de atalho a partir de um DTO explícito */
    private saveAsShortcutFromDto;
    private requestShortcutLabel;
    getAdvancedAriaLabel(): string;
    getAdvancedTooltip(): string;
    getSettingsAriaLabel(): string;
    getFieldSettingsLabel(): string;
    getSettingsTooltip(): string;
    getTagActionsAriaLabel(tag?: FilterTag): string;
    private getSchemaMetaKey;
    private getOutdatedIgnoreKey;
    private getOutdatedSnoozeKey;
    private getOutdatedNotifiedKey;
    private isOutdatedIgnored;
    private getOutdatedSnoozeUntil;
    private setOutdatedSnooze;
    private setOutdatedIgnore;
    private setOutdatedNotified;
    private wasOutdatedNotified;
    private verifyServerSchemaVersion;
    private runSchemaVerification;
    private maybeShowOutdatedSnack;
    ngOnDestroy(): void;
    isUserTag(tag: FilterTag): boolean;
    toggleTag(tag: FilterTag): void;
    applyTag(tag: FilterTag): void;
    private bindAdvancedDebounce;
    onSubmit(): void;
    onClear(): void;
    private isEventFromNestedOverlay;
    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;
    private captureLastActiveElement;
    private restoreFocusAfterAdvanced;
    private mergeI18n;
    private persist;
    private clearPersisted;
    private persistTags;
    private cleanFilterPayload;
    private upsertDtoValue;
    private normalizeFilterFieldValue;
    private getFilterFieldMetaByName;
    private isEntityLookupFilterField;
    private isEffectivelyEmptyFilterValue;
    private syncFormsToDto;
    private updateDisplayedTags;
    private normalizeMode;
    private normalizeAdvancedOpenMode;
    onGlobalKeydown(event: KeyboardEvent): void;
    private isEditableElement;
    private focusQuick;
    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisFilter, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisFilter, "praxis-filter", never, { "resourcePath": { "alias": "resourcePath"; "required": true; }; "apiUrlEntry": { "alias": "apiUrlEntry"; "required": false; }; "fieldMetadata": { "alias": "fieldMetadata"; "required": false; }; "filterId": { "alias": "filterId"; "required": false; }; "formId": { "alias": "formId"; "required": false; }; "componentInstanceId": { "alias": "componentInstanceId"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "notifyIfOutdated": { "alias": "notifyIfOutdated"; "required": false; }; "snoozeMs": { "alias": "snoozeMs"; "required": false; }; "autoOpenSettingsOnOutdated": { "alias": "autoOpenSettingsOnOutdated"; "required": false; }; "enableCustomization": { "alias": "enableCustomization"; "required": false; }; "value": { "alias": "value"; "required": false; }; "alwaysVisibleFields": { "alias": "alwaysVisibleFields"; "required": false; }; "alwaysVisibleFieldMetadataOverrides": { "alias": "alwaysVisibleFieldMetadataOverrides"; "required": false; }; "selectedFieldIds": { "alias": "selectedFieldIds"; "required": false; }; "tags": { "alias": "tags"; "required": false; }; "allowSaveTags": { "alias": "allowSaveTags"; "required": false; }; "persistenceKey": { "alias": "persistenceKey"; "required": false; }; "disablePersistence": { "alias": "disablePersistence"; "required": false; }; "i18n": { "alias": "i18n"; "required": false; }; "changeDebounceMs": { "alias": "changeDebounceMs"; "required": false; }; "showFilterSettings": { "alias": "showFilterSettings"; "required": false; }; "showAdvancedButton": { "alias": "showAdvancedButton"; "required": false; }; "showAddButton": { "alias": "showAddButton"; "required": false; }; "showClearButton": { "alias": "showClearButton"; "required": false; }; "showSearchButton": { "alias": "showSearchButton"; "required": false; }; "confirmTagDelete": { "alias": "confirmTagDelete"; "required": false; }; "placeBooleansInActions": { "alias": "placeBooleansInActions"; "required": false; }; "showToggleLabels": { "alias": "showToggleLabels"; "required": false; }; "useInlineSelectVariant": { "alias": "useInlineSelectVariant"; "required": false; }; "useInlineSearchableSelectVariant": { "alias": "useInlineSearchableSelectVariant"; "required": false; }; "useInlineMultiSelectVariant": { "alias": "useInlineMultiSelectVariant"; "required": false; }; "useInlineInputVariant": { "alias": "useInlineInputVariant"; "required": false; }; "useInlineToggleVariant": { "alias": "useInlineToggleVariant"; "required": false; }; "useInlineRangeVariant": { "alias": "useInlineRangeVariant"; "required": false; }; "useInlineDateVariant": { "alias": "useInlineDateVariant"; "required": false; }; "useInlineDateRangeVariant": { "alias": "useInlineDateRangeVariant"; "required": false; }; "useInlineTimeVariant": { "alias": "useInlineTimeVariant"; "required": false; }; "useInlineTimeRangeVariant": { "alias": "useInlineTimeRangeVariant"; "required": false; }; "useInlineTreeSelectVariant": { "alias": "useInlineTreeSelectVariant"; "required": false; }; "alwaysMinWidth": { "alias": "alwaysMinWidth"; "required": false; }; "alwaysColsMd": { "alias": "alwaysColsMd"; "required": false; }; "alwaysColsLg": { "alias": "alwaysColsLg"; "required": false; }; "tagColor": { "alias": "tagColor"; "required": false; }; "tagVariant": { "alias": "tagVariant"; "required": false; }; "tagButtonColor": { "alias": "tagButtonColor"; "required": false; }; "actionsButtonColor": { "alias": "actionsButtonColor"; "required": false; }; "actionsVariant": { "alias": "actionsVariant"; "required": false; }; "overlayVariant": { "alias": "overlayVariant"; "required": false; }; "overlayBackdrop": { "alias": "overlayBackdrop"; "required": false; }; "advancedOpenMode": { "alias": "advancedOpenMode"; "required": false; }; "advancedClearButtonsEnabled": { "alias": "advancedClearButtonsEnabled"; "required": false; }; }, { "submit": "submit"; "change": "change"; "clear": "clear"; "modeChange": "modeChange"; "requestSearch": "requestSearch"; "contextChange": "contextChange"; "tagsChange": "tagsChange"; "selectedFieldIdsChange": "selectedFieldIdsChange"; "metaChanged": "metaChanged"; "schemaStatusChange": "schemaStatusChange"; }, never, never, true, never>;
}

declare const PRAXIS_FILTER_COMPONENT_METADATA: ComponentDocMeta;
declare function providePraxisFilterMetadata(): Provider;

type AnalyticsTableRow = Record<string, string | number | boolean | null>;
type AnalyticsTableContractSource = 'remote' | 'fallback';
/**
 * Stable backend bucket identity retained on analytics rows for cross-filtering.
 * It is intentionally not materialized as a visible table column.
 */
declare const ANALYTICS_TABLE_ROW_KEY_FIELD = "__praxisAnalyticsKey";
type AnalyticsComparisonMetricValueKind = 'current' | 'previous' | 'delta' | 'deltaPercent' | 'baselineMissing';
/** Returns the deterministic local-data field for one comparison metric value. */
declare function analyticsComparisonMetricField(metricField: string, valueKind: AnalyticsComparisonMetricValueKind): string;
interface AnalyticsTableViewModel {
    config: TableConfig;
    data: AnalyticsTableRow[];
    projectionId?: string;
    source?: AnalyticsTableContractSource;
    error?: string;
}
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): Observable<AnalyticsTableRow[]>;
    private toTableRows;
    private resolveTimeSeriesCategory;
    private resolveBucketCategory;
    private resolveBucketKey;
    private projectComparisonMetricValues;
    private isComparisonResponse;
    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?: {
        index?: number | null;
        size?: number | null;
    } | null;
    meta?: Record<string, unknown> | null;
};
type DataMode = 'remote' | 'local' | 'empty';
type TableConfigPersistenceStrategy = 'local-first' | 'input-first' | 'volatile';
type RowExpansionTrigger = 'icon' | 'row' | 'keyboard' | 'api' | 'restore';
type RowExpansionReasonCode = 'user' | 'policy' | 'restore' | 'api';
type RowExpansionChangeBase = {
    tableId: string;
    trigger: RowExpansionTrigger;
    reasonCode: RowExpansionReasonCode;
    expanded: boolean;
    persisted: boolean;
};
type RowExpansionChangeEvent = (RowExpansionChangeBase & {
    rowIdExposure: 'redacted';
    rowIdRef: null;
    expandedKeysExposure: 'none';
    previousExpandedKeysRef: null;
    currentExpandedKeysRef: null;
}) | (RowExpansionChangeBase & {
    rowIdExposure: 'hashed';
    rowIdHash: string;
    expandedKeysExposure: 'none';
    previousExpandedKeysRef: null;
    currentExpandedKeysRef: null;
}) | (RowExpansionChangeBase & {
    rowIdExposure: 'hashed';
    rowIdHash: string;
    expandedKeysExposure: 'hashed';
    previousExpandedKeysHash: string[] | null;
    currentExpandedKeysHash: string[] | null;
}) | (RowExpansionChangeBase & {
    rowIdExposure: 'hashed';
    rowIdHash: string;
    expandedKeysExposure: 'raw';
    previousExpandedKeys: string[] | null;
    currentExpandedKeys: string[] | null;
}) | (RowExpansionChangeBase & {
    rowIdExposure: 'raw';
    rowId: string;
    expandedKeysExposure: 'none';
    previousExpandedKeysRef: null;
    currentExpandedKeysRef: null;
}) | (RowExpansionChangeBase & {
    rowIdExposure: 'raw';
    rowId: string;
    expandedKeysExposure: 'hashed';
    previousExpandedKeysHash: string[] | null;
    currentExpandedKeysHash: string[] | null;
}) | (RowExpansionChangeBase & {
    rowIdExposure: 'raw';
    rowId: string;
    expandedKeysExposure: 'raw';
    previousExpandedKeys: string[] | null;
    currentExpandedKeys: string[] | null;
});
type RowActionRuntimeOptions = {
    payload?: any;
    actionConfig?: any;
    /** Runtime-only focus origin. It must never be persisted or sent to an API. */
    focusOrigin?: HTMLElement;
};
type RowActionTriggerEvent = {
    target?: EventTarget | null;
    currentTarget?: EventTarget | null;
    stopPropagation?: () => void;
};
type RuntimeRowAction = {
    id: string;
    action: string;
    globalAction?: GlobalActionRef;
    effects?: PraxisRuntimeGlobalActionEffect[];
    label?: string;
    icon?: string;
    color?: string;
    tooltip?: string;
    disabled?: boolean;
    overflow?: boolean;
    __praxisDiscoveredAction?: ResourceActionCatalogItem;
    __praxisDiscoveredSurface?: ResourceSurfaceCatalogItem;
    __praxisCrudOperation?: ResourceCapabilityOperation;
    __praxisCapabilityDenied?: boolean;
    __praxisDiscoveryPending?: boolean;
};
type ExpansionDetailRuntimeStatus = 'idle' | 'loading' | 'ready' | 'error' | 'blocked';
type ExpansionDetailResolvedSource = 'inline' | 'resource' | 'resourcePath' | 'hypermedia' | 'fallback';
type ExpansionDetailViewState = {
    status: ExpansionDetailRuntimeStatus;
    schema: Record<string, unknown> | null;
    message: string | null;
    source: ExpansionDetailResolvedSource | null;
};
type ExpansionDetailInlineRendererView = {
    component: Type<unknown>;
    inputs: Record<string, unknown>;
};
declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterViewChecked, AfterContentInit, OnDestroy {
    private cdr;
    private settingsPanel;
    private crudService;
    private tableDefaultsProvider;
    filterConfig: FilterConfigService;
    private formattingService;
    private pxDialog;
    private snackBar;
    private asyncConfigStorage;
    private connectionStorage;
    private hostRef;
    private global;
    private injector;
    private componentKeys;
    private loadingOrchestrator;
    private globalActions;
    private enterpriseRuntimeContext?;
    private loadingRenderer?;
    private route?;
    private logger?;
    private analyticsStatsApi?;
    activeRowOverflowMenuTrigger?: MatMenuTrigger;
    private activeRowOverflowMenuTriggerElement?;
    private openingRowActions;
    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_REQUEST_TIMEOUT_MS;
    private static readonly ROW_DISCOVERY_CACHE_LIMIT;
    private static readonly ROW_DISCOVERY_MAX_CONCURRENT_REQUESTS;
    private _resourceDiscovery?;
    private _resourceActionOpenAdapter?;
    private _resourceSurfaceOpenAdapter?;
    private _crudOperationResolver?;
    private readonly runtimeObservationRegistry;
    private readonly detailInlineRenderers;
    private collectionLinks;
    private collectionCapabilities;
    private collectionCapabilitiesRequestHref;
    private collectionCapabilitiesResolvedHref;
    private collectionCapabilitiesRequestSeq;
    private readonly detailInlineNodeResolvers;
    private readonly detailResourceResolver;
    private runtimeObservationRegistration;
    readonly paginatorSelectConfig: MatPaginatorSelectConfig;
    private static readonly ROW_ANIMATION_PRESETS;
    private static readonly ROW_ANIMATION_PRESET_ALIASES;
    config: TableConfig;
    resourcePath: string;
    data: any[] | null;
    tableId: string;
    componentInstanceId?: string;
    configPersistenceStrategy: TableConfigPersistenceStrategy;
    title: string;
    subtitle: string;
    icon: string;
    autoDelete: boolean;
    notifyIfOutdated: 'inline' | 'snackbar' | 'both' | 'none';
    snoozeMs: number;
    autoOpenSettingsOnOutdated: boolean;
    crudContext: any;
    filterCriteria: Record<string, any>;
    queryContext: PraxisDataQueryContextBridge | null;
    aiContext: TableAiContext | null;
    aiAssistantVoiceInputMode: PraxisAssistantVoiceInputMode;
    aiAssistantVoiceLanguage: string;
    advancedFilterValue: Record<string, any>;
    activeQuickFilterId: string | null;
    private quickFilterBaseCriteria;
    private activeQuickFilterCriteria;
    advancedFilterRuntimeVisibleFields: string[];
    private advancedFilterAlwaysVisibleCacheKey;
    private advancedFilterAlwaysVisibleCache?;
    private advancedFilterMetadataOverridesCacheKey;
    private advancedFilterMetadataOverridesCacheSource?;
    private advancedFilterMetadataOverridesCache?;
    rowClick: EventEmitter<any>;
    widgetEvent: EventEmitter<any>;
    resourceEvent: EventEmitter<PraxisResourceEvent<unknown>>;
    rowDoubleClick: EventEmitter<any>;
    rowExpansionChange: EventEmitter<RowExpansionChangeEvent>;
    rowAction: EventEmitter<any>;
    toolbarAction: EventEmitter<ToolbarActionEvent<any>>;
    bulkAction: EventEmitter<any>;
    exportAction: EventEmitter<any>;
    columnReorder: EventEmitter<any>;
    columnReorderAttempt: EventEmitter<any>;
    columnResize: EventEmitter<any>;
    beforeDelete: EventEmitter<any>;
    afterDelete: EventEmitter<any>;
    deleteError: EventEmitter<any>;
    beforeBulkDelete: EventEmitter<any>;
    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;
    private loadingIndicatorVisible;
    private loadingIndicatorDelayHandle;
    paginator: MatPaginator;
    sort: MatSort;
    materialTable?: MatTable<any>;
    virtualScrollViewport?: CdkVirtualScrollViewport;
    scrollViewport?: ElementRef<HTMLElement>;
    internalFilter?: PraxisFilter;
    toolbar: PraxisTableToolbar;
    projectedFilter: any;
    toolbarV2: boolean;
    dataSource: MatTableDataSource<any, MatPaginator>;
    selection: SelectionModel<any>;
    dataSubject: BehaviorSubject<any[]>;
    subscriptions: Subscription[];
    showToolbar: boolean;
    hasInitialized: boolean;
    pageIndex: number;
    pageSize: number;
    private remotePaginationTotal;
    sortState: Sort;
    visibleColumns: ColumnDefinition[];
    visibleDataColumnsForDrag: ColumnDefinition[];
    displayedColumns: string[];
    readonly expansionDetailRowColumns: string[];
    readonly isExpansionDetailRow: (index: number, row: any) => boolean;
    columnReorderStatusMessage: string;
    columnReorderVisualStatusMessage: string;
    columnResizeStatusMessage: string;
    selectionStatusMessage: string;
    exportBusy: boolean;
    exportStatusMessage: string;
    hasHorizontalOverflow: boolean;
    canScrollHorizontallyLeft: boolean;
    canScrollHorizontallyRight: boolean;
    private columnReorderStatusTimer;
    private columnReorderVisualStatusTimer;
    private columnResizeStatusTimer;
    private selectionStatusTimer;
    private keyboardFocusedRowIdentity;
    private pendingKeyboardFocusIdentity;
    private columnReorderUndoSubscription;
    private columnRuntimeMutationOperationCounter;
    private latestColumnRuntimeMutationOperationId;
    private columnRuntimePersistenceInFlight;
    private columnRuntimePersistencePending;
    private columnResizeTransientWidths;
    private columnResizeTableWidthStyle;
    private columnResizeLayoutSignature;
    private isApplyingColumnResizeLayoutMutation;
    private activeColumnResize;
    private readonly columnResizePointerMoveListener;
    private readonly columnResizePointerUpListener;
    private readonly columnResizePointerCancelListener;
    private readonly columnResizeKeydownListener;
    localSource: any[];
    localView: any[];
    localTotal: number;
    private localPageSizeRuntimeOverride;
    private lastResolvedDataMode;
    private localFilterFieldMetadataCache;
    private localFilterFieldMetadataCacheKey;
    private remoteSchemaLoadSequence;
    private remoteDataLoadSequence;
    private analyticsLoadSequence;
    private activeRemoteSchemaLoadSubscription;
    private activeRemoteDataLoadSubscription;
    private activeAnalyticsLoadSubscription;
    private cancelledOperationalLoadPhase;
    private operationalLoadFailureKind;
    private uncontrolledExpandedRowKeys;
    private readonly expansionOpaqueRefCacheLimit;
    private expansionOpaqueRefByRowKey;
    private expansionDetailSchemaByRowKey;
    private expansionDetailStatusByRowKey;
    private expansionDetailMessageByRowKey;
    private expansionDetailSourceByRowKey;
    private expansionDetailAbortByRowKey;
    private expansionDetailActiveTabByRowKey;
    private rowCapabilitySnapshotByHref;
    private rowCapabilityCachedAtByHref;
    private rowCapabilityErrorHrefs;
    private rowCapabilityErrorCachedAtByHref;
    private rowCapabilityInFlightByHref;
    private rowActionCatalogByHref;
    private rowActionCachedAtByHref;
    private rowActionErrorHrefs;
    private rowActionErrorCachedAtByHref;
    private rowActionInFlightByHref;
    private rowDiscoveryMetricsByRel;
    private rowContextRuntimeByRef;
    private rowDiscoveryQueue;
    private rowDiscoveryActiveRequests;
    private rowDiscoveryEpoch;
    private rowDiscoveryMarkForCheckScheduled;
    private lastRowDiscoveryScopeKey;
    private readonly i18n;
    private readonly sanitizer;
    private readonly collectionExport;
    private readonly paginatorIntl;
    private readonly schemaNormalizer;
    private schemaFieldsSnapshot;
    private schemaColumnFieldsSnapshot;
    private filterSchemaFieldsSnapshot;
    private runtimeSchemaMeta;
    schemaError: boolean;
    dataError: boolean;
    errorMessage: string | null;
    idField: string;
    horizontalScroll: 'auto' | 'wrap' | 'none';
    private horizontalScrollOverrideSource;
    getToolbarPosition(): 'top' | 'bottom' | 'both';
    shouldShowToolbarTopPlacement(): boolean;
    shouldShowToolbarBottomPlacement(): boolean;
    shouldRenderFooterToolbar(): boolean;
    hasTopToolbarStack(): boolean;
    hasBottomTableStack(): boolean;
    shouldShowFooterToolbarMain(): boolean;
    shouldShowFooterToolbarEndActions(): boolean;
    getToolbarActionsPosition(): 'top' | 'bottom' | 'both';
    getBulkActionsPosition(): 'toolbar' | 'floating' | 'both';
    shouldRenderFloatingBulkActions(): boolean;
    getFloatingBulkActions(): any[];
    shouldHideFloatingBulkActions(): boolean;
    getFloatingBulkPositionClass(): string;
    isFloatingBulkActionDisabled(action: any): boolean;
    getFloatingBulkActionRichContentNodes(action: any): RichBlockNode[];
    shouldShowToolbarActionsTop(): boolean;
    shouldShowToolbarActionsBottom(): boolean;
    getToolbarActionsBackgroundColor(): string | null;
    private hasToolbarUtilityActions;
    getToolbarLayoutHeightPx(): number | null;
    getToolbarLayoutHeightCssVar(): string | null;
    getToolbarLayoutHeightHostStyle(): string | null;
    getRowActionsWidthStyle(): string | null;
    protected isStickyStartBoundary(column: ColumnDefinition): boolean;
    protected isStickyEndBoundary(column: ColumnDefinition): boolean;
    protected isActionsStickyStartBoundary(): boolean;
    protected isActionsStickyEndBoundary(): boolean;
    getColumnTextAlignStyle(column: ColumnDefinition): string | null;
    getColumnWidthStyle(column: ColumnDefinition): string | null;
    getColumnResizeTableWidthStyle(): string | null;
    getColumnHeaderAttrStyle(column: ColumnDefinition): string | null;
    getColumnHeaderNgStyle(column: ColumnDefinition): Record<string, string> | undefined;
    getColumnCellAttrStyle(column: ColumnDefinition): string | null;
    private mergeColumnWidthIntoInlineStyle;
    private buildColumnWidthInlineStyle;
    getTableElevationClassName(): string;
    private normalizeTableElevationLevel;
    private resolveRuntimeTableElevationLevel;
    private resolveTableShadowColor;
    private buildTableElevationShadow;
    private syncHorizontalScrollFromAppearanceConfig;
    private resolveResponsiveMobileBreakpoint;
    private shouldApplyResponsiveHorizontalScrollGlobally;
    private isWithinResponsiveMobileBreakpoint;
    private refreshResponsiveHorizontalScroll;
    onHorizontalViewportScroll(event: Event): void;
    onHorizontalViewportKeydown(event: KeyboardEvent): void;
    private refreshHorizontalOverflowState;
    private scheduleHorizontalOverflowRefresh;
    /**
     * Materializes the existing responsive contract as a labelled record card on
     * narrow screens or widget containers. Virtual rows keep the scroll-table path:
     * their fixed item height cannot safely represent a variable-height card.
     */
    isMobileCardModeActive(): boolean;
    private isWithinResponsiveCardBreakpoint;
    getMobileCardColumnOrder(column: ColumnDefinition): number;
    getMobileCardActionsOrder(): number;
    private scheduleResponsiveHorizontalScrollRefresh;
    private cancelResponsiveHorizontalScrollRefresh;
    hasBottomPaginator(): boolean;
    hasExplicitResourcePath(): boolean;
    hasLocalDataInput(): boolean;
    hasAnalyticsProjectionInput(): boolean;
    getDataMode(): DataMode;
    isRemoteMode(): boolean;
    isLocalMode(): boolean;
    isEmptyMode(): boolean;
    isLocalDataModeFeatureEnabled(): boolean;
    isLocalDataModeActive(): boolean;
    shouldRenderDataSurface(): boolean;
    shouldShowEmptyState(): boolean;
    shouldShowNoDataState(): boolean;
    shouldShowLoadingSurface(): boolean;
    shouldShowRefreshingState(): boolean;
    shouldReplaceDataWithLoading(): boolean;
    getLoadingIndicatorType(): 'spinner' | 'skeleton' | 'progress';
    getLoadingIndicatorPosition(): 'overlay' | 'inline' | 'replace';
    getLoadingSurfaceMessage(): string;
    getLoadingSkeletonRows(): number[];
    isLoadingSkeletonAnimated(): boolean;
    getNoDataStateTitle(): string;
    getNoDataStateDescription(): string | undefined;
    getTableSettingsLabel(): string;
    getScrollViewportAriaLabel(): string;
    getTableAriaLabel(): string;
    getTableErrorTitle(): string;
    getTableErrorMessage(): string;
    getTableErrorRetryLabel(): string;
    getTableSelectResourceLabel(): string;
    isErrorRetryInProgress(): boolean;
    canCancelLoad(): boolean;
    cancelLoad(): void;
    shouldShowCancelledState(): boolean;
    getCancelledLoadTitle(): string;
    getCancelledLoadMessage(): string;
    getCancelLoadLabel(): string;
    retryCancelledLoad(): void;
    getTableSettingsTooltip(): string;
    getDisconnectLabel(): string;
    getDisconnectTooltip(): string;
    private syncPaginatorIntl;
    private configuredLocaleRuntimeText;
    private formatPaginatorRangeLabel;
    getNoDataStateIcon(): string;
    getNoDataStateTone(): 'neutral' | 'primary' | 'secondary';
    getNoDataStateVariant(): 'card' | 'inline' | 'panel' | 'transparent';
    getNoDataStateAlignment(): 'start' | 'center';
    getNoDataStateDensity(): 'compact' | 'comfortable';
    getNoDataStateActionSize(): string;
    getNoDataStateActionRadius(): string;
    getNoDataStateIconContainer(): 'none' | 'circle' | 'soft';
    getNoDataStatePrimaryAction(): any | null;
    getNoDataStateSecondaryActions(): any[];
    shouldRenderAdvancedFilter(): boolean;
    getAdvancedFilterResourcePath(): string;
    getAdvancedFilterPersistenceKey(): string;
    getAdvancedFilterFormId(): string;
    getAdvancedFilterOpenMode(): 'modal' | 'drawer';
    getAdvancedFilterAlwaysVisibleFields(): string[] | undefined;
    getAdvancedFilterAlwaysVisibleFieldMetadataOverrides(): Record<string, Record<string, any>>;
    getAdvancedFilterFieldMetadata(): FieldMetadata[] | null | undefined;
    private buildLocalFilterMetadata;
    private buildLocalFilterMetadataCacheKey;
    private resolveLocalFilterDataType;
    private resolveLocalFilterControlType;
    private schemaState;
    schemaOutdated: boolean;
    enableCustomization: boolean;
    /** Capability publica exigida para materializar configuracao governada. */
    authoringCapability: string | null;
    private activeTableSettingsRef;
    private _resolvedPrefs;
    set resolvedPrefs(val: any);
    get resolvedPrefs(): any;
    dense: boolean;
    private hostDeclaredAppearanceDensity;
    private hostDeclaredAppearanceSpacing;
    private hostDeclaredAppearanceTypography;
    resolveAppearanceDensity(): 'compact' | 'comfortable' | 'spacious';
    get hostDensityCompactClass(): boolean;
    get hostDensityComfortableClass(): boolean;
    get hostDensitySpaciousClass(): boolean;
    get hostRowBordersClass(): boolean;
    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 buildAiAssistantSelectedRowsContext;
    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 agenticTurnClient;
    private readonly assistantSessions;
    private readonly aiTurnOrchestrator;
    private readonly aiAssistantSessionEffect;
    private computedContextCache;
    private computedFieldNames;
    private readonly jsonLogic;
    private computedExpressionEvaluator;
    private resizeObserver;
    private resizeObserverRefreshFrameId;
    private horizontalOverflowRefreshFrameId;
    private removeViewportChangeListeners;
    private conditionalSurfaceObserver;
    private conditionalSurfaceFrameId;
    private readonly warnedUnsupportedFeatures;
    private readonly activeCollectionCreateSurfaceOpens;
    private warnedStrictCspStyleMode;
    private fallbackLogger?;
    private fallbackLoggerEnvironment;
    private lastColumnDropHandledAt;
    private surfaceOpenAttemptSequence;
    private activeColumnDragField;
    private readonly _effectiveCellRenderCache;
    private readonly cellAnimationPreviousValuesByRowId;
    private readonly cellAnimationPreviousValuesByRowRef;
    private readonly cellAnimationPreviousRowIdOrder;
    private readonly progressRichContentContextByRowRef;
    private getLogger;
    private buildLogOptions;
    private debugLog;
    private debugLogWithMeta;
    private warnLog;
    private infoLog;
    private warnOnceLog;
    private errorLog;
    private logResolvedDataMode;
    private clearModeErrors;
    private resetRuntimeStateForModeTransition;
    private clearRenderedRowsForModeTransition;
    private applyDataModeTransition;
    private reconcileDataModeTransition;
    private clearLocalScaffolding;
    private syncPaginationTotal;
    private refreshLocalScaffolding;
    private syncLocalPageSizeFromConfig;
    private recomputeLocalView;
    private resolveLocalSortField;
    private setSchemaFieldsSnapshot;
    private setFilterSchemaFieldsSnapshot;
    private inferFilterSchemaSourceFields;
    private resolveFilterSchemaRelatedColumns;
    private normalizeFieldAlias;
    private normalizeSchemaOptions;
    private normalizeEnumValues;
    private normalizeSchemaKey;
    private clearSchemaFieldsSnapshot;
    private componentKeyId;
    private storageKey;
    private isVolatileConfigPersistence;
    private tableConfigKey;
    private filterConfigKey;
    private ensureConfigDefaults;
    private hasDeclaredAppearanceDensity;
    private hasDeclaredAppearanceSection;
    private shouldApplyAppearanceDefaultValue;
    private mergePersistedTableConfigWithInput;
    private reconcileHostDeclaredTableContract;
    private reconcileHostDeclaredColumns;
    private reconcileHostDeclaredRowActions;
    private reconcileHostDeclaredExport;
    private normalizePersistedExportFormats;
    private normalizePersistedRowActionIds;
    private normalizePersistedColumnIds;
    private columnIdentitySetChanged;
    private clonePlainObject;
    private setShowToolbar;
    private shouldExposeToolbar;
    private resolveCollectionDiscoveryOptions;
    private updateCollectionLinks;
    private resolveCollectionCapabilitiesHref;
    private materializeCollectionCreateToolbarAction;
    private materializeCollectionWorkflowToolbarActions;
    private isCollectionActionDiscoveryEnabled;
    private ensureToolbarConfigForRuntime;
    private buildCollectionCreateToolbarAction;
    private resolveCollectionCreateRuntime;
    private resolveCollectionResourcePath;
    private hasCollectionCreateLink;
    private resolveCollectionCreateCapabilityOperation;
    private createSyntheticCollectionCrudOperation;
    private resolveCollectionCreateSurface;
    private isWritableCrudSurface;
    private isCollectionCreateSurface;
    private getCollectionCreateActionLabel;
    private getCollectionCreateActionTooltip;
    private getCollectionCreateUnavailableTooltip;
    private resolveCollectionCreateDisabled;
    private isCreateToolbarAction;
    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, enterpriseRuntimeContext?: EnterpriseRuntimeContextService | undefined, loadingRenderer?: PraxisLoadingRenderer | undefined, route?: ActivatedRoute | undefined, logger?: LoggerService | undefined, analyticsStatsApi?: AnalyticsTableStatsApiService | undefined);
    private get resourceDiscovery();
    private get resourceSurfaceOpenAdapter();
    private get resourceActionOpenAdapter();
    private get crudOperationResolver();
    private ensureAiAdapterLoaded;
    openAiAssistant(): void;
    aiAssistantTriggerTestId(position: string): string;
    hasMinimizedAiAssistantSession(): boolean;
    aiAssistantTriggerIcon(): string;
    aiAssistantTriggerBadge(): string;
    aiAssistantTriggerLabel(): string;
    aiAssistantTriggerTooltip(): string;
    isAiAssistantEnabled(): boolean;
    shouldShowAiAssistantEntrypoint(): boolean;
    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;
    private mergeAiAssistantQuickReplyContextHints;
    private resolveAiAssistantVisualPresentationQuickReplyPrompt;
    private resolveAiAssistantVisualPresentationQuickReplyContextHints;
    private resolveAiAssistantVisualPresentationRenderer;
    private resolveAiAssistantVisualPresentationTargetField;
    private aiAssistantVisualPresentationTargetScore;
    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;
    buildRuntimeComponentObservation(): PraxisRuntimeComponentObservationEnvelope;
    private registerRuntimeComponentObservationProvider;
    private resolveRuntimeThemeMode;
    private getRuntimeObservationSelectedRecordsContext;
    private getActiveRuntimeObservationSelectedRows;
    private buildRuntimeObservationSelectionDigest;
    private buildRuntimeObservationStateDigest;
    private buildRuntimeObservationRendererStateDigest;
    private buildRuntimeObservationDataProfileDigest;
    private getRuntimeObservationSchemaFieldRefs;
    private getRuntimeObservationSchemaFieldDescriptors;
    private getRuntimeObservationSurfaceRefs;
    private getRuntimeObservationActionRefs;
    private buildRuntimeObservationClaims;
    private isRuntimeObservationVisible;
    private syncAiAssistantSession;
    private disableAiAssistantSession;
    private assistantContextRuntimeLocale;
    private refreshAiAssistantContextAfterSelectionChange;
    private hasAiAssistantSessionState;
    private resolveAiAssistantSessionId;
    private resolveAiAssistantOwnerId;
    private runtimeSurfaceInstanceRef;
    private safeRuntimeSurfaceRefSegment;
    private resolveAiAssistantRouteKey;
    private resolveAiAssistantSummary;
    private resolveAiAssistantBadge;
    private resolveAiAssistantIcon;
    private emitLoadingState;
    private shouldExposeLoadingIndicator;
    private updateLoadingIndicatorVisibility;
    private hasResolvedRemoteDataLoad;
    isTableDataLoading(): boolean;
    private hasActiveOperationalLoad;
    private getRenderedRowCount;
    private hasActiveDataFilters;
    private hasActiveEmptyStateFilters;
    private hasMeaningfulFilterCriteria;
    private hasMeaningfulFilterValue;
    private resolveNoDataStateConfig;
    private isEmptyStateTone;
    private isEmptyStateVariant;
    private mapEmptyStateAction;
    private resolveMatchingEmptyStateToolbarAction;
    private onEmptyStateAction;
    private buildLoadingContext;
    private beginLoading;
    private endLoading;
    openQuickConnect(): void;
    ngOnInit(): Promise<void>;
    ngAfterContentInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Angular delivers the initial resource, config and query inputs before
     * ngAfterContentInit. That lifecycle hook owns the first remote load after
     * pagination defaults have been applied. Fetching here for a first change
     * would issue a second request with the constructor page size and create a
     * race with the configured request.
     */
    private shouldFetchRemoteDataForQueryChanges;
    private isDebug;
    private connectionKey;
    private saveConnection;
    private inputsKey;
    disconnect(): void;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    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;
    isRowExpanded(row: any, index?: number): boolean;
    shouldRenderExpansionDetailRow(row: any, index?: number): boolean;
    getRowExpansionDetailId(row: any, index?: number): string;
    getRowExpansionToggleAriaLabel(row: any, index?: number): string;
    getExpansionCollapsedIcon(): string;
    getExpansionExpandedIcon(): string;
    getExpansionMotionPresetClass(): string;
    getExpansionMotionStyle(): Record<string, string>;
    getRowExpansionRegionAriaLabel(row: any, index?: number): string;
    getExpansionDetailViewState(row: any, index?: number): ExpansionDetailViewState;
    getExpansionDetailItems(schema: Record<string, unknown> | null): any[];
    getExpansionDetailLayout(schema: Record<string, unknown> | null): 'stack' | 'tabs';
    getExpansionDetailTabs(schema: Record<string, unknown> | null): any[];
    getExpansionDetailNodeType(node: any): string;
    getExpansionDetailNodeTitle(node: any, fallback?: string): string;
    getExpansionDetailNodeChildren(node: any): any[];
    getExpansionDetailValue(row: any, node: any): string;
    getExpansionDetailListEntries(row: any, node: any): unknown[];
    getExpansionDetailListItems(row: any, node: any): string[];
    getExpansionDetailRichListEntries(row: any, node: TableDetailRichListNode | any): unknown[];
    getExpansionDetailRichListEmptyText(node: TableDetailRichListNode | any): string;
    getExpansionDetailRichListItemNodes(node: TableDetailRichListNode | any): RichBlockNode[];
    getExpansionDetailCardGridHeaderNodes(node: TableDetailCardGridNode | any): RichBlockNode[];
    getExpansionDetailCardGridCards(node: TableDetailCardGridNode | any): TableDetailCardGridCardNode[];
    getExpansionDetailCardGridStyles(node: TableDetailCardGridNode | any): Record<string, string>;
    getExpansionDetailCardGridCardNodes(card: TableDetailCardGridCardNode | any): RichBlockNode[];
    getExpansionDetailTimelineEntries(row: any, node: TableDetailTimelineNode | any): unknown[];
    getExpansionDetailTimelineEmptyText(node: TableDetailTimelineNode | any): string;
    getExpansionDetailTimelineNodes(row: any, node: TableDetailTimelineNode | any): RichBlockNode[];
    getExpansionDetailRichListItemContext(row: any, rowIndex: number, node: TableDetailRichListNode | any, entry: unknown, itemIndex: number): JsonLogicDataRecord;
    getExpansionDetailRichListItemClassName(node: TableDetailRichListNode | any): string;
    getExpansionDetailRichListItemKey(node: TableDetailRichListNode | any, entry: unknown, itemIndex: number): string;
    getExpansionDetailRichListItemActions(node: TableDetailRichListNode | any, row: any, rowIndex: number, entry: unknown, itemIndex: number): TableDetailListItemAction[];
    private normalizeExpansionDetailCardGridColumns;
    private normalizeExpansionDetailCardGridMinWidth;
    private getExpansionDetailTimelineFieldName;
    private buildExpansionDetailTimelineRichNode;
    private mapExpansionDetailTimelineItem;
    private resolveExpansionDetailTimelineObjectValue;
    private resolveExpansionDetailTimelineExpressionValue;
    private getExpansionDetailTimelineObjectValue;
    private normalizeExpansionDetailCardGridCardContent;
    private normalizeExpansionDetailMediaBlockAvatar;
    private normalizeExpansionDetailMediaBlockText;
    private normalizeExpansionDetailMediaBlockMeta;
    private normalizeExpansionDetailMediaBlockTrailing;
    private normalizeExpansionDetailComposeItems;
    private isExpansionDetailCardGridContentNode;
    private isExpansionDetailComposeItemNode;
    getExpansionDetailRichListItemActionNodes(action: TableDetailListItemAction | any): RichBlockNode[];
    isExpansionDetailRichListItemActionDisabled(action: TableDetailListItemAction | any, row: any, rowIndex: number, node: TableDetailRichListNode | any, entry: unknown, itemIndex: number): boolean;
    onExpansionDetailRichListItemAction(action: TableDetailListItemAction | any, row: any, rowIndex: number, node: TableDetailRichListNode | any, entry: unknown, itemIndex: number, event: Event): void;
    getExpansionDetailListItemRichContentNodes(entry: unknown): RichBlockNode[] | null;
    getExpansionDetailActionId(node: any): string;
    getExpansionDetailActionLabel(node: any): string;
    getExpansionDetailActionStatusText(node: any): string | null;
    getExpansionDetailActionBarTitle(node: TableDetailActionBarNode | any): string;
    getExpansionDetailActionBarActions(node: TableDetailActionBarNode | any, row: any, index: number): TableDetailActionBarAction[];
    getExpansionDetailActionBarActionNodes(action: TableDetailActionBarAction | any): RichBlockNode[];
    isExpansionDetailActionBarActionDisabled(action: TableDetailActionBarAction | any, row: any, index: number): boolean;
    getExpansionDetailActionBarEmptyText(node: TableDetailActionBarNode | any): string;
    onExpansionDetailActionBarAction(action: TableDetailActionBarAction | any, row: any, index: number, event: Event): void;
    getExpansionDetailEmbedHeaderNodes(node: TableDetailRefNode | TableDetailTemplateRefNode | TableDetailDiagramEmbedNode | any): RichBlockNode[];
    getExpansionDetailEmbedMetaNodes(node: TableDetailRefNode | TableDetailTemplateRefNode | TableDetailDiagramEmbedNode | any): RichBlockNode[];
    getExpansionDetailEmbedActionNodes(action: TableDetailEmbedAction | any): RichBlockNode[];
    getExpansionDetailInlineRendererView(node: TableDetailRefNode | any, row: any, index: number): ExpansionDetailInlineRendererView | null;
    private resolveExpansionDetailInlineRenderer;
    private resolveExpansionDetailInlineNode;
    getExpansionDetailEmbedAction(node: TableDetailRefNode | TableDetailTemplateRefNode | TableDetailDiagramEmbedNode | any, row: any, index: number): TableDetailEmbedAction | null;
    isExpansionDetailEmbedActionDisabled(action: TableDetailEmbedAction | any, row: any, index: number): boolean;
    getExpansionDetailEmbedEmptyText(node: TableDetailRefNode | TableDetailTemplateRefNode | TableDetailDiagramEmbedNode | any): string;
    getExpansionDetailDiagramSource(row: any, node: TableDetailDiagramEmbedNode | any): string | null;
    getExpansionDetailDiagramSourceLabel(): string;
    onExpansionDetailEmbedAction(action: TableDetailEmbedAction | any, row: any, index: number, event: Event): void;
    private isExpansionDetailEmbedActionVisible;
    private getExpansionDetailEmbedLabel;
    private getExpansionDetailEmbedReference;
    private getExpansionDetailDiagramProvider;
    private getExpansionDetailEmbedPresetLabel;
    private getExpansionDetailEmbedInputsSummary;
    getExpansionDetailTextRichContentNodes(text: string | null | undefined, className?: string): RichBlockNode[];
    getTableChromeTextRichContentNodes(text: string | null | undefined, className?: string): RichBlockNode[];
    getRowActionRichContentNodes(action: any, busy?: boolean): RichBlockNode[];
    getRowActionIconRichContentNodes(action: any): RichBlockNode[];
    getExpansionDetailActionRichContentNodes(node: any): RichBlockNode[];
    private isExpansionDetailActionBarActionVisible;
    getExpansionDetailTabButtonRichContentNodes(tab: any): RichBlockNode[];
    private getExpansionDetailTabBadgeLabel;
    isExpansionDetailActionDisabled(node: any): boolean;
    onExpansionDetailAction(node: any, row: any, event: Event): void;
    formatExpansionDetailListEntry(entry: unknown): string;
    private getExpansionDetailObjectListLabel;
    private getExpansionDetailObjectListBadgeLabel;
    private evaluateExpansionDetailRichListItemPayload;
    private isExpansionDetailRichListItemActionVisible;
    private evaluateExpansionDetailRichListItemCondition;
    getExpansionDetailRichText(node: any): string;
    getExpansionDetailRichContentContext(row: any, index: number): JsonLogicDataRecord;
    getExpansionDetailRichContentNodes(node: any, row: any, index: number): RichBlockNode[] | null;
    getExpansionDetailTabRichContentNodes(tab: any, row: any, index: number): RichBlockNode[] | null;
    private mapExpansionDetailNodeToRichContent;
    private mapExpansionDetailMediaBlockNodeToRichContent;
    private mapExpansionDetailCardNodeToRichContent;
    private mapExpansionDetailStackNodeToRichContent;
    private mapExpansionDetailValueNodeToRichContent;
    private mapExpansionDetailTimelineNodeToRichContent;
    getExpansionDetailTabId(row: any, index: number, tab: any, tabIndex: number): string;
    getExpansionDetailPanelId(row: any, index: number, tab: any, tabIndex: number): string;
    getExpansionDetailTabToken(tab: any, tabIndex: number): string;
    isExpansionDetailTabActive(row: any, index: number, tab: any, tabIndex: number, tabs: any[]): boolean;
    onExpansionDetailTabSelect(row: any, index: number, tab: any, tabIndex: number, event?: Event): void;
    onExpansionDetailTabKeydown(event: KeyboardEvent, row: any, index: number, tabIndex: number, tabs: any[]): void;
    onExpansionToggleFromIcon(row: any, index: number, event: MouseEvent): void;
    onExpansionToggleKeydown(event: KeyboardEvent, row: any, index: number): void;
    private getExpansionConfig;
    private ensureExpansionDetailPrepared;
    private resolveExpansionDetailSchemaForRow;
    private resolveExpansionDetailByMode;
    private resolveExpansionDetailInlineSchema;
    private resolveExpansionDetailFromResource;
    private resolveExpansionDetailFromResourcePath;
    private resolveExpansionDetailFromHypermedia;
    private normalizeExpansionDetailSchemaCandidate;
    private sanitizeExpansionDetailSchema;
    private sanitizeExpansionDetailNodes;
    private sanitizeExpansionDetailNode;
    private sanitizeExpansionDetailMediaBlockNode;
    private sanitizeExpansionDetailCardGridCards;
    private getExpansionDetailCardGridContentTypes;
    private getExpansionDetailComposeItemTypes;
    private buildExpansionBlockedPlaceholderNode;
    private interpolateExpansionResourcePath;
    private isExpansionResourcePathAllowed;
    private normalizeResolvedExpansionResourcePath;
    private isAbsoluteExpansionResourcePath;
    private normalizeExpansionResourceAllowListPattern;
    private wildcardToRegExp;
    private resolveExpansionContextValue;
    private buildExpansionContextRecord;
    private getExpansionFallbackMode;
    private loadExpansionHypermediaSnapshot;
    private buildExpansionHypermediaDetailSchema;
    private selectExpansionHypermediaPrimarySurface;
    private buildExpansionHypermediaOperationItems;
    private buildExpansionHypermediaWorkflowActionItems;
    private getExpansionHypermediaMessage;
    private describeExpansionHypermediaSurface;
    private getExpansionFallbackNodePolicy;
    private getExpansionAllowedNodesSet;
    private validateExpansionDetailRendererContract;
    private setExpansionDetailRuntimeState;
    private clearExpansionDetailRuntimeForRowKey;
    private clearExpansionDetailRuntime;
    private cancelExpansionDetailLoad;
    private syncExpansionDetailRuntimeAfterStateChange;
    private shouldKeepExpansionDetailCacheOnCollapse;
    private shouldCancelExpansionDetailLoadOnCollapse;
    private renderExpansionRows;
    private logExpansionDiagnostic;
    private isExpansionControlledMode;
    private getCurrentExpandedRowKeys;
    private toggleRowExpansion;
    private resolveRowExpansionKey;
    private computeNextExpansionState;
    private getExpansionAllowMultiple;
    private getExpansionMaxExpandedRows;
    private getExpansionOverflowPolicy;
    private emitRowExpansionStateDiffEvents;
    private shouldEmitExpansionChangeEvents;
    private createRowExpansionEvent;
    private hashExpansionKey;
    private enforceExpansionOpaqueRefCacheLimit;
    private generateExpansionOpaqueRefToken;
    private getRuntimeCrypto;
    private escapeRegExp;
    private sanitizeDomIdToken;
    private areStringSetsEqual;
    private shouldToggleExpansionOnRowClick;
    private shouldSelectRowOnRowClick;
    private getExpansionMotionPreset;
    private getExpansionMotionDurationMs;
    private getExpansionMotionEasingCurve;
    private isInteractiveRowTarget;
    private restoreFocusToToggle;
    private collapseExpandedRowsByPolicy;
    private applyExpansionCollapsePolicy;
    onRowDoubleClicked(row: any, index: number): void;
    onRowAction(action: string, row: any, event: RowActionTriggerEvent, runtimeOptions?: RowActionRuntimeOptions): void;
    onOverflowRowAction(action: string, row: any, event: RowActionTriggerEvent, runtimeOptions?: RowActionRuntimeOptions): void;
    setActiveRowOverflowMenuTrigger(trigger: MatMenuTrigger, origin?: unknown): void;
    private resolveRowActionRuntimeOptions;
    private emitRowActionEvent;
    private showConfirmDialog;
    isRowActionOpening(action: string | RuntimeRowAction, row: any): boolean;
    private dispatchRowActionWithOpening;
    private getOpeningRowActions;
    private executeDeleteAction;
    private dispatchRowAction;
    private openDiscoveredRowView;
    private groundRowActionConfigForDispatch;
    private getUnavailableGroundedRowActionMessage;
    private isResourceActionCatalogItem;
    private openResourceWorkflowAction;
    private applyWorkflowActionRefresh;
    private cloneForEmit;
    private interpolateActionMessageTemplate;
    private buildActionFeedbackContext;
    private resolveActionFeedbackMessage;
    private showActionFeedbackMessage;
    private emitEventWithActionFeedback;
    private executeConfiguredGlobalAction;
    private withTableRuntimeContext;
    private executeSurfaceOpen;
    private resolveConfiguredGlobalActionRef;
    private resolveActionGlobalActionRef;
    private resolveGlobalActionPayload;
    private buildGlobalActionTemplateContext;
    private resolveGlobalActionTemplateValue;
    private isDeferredTemplateExpressionKey;
    private interpolateGlobalActionTemplate;
    private shouldEmitLocalForGlobalAction;
    private resolveBulkValidationMessage;
    private hasValidBulkSelectionCount;
    private showBulkConfirmDialog;
    onToolbarAction(event: Pick<ToolbarActionEvent<any>, 'action' | 'actionConfig' | 'focusOrigin'>): Promise<void>;
    getFocusRestoreScope(placement: 'header' | 'footer' | 'row'): string;
    getRowActionFocusOriginKey(row: any): string;
    private hasValidToolbarTargetSelection;
    private tryHandleCollectionWorkflowToolbarAction;
    private openCollectionWorkflowAction;
    private bindWorkflowSurfaceOutcome;
    private handleWorkflowSurfaceFailure;
    private applyCollectionWorkflowOutcome;
    private unwrapCollectionWorkflowResult;
    private showCollectionWorkflowContractError;
    private tryHandleCollectionCreateToolbarAction;
    private resolveBulkExportFormat;
    private isBulkExportActionKey;
    private normalizeExportFormat;
    private isExportFormatEnabled;
    private getFirstEnabledExportFormat;
    onExportAction(event: {
        format: string;
        scope?: PraxisExportScope;
        localOnly?: boolean;
    }): Promise<void>;
    canRunExportAction(format: unknown): boolean;
    private shouldBlockSelectedExportWithoutSelection;
    private buildTableExportRequest;
    private buildVisibleExcelExportRequest;
    private resolveVisibleExcelExportFileName;
    private formatExportDate;
    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;
    onQuickFilterChange(event: {
        id: string;
        filter: Record<string, unknown>;
        active: boolean;
    }): void;
    private clearQuickFilterRuntimeState;
    private hasEquivalentFilterCriteria;
    private applyAdvancedFilterCriteria;
    private setAdvancedFilterCriteria;
    private syncAdvancedFilterValueFromCriteria;
    private deriveRuntimeVisibleAdvancedFilterFields;
    private isEmptyAdvancedFilterCriterionValue;
    private mergeAdvancedFilterFieldIds;
    private getRuntimePromotedAdvancedFilterFields;
    private toPlainRecord;
    private saveConfigWithAck;
    private clearConfigWithAck;
    private persistHorizontalScrollInput;
    private showPersistenceFailureFeedback;
    private showResetSuccessFeedback;
    readonly toolbarColumnVisibilityController: (field: string, visible: boolean) => void;
    toggleColumnVisibility(field: string, visible: boolean): void;
    onDensityChange(density: TableToolbarAppearanceDensity): void;
    isCustomizationAvailable(): boolean;
    private isAuthoringAssistantAvailable;
    openTableSettings(): void;
    private applyTableConfig;
    private buildTableEditorRuntimeContext;
    private emitWidgetInputPatch;
    private cloneInputPatch;
    private executeTableEditorApplyPlan;
    private attachRuntimeMetadataToEditorConfig;
    private syncInternalFilterSettings;
    private resetPreferencesToDefaults;
    onResetPreferences(): void;
    private resolvePagingStrategy;
    private resolveSortingStrategy;
    private applyDataSourceSettings;
    private sanitizeColumns;
    private applyRendererPresentationDefaults;
    private setupColumns;
    private preserveSchemaDrivenColumnsIfConfigOmittedColumns;
    private isDataColumnField;
    private computeVisibleDataColumnsForDrag;
    getVisibleDataColumnsForDrag(): ColumnDefinition[];
    isColumnDraggingEnabled(): boolean;
    isColumnDragIndicatorEnabled(): boolean;
    isColumnDraggable(column: ColumnDefinition | null | undefined): boolean;
    isColumnResizeEnabled(): boolean;
    isColumnResizable(column: ColumnDefinition | null | undefined): boolean;
    isColumnResizeActive(column?: ColumnDefinition | null): boolean;
    getColumnResizeHandleAriaLabel(column: ColumnDefinition): string;
    getColumnResizeHandleTooltip(column: ColumnDefinition): string;
    isColumnAutoFitEnabled(): boolean;
    getColumnResizeMinWidthAriaValue(column: ColumnDefinition): number;
    getColumnResizeMaxWidthAriaValue(column: ColumnDefinition): number | null;
    getColumnResizeCurrentWidthAriaValue(column: ColumnDefinition): number | null;
    onColumnResizeHandleClick(event: MouseEvent): void;
    onColumnResizeHandleDoubleClick(event: MouseEvent, column: ColumnDefinition): void;
    onColumnResizeHandleKeydown(event: KeyboardEvent, column: ColumnDefinition): void;
    onColumnResizePointerDown(event: PointerEvent, column: ColumnDefinition): void;
    onColumnResizeLostPointerCapture(event: PointerEvent): void;
    private onColumnResizePointerMove;
    private onColumnResizePointerUp;
    private onColumnResizePointerCancel;
    private onColumnResizeDocumentKeydown;
    private addColumnResizeDocumentListeners;
    private removeColumnResizeDocumentListeners;
    private cancelColumnResize;
    private commitColumnResize;
    private applyColumnResizeWidth;
    private emitAndPersistColumnResize;
    private updateConfigColumnWidth;
    private updateConfigColumnWidths;
    private updateColumnResizeTableWidthFromDelta;
    private clampColumnResizeTableWidthPx;
    private captureColumnResizeLockedWidths;
    private resolveColumnResizeTableWidthPx;
    private resolveColumnWidthPx;
    private resolveColumnAutoFitWidthPx;
    private measureRenderedColumnElementWidthPx;
    private parseColumnResizePixelWidth;
    private normalizeColumnResizeWidthStyle;
    private clampColumnWidthPx;
    private resolveColumnResizeEffectiveMinWidthPx;
    private resolveColumnResizeMinWidthPx;
    private resolveColumnResizeMaxWidthPx;
    private normalizeColumnResizeConfigWidths;
    private runColumnResizeLayoutMutation;
    private reconcileColumnResizeLayoutState;
    private clearColumnResizeLayoutState;
    private createColumnResizeLayoutSignature;
    private formatColumnWidthPx;
    private isTableRtl;
    private resolveColumnReorderHeader;
    private isEnglishLocale;
    private isEnglishLocaleValue;
    private isColumnDragDebugEnabled;
    private logColumnDragDebug;
    private resolveTableMessageTemplate;
    private resolveTableMessage;
    getColumnDragHandleAriaLabel(column: ColumnDefinition): string;
    getColumnDragHandleTooltip(column: ColumnDefinition): string;
    private publishColumnReorderStatus;
    private publishColumnReorderVisualStatus;
    private clearColumnReorderVisualStatus;
    private clearColumnReorderUndoSubscription;
    private emitColumnReorderAttempt;
    private createColumnReorderOperationId;
    private isLatestColumnReorderOperation;
    private createColumnRuntimeMutationOperationId;
    private isLatestColumnRuntimeMutationOperation;
    private persistColumnRuntimeMutation;
    private startColumnRuntimePersistence;
    private publishColumnResizeStatus;
    private offerColumnReorderUndo;
    private restoreColumnOrderFromUndo;
    onColumnHeaderReorderKeydown(event: KeyboardEvent, column: ColumnDefinition): void;
    onColumnDrop(event: CdkDragDrop<ColumnDefinition[]>): void;
    onColumnDragStarted(column: ColumnDefinition): void;
    onColumnDragEnded(event: CdkDragEnd<ColumnDefinition>, column: ColumnDefinition): void;
    private applyColumnReorder;
    private reorderConfigColumnsByVisibleOrder;
    private haveSameFieldMultiset;
    private resolveColumnDropZone;
    private normalizeDropZoneToken;
    private parseColumnDropZoneRules;
    private canDropAcrossColumnZones;
    private persistTableConfigAfterRuntimeMutation;
    private isConfigConcurrencyConflict;
    private reconcileConcurrentColumnRuntimeMutation;
    private applyDefaultSortIfNone;
    /**
     * Performs a lightweight server schema verification using ETag/If-None-Match without
     * downloading or storing the schema body. Updates config.meta (serverHash/lastVerifiedAt)
     * and toggles schemaOutdated when a new hash is detected.
     */
    private verifyServerSchemaVersion;
    private loadSchema;
    private applyOperationalRequestTimeout;
    private isOperationalRequestTimeout;
    private cancelActiveAnalyticsLoadForSupersession;
    private loadOrVerifyRemoteSchema;
    private loadFilterSchemaSnapshot;
    private convertFieldToColumn;
    private usesSchemaColumnProjection;
    /**
     * Materializa a projeção efetiva sem promover o JSON da página a fonte de
     * verdade estrutural. Overrides desconhecidos não criam colunas e `field`
     * nunca pode ser substituído pelo consumidor.
     */
    private projectSchemaColumns;
    /**
     * Converte a configuração materializada usada pelo renderer de volta ao
     * contrato compacto e persistível. O schema continua sendo a fonte
     * estrutural; somente ordem/allowlist, diferenças editoriais e colunas sem
     * correspondente canônico são serializadas.
     */
    private toPortableTableConfig;
    private diffPortableColumnDefinition;
    private toPortableColumnDefinition;
    private arePortableValuesEqual;
    private applySchemaFieldPresentationsToExistingColumns;
    private applySchemaFieldPresentation;
    private applySchemaSemanticCellPresentation;
    private resolveSemanticPresentationColor;
    private resolveSemanticPresentationVariant;
    private resolveSemanticPresentationAffixes;
    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).
     */
    private applyAutoRenderer;
    /**
     * Infer column data type from field name patterns when API type is not available
     * Refined logic to reduce false positives
     */
    private inferFieldTypeFromFieldName;
    private clearRowDiscoveryRuntime;
    private buildRowDiscoveryScopeKey;
    private resetRowContextRuntimeState;
    private enqueueRowDiscoveryRequest;
    private drainRowDiscoveryQueue;
    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;
    private shouldUseRowDiscovery;
    private shouldPrefetchRowDiscovery;
    private hasRowContextualDiscoveryEntryPoint;
    private hasRowContextualDiscoveryEntryPointRaw;
    hasRowOverflowMenuLoadingState(row: any): boolean;
    getRowOverflowMenuLoadingLabel(): string;
    hasRowOverflowMenuEmptyState(row: any): boolean;
    getRowOverflowMenuEmptyLabel(row: any): string;
    private getLegacyRowOverflowMenuEmptyLabel;
    private getRowDiscoveryMetricSnapshot;
    private createEmptyRowDiscoveryMetricSnapshot;
    private incrementRowDiscoveryMetric;
    private setRowDiscoveryLastResolvedAt;
    private resolveRowDiscoveryRuntimeStatus;
    private resolveRowDiscoveryRuntimeStatusRaw;
    private getRowContextRuntimeState;
    private buildRowContextRuntimeState;
    private resolveRowContextRuntimeValidUntil;
    private resolveRowDiscoveryRelValidUntil;
    private getRowDiscoveryPendingRowCount;
    private getRowDiscoveryDebugSnapshot;
    private hasFreshRowCapabilitySnapshot;
    private hasFreshRowActionCatalog;
    private hasFreshRowCapabilityError;
    private hasFreshRowActionError;
    private hasFreshRowDiscoveryEntry;
    private hasFreshRowDiscoveryError;
    private rememberRowCapabilitySnapshot;
    private rememberRowActionCatalog;
    private rememberRowCapabilityError;
    private rememberRowActionError;
    private clearRowCapabilityError;
    private clearRowActionError;
    private enforceRowDiscoveryCacheLimit;
    private pruneRowDiscoveryCaches;
    private pruneRowDiscoveryCache;
    private fetchData;
    private resolveAnalyticsProjection;
    private fetchAnalyticsProjectionData;
    private getEffectiveFilterCriteria;
    retryData(): void;
    reloadSchema(): void;
    retryTableError(): void;
    refetch(): void;
    /**
     * Get the cell value for a given row and column
     * Handles the complete transformation pipeline:
     * 1. _generatedValueGetter (calculated columns) or regular field access
     * 2. valueMapping (convert values to display text)
     * 3. format (data formatting like dates, numbers, currency)
     */
    getCellValue(rowData: any, column: ColumnDefinition): any;
    private applyImplicitRuntimeCellPresentation;
    private shouldHumanizeRuntimeEnumCell;
    private resolveCellFormattingType;
    private isCanonicalNumericFormat;
    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 applyAccessibleCellSurface;
    private deferUnresolvedConditionalSurface;
    private resolveRuntimeConditionalForeground;
    private normalizeInlineStyleRecord;
    private normalizeConditionalStyleRules;
    private normalizeConditionalSurfacePresetRef;
    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;
    private ensureCellAnimationPreviousValuesByRowRef;
    private ensureCellAnimationPreviousRowIdOrder;
    private clearEffectiveCellRendererCache;
    private clearCellAnimationChangeState;
    private collectComputedFieldNames;
    private buildComputedSignature;
    private stringifyDependencyValue;
    private buildComputedValueMap;
    private collectComputedColumns;
    private evaluateCanonicalComputedColumns;
    private collectComputedExpressionDependencies;
    private collectJsonLogicVarDependencies;
    private resolveJsonLogicVarPath;
    private buildEvaluationContext;
    private getJsonLogicEvaluationOptions;
    private resolveJsonLogicUserTimeZone;
    private isUnsafeComputedField;
    private evaluateStyleRule;
    private evaluateActionVisibilityCondition;
    private evaluateActionDisabledCondition;
    /** Evaluate row action conditions using the canonical JSON Logic runtime with explicit failure policy. */
    private evaluateActionCondition;
    private resolveRowVisibleWhenFailurePolicy;
    private isJsonLogicExpression;
    private hasConditionalExpression;
    private resolveRuntimeEnvironment;
    private logActionConditionFallback;
    getRowClasses(rowData: any): string[] | undefined;
    getRowNgStyle(rowData: any): Record<string, string> | undefined;
    private setupContextualConditionalSurfaceObserver;
    private scheduleContextualConditionalSurfaceResolution;
    private resolveContextualConditionalSurfaces;
    private resolveContextualConditionalSurfaceForElement;
    private getRowRenderer;
    private isMotionReductionRequested;
    private isRowAnimationRuntimeEnabled;
    private isCellAnimationRuntimeEnabled;
    private resolveRuntimeConditionalAnimationConfig;
    private getCellAnimationValueSignature;
    private shouldActivateCellAnimationOnChange;
    private getRowAnimationConfig;
    private getRowAnimationClasses;
    private getRowAnimationNgStyle;
    getCellContentClasses(rowData: any, column: ColumnDefinition): string[] | undefined;
    getCellContentNgStyle(rowData: any, column: ColumnDefinition): Record<string, string> | undefined;
    getRowTooltip(rowData: any): any;
    getRowTooltipPosition(rowData: any): 'above' | 'below' | 'left' | 'right';
    getRowTooltipShowDelay(rowData: any): number;
    /**
     * Apply value mapping to transform raw values into display-friendly text
     */
    private applyValueMapping;
    /**
     * Safely access nested properties using dot notation
     */
    private getNestedPropertyValue;
    /**
     * Verifica se a ordenação está habilitada
     */
    getSortingEnabled(): boolean;
    /**
     * Verifica se a paginação está habilitada
     */
    getPaginationEnabled(): boolean;
    /**
     * Obtém o comprimento total da paginação
     */
    getPaginationLength(): number;
    /**
     * Obtém o tamanho da página
     */
    getPaginationPageSize(): number;
    /**
     * Obtém as opções de tamanho de página
     */
    getPaginationPageSizeOptions(): number[];
    /**
     * Verifica se deve mostrar botões primeira/última
     */
    getPaginationShowFirstLast(): boolean;
    /**
     * Verifica se uma funcionalidade está disponível
     */
    isFeatureAvailable(feature: string): boolean;
    /**
     * Obtém configurações de i18n para o filtro baseado na configuração da tabela
     */
    getFilterI18n(): Partial<I18n> | undefined;
    private warnUnsupportedFeature;
    private isMultiSortSupported;
    private isColumnFiltersSupported;
    private isRowDraggingSupported;
    private isRowExpansionSupported;
    private enforceAppearanceSchemaGuards;
    private enforceUnsupportedFeatureGuards;
    getToolbarEvaluationContext(): Record<string, any>;
    getIconName(row: any, column: ColumnDefinition): string | null;
    getIconColor(_row: any, column: ColumnDefinition): string | null;
    getIconStyle(_row: any, column: ColumnDefinition): Record<string, string> | null;
    getIconAriaLabel(row: any, column: ColumnDefinition): string | null;
    getIconText(row: any, column: ColumnDefinition): string | null;
    getIconRichContentNodes(row: any, column: ColumnDefinition): RichBlockNode[];
    private getIconRawText;
    /**
     * Lightweight, controlled evaluator for string/number expressions using row context.
     * Accepts values like '= row.status === "OK" ? "primary" : "warn"'.
     * Falls back safely on error.
     */
    private evaluateValueExpr;
    private evaluateComputedValue;
    private hasCanonicalComputedExpression;
    private buildComputedRuleData;
    private resolveComputedDependencyValue;
    private evaluateLegacyExpression;
    private tryEvaluateLegacyConcat;
    private tryEvaluateLegacyTernary;
    private tryEvaluateLegacyCoalesce;
    private normalizeLegacyExpression;
    private extractLegacyArrayItems;
    private splitTopLevelTernary;
    private findTopLevelOperator;
    private splitTopLevel;
    private findMatchingBracket;
    private normalizeExpression;
    private normalizeOptionalChaining;
    private stripRowPrefixes;
    private stripOuterParens;
    private findMatchingParen;
    private extractExpression;
    private coerceExpected;
    getImageSrc(row: any, column: ColumnDefinition): string | null;
    getImageAlt(row: any, column: ColumnDefinition): string | null;
    getImageRichContentNodes(row: any, column: ColumnDefinition): RichBlockNode[];
    getImageWidth(row: any, column: ColumnDefinition): number | null;
    getImageHeight(row: any, column: ColumnDefinition): number | null;
    getImageShape(row: any, column: ColumnDefinition): 'square' | 'rounded' | 'circle' | undefined;
    getImageFit(row: any, column: ColumnDefinition): 'cover' | 'contain' | undefined;
    getImageLazy(_row: any, column: ColumnDefinition): boolean;
    getBadgeText(row: any, column: ColumnDefinition): string | null;
    getBadgeIcon(row: any, column: ColumnDefinition): string | null;
    getBadgeClasses(row: any, column: ColumnDefinition): string[];
    getBadgeRichContentNodes(row: any, column: ColumnDefinition): RichBlockNode[];
    shouldRenderBadge(row: any, column: ColumnDefinition): boolean;
    getEffectiveRendererType(row: any, column: ColumnDefinition): 'icon' | 'image' | 'badge' | 'link' | 'button' | 'chip' | 'progress' | 'avatar' | 'toggle' | 'menu' | 'html' | 'compose' | 'rating' | 'microVisualization' | null;
    getMicroVisualizationHtml(row: any, column: ColumnDefinition): SafeHtml;
    private resolveMicroVisualizationForRow;
    private applyMicroVisualizationExpression;
    private evaluateMicroVisualizationExpression;
    getComposeItems(row: any, column: ColumnDefinition): any[];
    trackComposeItem(index: number, item: any): string;
    getComposeClasses(row: any, column: ColumnDefinition): string[];
    getComposeGapStyle(row: any, column: ColumnDefinition): any;
    private getComposeItemField;
    getComposeItemValue(row: any, base: ColumnDefinition, item: any): any;
    getComposeValueClasses(item: any): string[];
    private asComposeValueItemColumn;
    asItemColumn(base: ColumnDefinition, item: any): any;
    getItemEffectiveType(row: any, column: ColumnDefinition, item: any): any;
    private mergeRenderer;
    private hasRenderableColumnOverride;
    private resolveColumnRuleAnimationCandidate;
    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[];
    getMenuItemRichContentNodes(item: {
        label?: string;
        icon?: string;
        id?: string;
    } | null | undefined): RichBlockNode[];
    getLinkTarget(row: any, column: ColumnDefinition): string | null;
    getLinkRel(row: any, column: ColumnDefinition): string | null;
    getButtonLabel(row: any, column: ColumnDefinition): string;
    getButtonIcon(row: any, column: ColumnDefinition): string | null;
    getButtonVariant(row: any, column: ColumnDefinition): 'filled' | 'outlined' | 'text';
    getButtonColor(row: any, column: ColumnDefinition): string | null;
    isButtonDisabled(row: any, column: ColumnDefinition): boolean;
    getButtonAriaLabel(row: any, column: ColumnDefinition): string | null;
    getButtonRichContentNodes(row: any, column: ColumnDefinition): RichBlockNode[];
    private evaluateActionPayloadExpr;
    private buildRendererActionRuntimeOptions;
    onButtonClick(row: any, column: ColumnDefinition, event: Event): void;
    getChipText(row: any, column: ColumnDefinition): string | null;
    private getRendererTextFieldValue;
    private normalizeRendererText;
    getChipRichContentNodes(row: any, column: ColumnDefinition): RichBlockNode[];
    shouldRenderChip(row: any, column: ColumnDefinition): boolean;
    getChipIcon(row: any, column: ColumnDefinition): string | null;
    getChipClasses(row: any, column: ColumnDefinition): string[];
    getProgressValue(row: any, column: ColumnDefinition): number;
    getProgressColor(row: any, column: ColumnDefinition): string | null;
    getProgressWidthPercentStyle(row: any, column: ColumnDefinition): number | null;
    getProgressBackgroundStyle(row: any, column: ColumnDefinition): string | null;
    getProgressShowLabel(row: any, column: ColumnDefinition): boolean;
    getProgressRichContentContext(row: any, column: ColumnDefinition): JsonLogicDataRecord;
    getProgressRichContentNodes(row: any, column: ColumnDefinition): RichBlockNode[];
    getRatingValue(row: any, column: ColumnDefinition): number;
    getRatingMax(_row: any, column: ColumnDefinition): number;
    getRatingColor(_row: any, column: ColumnDefinition): string | undefined;
    getRatingOutlineColor(_row: any, column: ColumnDefinition): string | undefined;
    getRatingSize(_row: any, column: ColumnDefinition): 'small' | 'medium' | 'large';
    getRatingAriaLabel(row: any, column: ColumnDefinition): string | undefined;
    private normalizeTableRatingValue;
    getAvatarSrc(row: any, column: ColumnDefinition): string | null;
    getAvatarAlt(row: any, column: ColumnDefinition): string | null;
    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;
    isToggleDisabled(row: any, column: ColumnDefinition): boolean;
    getToggleAriaLabel(row: any, column: ColumnDefinition): string | null;
    onToggleChange(row: any, column: ColumnDefinition, event: any): void;
    getMenuAriaLabel(row: any, column: ColumnDefinition): string | null;
    getMenuTriggerRichContentNodes(): RichBlockNode[];
    private evaluateArrayExpr;
    getMenuItems(row: any, column: ColumnDefinition): Array<{
        label: string;
        icon?: string;
        id: string;
        __visible: boolean;
        payload?: any;
        actionConfig?: any;
    }>;
    onMenuItemClick(actionOrItem: string | {
        id?: string;
        payload?: any;
        actionConfig?: any;
    }, row: any, event: Event): void;
    getSafeHtml(row: any, column: ColumnDefinition): any;
    private escapeHtml;
    private sanitizeStrictHtml;
    private isSafeStrictInlineStyle;
    private isSafeStrictHtmlUrl;
    private escapeHtmlAttribute;
    private isStrictCspStyleModeEnabled;
    private warnStrictCspStyleModeOnce;
    private clearAppearanceCssVariables;
    private applyAppearanceVariables;
    private getPrefsKey;
    private getOutdatedIgnoreKey;
    private getOutdatedSnoozeKey;
    private getOutdatedNotifiedKey;
    private isOutdatedIgnored;
    private getOutdatedSnoozeUntil;
    private setOutdatedSnooze;
    private setOutdatedIgnore;
    private setOutdatedNotified;
    private wasOutdatedNotified;
    private resolveSchemaPrefs;
    private maybeShowOutdatedSnack;
    shouldShowOutdatedInline(): boolean;
    onReconcileRequested(): void;
    onSnoozeOutdated(): void;
    onIgnoreOutdated(): void;
    private updateRuntimeSchemaMetaFromServerInfo;
    private emitMetadataChange;
    private emitSchemaStatus;
    getRowId(row: any): any;
    private reconcileSelectionAfterDataChange;
    private getComparableRowIdentity;
    getIdField(): string;
    private getSchemaIdFieldOverride;
    private resolveConfigMetaIdField;
    private normalizeIdField;
    private syncRuntimeSchemaMetaFromConfig;
    private getEffectiveMetadataSnapshot;
    getActionId(action: any): string;
    private setupResizeObserver;
    private setupViewportChangeListeners;
    private getVirtualizationSources;
    isVirtualized(): boolean;
    getVirtItemHeight(): number;
    private getDefaultDensityRowHeight;
    getVirtBufferSize(): number;
    getVirtMinHeightStyle(): string;
    getVirtMinHeightHostStyle(): string | null;
    getVirtualTableWidthStyle(): string | null;
    isSelectionColumnEnabled(): boolean;
    isRowClickSelectable(): boolean;
    getRowTabIndex(row: any, index: number): number | null;
    onRowFocused(row: any, index: number): void;
    onRowKeydown(event: KeyboardEvent, row: any, index: number): void;
    private reconcileKeyboardFocusAfterDataChange;
    private hasKeyboardRowFocus;
    private restorePendingKeyboardRowFocus;
    canSelectAll(): boolean;
    masterToggle(): void;
    isAllSelected(): boolean;
    toggleRow(row: any): void;
    getRowSelectionAriaLabel(row: any, index?: number): string;
    getMasterSelectionAriaLabel(): string;
    private selectRowFromUserInteraction;
    private emitSelectionChange;
    private publishSelectionStatus;
    private getAccessibleRowLabel;
    getKeyboardRowIdentity(row: any, index: number): string;
    private materializeRecordIdentity;
    private resolveHostIdentityIdField;
    private reportResourceIdentityDiagnostics;
    private emitResourceEvent;
    private buildResourceEvent;
    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;
    getActionsHeaderIcon(): string | undefined;
    getActionsHeaderLabel(): string | undefined;
    getActionsHeaderRichContentNodes(): RichBlockNode[];
    private getRowActionsDisplay;
    private getRowActionsInlineLimit;
    private getRowActionsBehaviorInlineLimit;
    private getBreakpointInlineLimit;
    private estimateInlineActionsLimit;
    private parsePixelWidth;
    private getViewportWidth;
    private splitVisibleRowActions;
    getInlineRowActions(row: any): any[];
    getOverflowRowActions(row: any): any[];
    hasOverflowRowActions(row: any): boolean;
    onRowOverflowMenuOpened(row: any): void;
    private prepareRowDiscoveryRetry;
    private getVisibleRowActions;
    private getResolvedRowActions;
    private buildResolvedRowActions;
    private splitVisibleRowActionsFromVisible;
    private decorateConfiguredRowAction;
    private isConfiguredRowActionDiscoveryIndependent;
    private isRowDiscoveryStatusUnresolved;
    private buildPendingConfiguredRowAction;
    private getDiscoveredRowWorkflowActions;
    private getDiscoveredRowCrudActionsFromSnapshot;
    private buildDiscoveredRowCrudAction;
    private getDiscoveredRowSurfaceActionsFromSnapshot;
    private getDiscoveredRowWorkflowActionsFromCatalog;
    private getDiscoveredRowWorkflowActionsFromItems;
    private resolveRowCrudCapabilityOperation;
    private createSyntheticCrudCapabilityOperation;
    private supportsRowCrudAction;
    private isCapabilityManagedCrudRowAction;
    private isFailClosedConfiguredRowAction;
    private getCrudRowActionLabel;
    private getCrudRowActionIcon;
    private getCrudRowActionColor;
    private getUnavailableCrudOperationMessage;
    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;
    isActionDisabled(action: any, row: any): boolean;
    getRowActionRuntimeOptions(action: RuntimeRowAction, row: any): RowActionRuntimeOptions | undefined;
    isRowActionBusy(action: RuntimeRowAction, row: unknown): boolean;
    getActionTooltip(action: RuntimeRowAction | any, row: any): string | null;
    getActionAriaDescription(action: RuntimeRowAction | any, row: any): string | null;
    getRowMenuTooltip(row: any): string;
    getRowMenuButtonColor(): any;
    getCanonicalIconActionColor(color: unknown): string | null;
    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, null, { optional: true; }, { 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; }; "configPersistenceStrategy": { "alias": "configPersistenceStrategy"; "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; }; "authoringCapability": { "alias": "authoringCapability"; "required": false; }; "dense": { "alias": "dense"; "required": false; }; }, { "rowClick": "rowClick"; "widgetEvent": "widgetEvent"; "resourceEvent": "resourceEvent"; "rowDoubleClick": "rowDoubleClick"; "rowExpansionChange": "rowExpansionChange"; "rowAction": "rowAction"; "toolbarAction": "toolbarAction"; "bulkAction": "bulkAction"; "exportAction": "exportAction"; "columnReorder": "columnReorder"; "columnReorderAttempt": "columnReorderAttempt"; "columnResize": "columnResize"; "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;
}

interface EditorDocument<TConfig, TBindings = unknown> {
    kind: string;
    version: number;
    config: TConfig;
    bindings?: TBindings;
}
type TableHorizontalScroll = 'auto' | 'wrap' | 'none';
interface TableBindings {
    resourcePath?: string | null;
    horizontalScroll?: TableHorizontalScroll;
}
interface TableAuthoringDocument extends EditorDocument<TableConfig, TableBindings> {
    kind: 'praxis.table.editor';
    version: 1;
}
interface EditorDiagnostic {
    level: 'error' | 'warning' | 'info';
    code: string;
    message: string;
    path?: string;
}
interface TableValidationContext {
    hasLocalDataInput?: boolean;
    localDataModeDefaultEnabled?: boolean;
    server?: {
        idField?: string;
        schemaHash?: string;
    };
}
interface TableProjectionContext {
    hasLocalDataInput?: boolean;
    localDataModeDefaultEnabled?: boolean;
}
interface TableRuntimeContext {
    hasLocalDataInput?: boolean;
    localDataModeDefaultEnabled?: boolean;
    server?: {
        idField?: string;
        schemaId?: string;
        schemaHash?: string;
    };
    crud?: {
        tableId: string;
        componentKeyId?: string;
    };
    currentBindings?: TableBindings;
}
interface TableApplyPlan {
    canonicalConfig: TableConfig;
    bindingsPatch?: TableBindings;
    persistence?: {
        saveConfig?: boolean;
        saveBindings?: boolean;
    };
    runtime?: {
        reconnectDataSource?: boolean;
        reloadSchema?: boolean;
        fetchData?: boolean;
        refreshLocalView?: boolean;
    };
    metadata?: {
        attachServerMeta?: boolean;
    };
    diff?: {
        resourcePathChanged?: boolean;
        horizontalScrollChanged?: boolean;
        requiresDataRefresh?: boolean;
    };
    diagnostics: EditorDiagnostic[];
}

interface JsonValidationResult {
    isValid: boolean;
    error?: string;
    document?: TableAuthoringDocument;
    diagnostics?: EditorDiagnostic[];
}
interface JsonEditorEvent {
    type: 'apply' | 'format' | 'validation';
    payload: JsonValidationResult;
}
declare class JsonConfigEditorComponent implements OnInit, OnDestroy {
    private cdr;
    document: TableAuthoringDocument | null;
    documentChange: EventEmitter<TableAuthoringDocument>;
    validationChange: EventEmitter<JsonValidationResult>;
    editorEvent: EventEmitter<JsonEditorEvent>;
    jsonText: string;
    isValidJson: boolean;
    jsonError: string;
    unknownTopKeys: string[];
    private destroy$;
    private jsonTextChanges$;
    constructor(cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onJsonTextChange(text: string): void;
    applyJsonChanges(): void;
    formatJson(): void;
    updateJsonFromDocument(document: TableAuthoringDocument): void;
    getCurrentDocument(): TableAuthoringDocument | null;
    hasChanges(): boolean;
    private validateJson;
    private updateValidationState;
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonConfigEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JsonConfigEditorComponent, "json-config-editor", never, { "document": { "alias": "document"; "required": false; }; }, { "documentChange": "documentChange"; "validationChange": "validationChange"; "editorEvent": "editorEvent"; }, never, never, true, never>;
}

type FormulaType = 'none' | 'concatenation' | 'arithmetic' | 'nested_property' | 'conditional_mapping' | 'default_value';
interface FieldSchema {
    name: string;
    label: string;
    type: 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array';
    path?: string;
}
interface FormulaDefinition {
    type: FormulaType;
    params: any;
    _generatedExpression?: string;
}
interface ConcatenationParams {
    fields: string[];
    separator: string;
    ignoreEmpty: boolean;
}
interface ArithmeticParams {
    operator: '+' | '-' | '*' | '/';
    operand1: string | number;
    operand2: string | number;
}
interface NestedPropertyParams {
    propertyPath: string;
    fallbackValue?: any;
}
interface ConditionalMappingParams {
    conditionField: string;
    comparisonValue: any;
    trueValue: any;
    falseValue: any;
    operator?: '===' | '!=' | '>' | '<' | '>=' | '<=';
}
interface DefaultValueParams {
    originalField: string;
    defaultValue: any;
}
type FormulaParams = ConcatenationParams | ArithmeticParams | NestedPropertyParams | ConditionalMappingParams | DefaultValueParams;
interface FormulaTemplate {
    type: FormulaType;
    label: string;
    description: string;
    icon: string;
    parameterSchema: FormulaParameterSchema[];
}
interface FormulaParameterSchema {
    key: string;
    label: string;
    type: 'field' | 'text' | 'number' | 'boolean' | 'select' | 'value_input';
    required: boolean;
    options?: {
        value: any;
        label: string;
    }[];
    placeholder?: string;
    hint?: string;
    valueType?: 'string' | 'number' | 'boolean' | 'any';
}
declare const FORMULA_TEMPLATES: FormulaTemplate[];

interface ColumnChange {
    type: 'add' | 'remove' | 'update' | 'reorder' | 'global';
    columnIndex?: number;
    column?: ColumnDefinition;
    columns?: ColumnDefinition[];
    fullConfig?: TableConfig;
}
interface ExtendedColumnDefinition extends ColumnDefinition {
    calculationType?: string;
    calculationParams?: any;
    _generatedValueGetter?: string;
    valueMapping?: {
        [key: string | number]: string;
    };
    format?: string;
    conditionalStyles?: any[];
    cellClassCondition?: any;
    resizable?: boolean;
    filterable?: boolean;
}
interface RendererFieldOption {
    name: string;
    label: string;
    type?: string;
    isVisible: boolean;
    isHidden?: boolean;
}
type ComposePresetId = 'personAvatar' | 'contactTwoLines' | 'documentEmail' | 'statusChip';
declare class ColumnsConfigEditorComponent implements OnInit, OnChanges, OnDestroy {
    private cdr;
    private readonly i18n;
    tx(key: string, fallback: string): string;
    readonly ratingAriaLabelPlaceholder: string;
    readonly ratingRendererHint: string;
    readonly composeRatingRendererHint: string;
    config: TableConfig;
    readonly: boolean;
    fieldMetadata: Array<{
        name?: string;
        label?: string;
        type?: string;
        tableHidden?: boolean;
        hidden?: boolean;
        xUi?: Record<string, any>;
        ui?: Record<string, any>;
    }>;
    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
    columnChange: EventEmitter<ColumnChange>;
    columns: ExtendedColumnDefinition[];
    selectedColumnIndex: number;
    selectedColumn: ExtendedColumnDefinition | null;
    isV2Config: boolean;
    private expressionEvaluator;
    availableDataSchema: FieldSchema[];
    currentFieldSchemas: FieldSchema[];
    sampleTableData: any[];
    globalSortableEnabled: boolean;
    globalAlignment: 'left' | 'center' | 'right' | null;
    visibilityState: 'all' | 'none' | null;
    globalResizable: boolean;
    globalStickyEnabled: boolean;
    private operationInProgress;
    private columnOperationSubject;
    private readonly destroyRef;
    private destroy$;
    onlyVisibleRendererFields: boolean;
    uiRendererType: 'icon' | 'image' | 'badge' | 'link' | 'button' | 'chip' | 'progress' | 'microVisualization' | 'avatar' | 'toggle' | 'menu' | 'rating' | 'html' | 'compose' | null;
    private _rendererApplyTimer;
    rendererFieldOptions: RendererFieldOption[];
    uiRendererConditional: boolean;
    condOverridesSelectedIndex: number;
    getConditionalOverrides(): any[];
    ensureConditionalOverrides(): any[];
    addConditionalOverride(): void;
    removeConditionalOverride(index: number): void;
    duplicateConditionalOverride(index: number): void;
    onConditionalOverrideReorder(event: any): void;
    selectConditionalOverride(index: number): void;
    getJsonLogicText(value: JsonLogicExpression | null | undefined): string;
    getJsonLogicSummary(value: JsonLogicExpression | null | undefined): string;
    private parseJsonLogicText;
    setConditionalOverrideCondition(index: number, raw: string): void;
    getOverrideField(path: string): any;
    setOverrideField(path: string, value: any): void;
    setOverrideJsonLogicField(path: string, raw: string): void;
    private ensureOverrideCompose;
    getOverrideComposeItems(): Array<{
        item: any;
        index: number;
    }>;
    addOverrideComposeValueItem(): void;
    setOverrideComposeValueItemField(index: number, field: string): void;
    setOverrideComposeValueItemEmphasis(index: number, emphasis: string): void;
    getOverrideComposeLayoutProp(key: string): any;
    setOverrideComposeLayoutProp(key: string, value: any): void;
    onOverrideTypeChange(ov: any, val: string): void;
    getOverrideMicroVisualizationProp(path: string): any;
    setOverrideMicroVisualizationProp(path: string, value: any): void;
    getOverrideMicroVisualizationKind(): PraxisPresentationVisualizationKind;
    getOverrideMicroVisualizationGuidance(): 'recommended' | 'conditional';
    getOverrideMicroVisualizationConstraint(): PraxisTableCellVisualizationConstraint;
    isOverrideMicroVisualizationValueKind(): boolean;
    isOverrideMicroVisualizationPointsKind(): boolean;
    isOverrideMicroVisualizationSegmentsKind(): boolean;
    isOverrideMicroVisualizationItemsKind(): boolean;
    isOverrideMicroVisualizationTotalKind(): boolean;
    getOverrideMicroVisualizationGuidanceText(): string;
    exportOverrideJson(index: number): void;
    importOverrideJson(index: number): void;
    rendererValidationErrors: string[];
    rendererImportWarnings: string[];
    rendererIsValid: boolean;
    rendererPreviewEnabled: boolean;
    private rendererAppliedSnapshot;
    previewRows: any[];
    private refreshRendererFieldOptions;
    getRendererFieldOptions(): RendererFieldOption[];
    formatRendererFieldOption(option: RendererFieldOption): string;
    private buildRendererFieldOptions;
    private sortRendererFieldOptions;
    onRendererFieldToggleChange(): void;
    constructor(cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private updateGlobalSettings;
    private updateVisibilityState;
    getVisibleColumnsCount(): number;
    areAllColumnsVisible(): boolean;
    areAllColumnsHidden(): boolean;
    onVisibilityChange(state: 'all' | 'none'): void;
    showAllColumns(): void;
    hideAllColumns(): void;
    applyGlobalSortable(enabled: boolean): void;
    applyGlobalAlignment(alignment: 'left' | 'center' | 'right'): void;
    applyGlobalResizable(enabled: boolean): void;
    applyGlobalSticky(enabled: boolean): void;
    private isColumnExplicitlySet;
    selectColumn(index: number): void;
    addNewColumn(): void;
    removeColumn(index: number, event: Event): void;
    onColumnReorder(event: CdkDragDrop<ExtendedColumnDefinition[]>): void;
    private updateColumnOrders;
    onColumnPropertyChange(): void;
    isExistingColumn(column: ColumnDefinition): boolean;
    isCalculatedColumn(column: ColumnDefinition): boolean;
    hasValueGetterError(column: ColumnDefinition): boolean;
    private generateAvailableDataSchema;
    /**
     * Map ColumnDataType to FieldSchema type
     */
    private mapColumnTypeToFieldType;
    getColumnFormula(column: ColumnDefinition | null): FormulaDefinition | undefined;
    onFormulaChange(formula: FormulaDefinition): void;
    onGeneratedExpressionChange(expression: string): void;
    getMappingCount(column: ColumnDefinition): number;
    getMappingTooltip(column: ColumnDefinition): string;
    getMappingPanelDescription(column: ColumnDefinition | null): string;
    getColumnMapping(column: ColumnDefinition | null): {
        [key: string | number]: string;
    };
    getRendererType(col: ColumnDefinition | null): 'icon' | 'image' | 'badge' | 'link' | 'button' | 'chip' | 'progress' | 'microVisualization' | 'avatar' | 'toggle' | 'menu' | 'rating' | 'html' | null;
    onRendererTypeChange(type: 'icon' | 'image' | 'badge' | 'link' | 'button' | 'chip' | 'progress' | 'microVisualization' | 'avatar' | 'toggle' | 'menu' | 'rating' | 'html' | 'compose' | null): void;
    onRendererModeClosed(): void;
    onToggleRendererConditional(enabled: boolean): void;
    getRendererTypeExpr(): string;
    setRendererTypeExpr(val: string): void;
    getRendererIconName(): string;
    setRendererIconName(v: string): void;
    getRendererIconNameField(): string;
    setRendererIconNameField(v: string): void;
    getRendererIconColor(): string;
    setRendererIconColor(v: string): void;
    getRendererIconSize(): number | null;
    setRendererIconSize(v: number): void;
    getRendererImageSrc(): string;
    setRendererImageSrc(v: string): void;
    getRendererImageSrcField(): string;
    setRendererImageSrcField(v: string): void;
    getRendererImageAlt(): string;
    setRendererImageAlt(v: string): void;
    getRendererImageAltField(): string;
    setRendererImageAltField(v: string): void;
    getRendererImageWidth(): number | null;
    setRendererImageWidth(v: number): void;
    getRendererImageHeight(): number | null;
    setRendererImageHeight(v: number): void;
    getRendererImageShape(): 'square' | 'rounded' | 'circle' | '';
    setRendererImageShape(v: any): void;
    getRendererImageFit(): 'cover' | 'contain' | '';
    setRendererImageFit(v: any): void;
    getRendererImageLazy(): boolean;
    setRendererImageLazy(v: boolean): void;
    getRendererBadgeText(): string;
    setRendererBadgeText(v: string): void;
    getRendererBadgeTextField(): string;
    setRendererBadgeTextField(v: string): void;
    getRendererBadgeColor(): string;
    setRendererBadgeColor(v: string): void;
    getRendererBadgeVariant(): string;
    setRendererBadgeVariant(v: string): void;
    getRendererBadgeIcon(): string;
    setRendererBadgeIcon(v: string): void;
    private ensureRenderer;
    private _ensureKind;
    getRendererProp(kind: string, path: string): any;
    setRendererJsonLogicProp(kind: string, path: string, raw: string): void;
    setRendererProp(kind: string, path: string, value: any): void;
    private createDefaultMicroVisualization;
    setMicroVisualizationProp(path: string, value: any): void;
    private _deepClone;
    hasSelectedRenderer(): boolean;
    onApplyRenderer(): void;
    onDiscardRenderer(): void;
    onExportRendererJson(): Promise<void>;
    onImportRendererJson(): void;
    private collectRendererImportWarnings;
    private sanitizeRenderer;
    private sanitizeComposeItem;
    private ensurePreviewRows;
    private evalValueExpr;
    private evalMicroVisualizationExpression;
    private evalArrayExpr;
    private normalizeExpression;
    private normalizeOptionalChaining;
    private extractExpression;
    private stripRowPrefixes;
    private _coerceExpected;
    private getNested;
    getPreviewRendererType(row: any): 'icon' | 'image' | 'badge' | 'link' | 'button' | 'chip' | 'progress' | 'microVisualization' | 'rating' | 'avatar' | 'toggle' | 'menu' | 'html' | 'compose' | null;
    getPreviewIconName(row: any): string | null;
    getPreviewIconColor(row: any): string | null;
    getPreviewIconStyle(row: any): Record<string, string> | null;
    getPreviewImageSrc(row: any): string | null;
    getPreviewImageAlt(row: any): string | null;
    getPreviewImageWidth(): number | null;
    getPreviewImageHeight(): number | null;
    getPreviewImageShape(): 'square' | 'rounded' | 'circle' | undefined;
    getPreviewImageFit(): 'cover' | 'contain' | undefined;
    getPreviewBadgeText(row: any): string | null;
    getPreviewBadgeIcon(_row: any): string | null;
    getPreviewBadgeClasses(_row: any): string[];
    getPreviewLinkText(row: any): string;
    getPreviewLinkHref(row: any): string | null;
    getPreviewButtonLabel(row: any): string;
    getPreviewButtonIcon(): string | null;
    getPreviewChipText(row: any): string | null;
    getPreviewChipClasses(): string[];
    getPreviewProgressValue(row: any): number;
    getPreviewMicroVisualizationHtml(row: any): string;
    getMicroVisualizationGuidance(): 'recommended' | 'conditional';
    getMicroVisualizationKind(): PraxisPresentationVisualizationKind;
    isMicroVisualizationValueKind(): boolean;
    isMicroVisualizationPointsKind(): boolean;
    isMicroVisualizationSegmentsKind(): boolean;
    isMicroVisualizationItemsKind(): boolean;
    isMicroVisualizationTotalKind(): boolean;
    getMicroVisualizationGuidanceText(): string;
    getMicroVisualizationConstraint(): PraxisTableCellVisualizationConstraint;
    getPreviewRatingValue(row: any): number;
    getPreviewRatingMax(): number;
    getPreviewRatingColor(): string | undefined;
    getPreviewRatingOutlineColor(): string | undefined;
    getPreviewRatingSize(): 'small' | 'medium' | 'large';
    getPreviewRatingAriaLabel(): string | undefined;
    getComposePreviewItems(_row: any): any[];
    getComposePreviewRatingValue(item: any, row: any): number;
    getComposePreviewRatingMax(item: any): number;
    getComposePreviewRatingColor(item: any): string | undefined;
    getComposePreviewRatingOutlineColor(item: any): string | undefined;
    getComposePreviewRatingSize(item: any): 'small' | 'medium' | 'large';
    getComposePreviewRatingAriaLabel(item: any): string | undefined;
    private normalizePreviewRatingValue;
    getPreviewAvatarSrc(row: any): string | null;
    getPreviewAvatarInitials(row: any): string;
    private derivePreviewAvatarInitials;
    getPreviewAvatarStyle(): Record<string, string>;
    getPreviewAvatarShape(): 'square' | 'rounded' | 'circle' | undefined;
    getPreviewToggleState(row: any): boolean;
    getPreviewMenuCount(row: any): number;
    getPreviewHtml(row: any): string;
    trackByIdx: (_: number, item: any) => number;
    private validateRenderer;
    private readonly _emptyMappingRef;
    composeSelectedIndex: number;
    private ensureCompose;
    getComposeItemsUI(): Array<{
        type: string;
        summary: string;
        raw: any;
    }>;
    private getComposeItemSummary;
    addComposeItem(kind: string): void;
    applyComposePreset(preset: ComposePresetId): void;
    removeComposeItem(index: number): void;
    duplicateComposeItem(index: number): void;
    onComposeReorder(event: any): void;
    selectComposeItem(index: number): void;
    getComposeLayoutProp(key: string): any;
    setComposeLayoutProp(key: string, value: any): void;
    getSelectedComposeItem(): any;
    getSelectedComposeItemProp(path: string): any;
    setSelectedComposeItemProp(path: string, value: any): void;
    private findRendererFieldByCandidates;
    private normalizeFieldLookup;
    getColumnKeyInputType(column: ColumnDefinition | null): 'text' | 'number' | 'boolean';
    onMappingChange(mapping: {
        [key: string | number]: string;
    }): void;
    get selectedColumnDataType(): ColumnDataType$1;
    set selectedColumnDataType(value: ColumnDataType$1);
    getColumnDataType(column: ColumnDefinition | null): ColumnDataType$1;
    /**
     * Infer column data type from field name patterns (shared logic with PraxisTable)
     */
    private inferFieldTypeFromFieldName;
    onDataTypeChange(dataType: ColumnDataType$1): void;
    showDataFormatter(column: ColumnDefinition | null): boolean;
    getFormatterIcon(column: ColumnDefinition | null): string;
    getFormatterPanelDescription(column: ColumnDefinition | null): string;
    getColumnFormat(column: ColumnDefinition | null): string;
    onFormatChange(format: string): void;
    private emitConfigChange;
    /**
     * Public method to update columns from external source
     */
    updateColumnsFromConfig(config: TableConfig): void;
    /**
     * Public method to get current columns
     */
    getCurrentColumns(): ExtendedColumnDefinition[];
    private initializeStyleRules;
    private generateSampleData;
    getStyleRulesPanelDescription(column: ColumnDefinition | null): string;
    onConditionalStylesChanged(styles: any[]): void;
    onRuleValidated(event: {
        ruleId: string;
        result: any;
    }): void;
    private updateFieldSchemasForStyleRules;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsConfigEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnsConfigEditorComponent, "columns-config-editor", never, { "config": { "alias": "config"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "fieldMetadata": { "alias": "fieldMetadata"; "required": false; }; }, { "configChange": "configChange"; "columnChange": "columnChange"; }, never, never, true, never>;
}

interface BehaviorConfigChange {
    type: 'pagination' | 'sorting' | 'filtering' | 'selection' | 'dragging' | 'interaction' | 'loading' | 'expansion' | 'general';
    property: string;
    value: any;
    fullConfig: TableConfig;
}
declare class BehaviorConfigEditorComponent implements OnInit, OnDestroy, OnChanges {
    private fb;
    private readonly i18n;
    tx(key: string, fallback: string): string;
    readonly schemaOnlyLimitationsDocPath = "praxis-table.json-api.md#known-limitations-and-mismatches";
    readonly multiSortSchemaOnlyTooltip: string;
    readonly columnFiltersSchemaOnlyTooltip: string;
    readonly draggingRowsSchemaOnlyTooltip: string;
    readonly expansionSchemaOnlyTooltip: string;
    config: TableConfig;
    resourcePath?: string;
    forceClientStrategies: boolean;
    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
    behaviorChange: EventEmitter<BehaviorConfigChange>;
    behaviorForm: FormGroup;
    isV2: boolean;
    private destroy$;
    private previousBehaviorFormValue;
    constructor(fb: FormBuilder);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private initializeForm;
    private setupFormListeners;
    /**
     * Applies current form values to the configuration immediately.
     * Useful to flush pending changes before external save operations.
     */
    applyFormChanges(): void;
    private updateConfig;
    private resolveStrategy;
    private enforceStrategyConstraints;
    private coerceSchemaOnlyControls;
    private coerceExpansionControls;
    private buildFormSnapshotFromConfig;
    private areSnapshotsEqual;
    private getChangedProperties;
    private areFieldValuesEqual;
    private emitBehaviorChanges;
    private resolveBehaviorChangeType;
    private arrayToString;
    private stringToArray;
    private stringToStringArray;
    private resolvePositiveNumber;
    private resolveNonNegativeNumber;
    private resolveExpansionMaxExpandedRows;
    private asRecord;
    private cloneRecord;
    private cloneTableConfig;
    private resolveAllowedNodes;
    private objectToPrettyJson;
    private parseJsonRecordOrFallback;
    private setInlineSchemaParseError;
    private setResourcePathParamsMapParseError;
    private isInlineSchemaValidationErrorActive;
    private isResourcePathParamsMapValidationErrorActive;
    private setControlErrorFlag;
    static ɵfac: i0.ɵɵFactoryDeclaration<BehaviorConfigEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BehaviorConfigEditorComponent, "behavior-config-editor", never, { "config": { "alias": "config"; "required": false; }; "resourcePath": { "alias": "resourcePath"; "required": false; }; "forceClientStrategies": { "alias": "forceClientStrategies"; "required": false; }; }, { "configChange": "configChange"; "behaviorChange": "behaviorChange"; }, never, never, true, never>;
}

interface ToolbarAction {
    id: string;
    label: string;
    icon?: string;
    type: 'button' | 'icon' | 'fab' | 'menu';
    color?: 'primary' | 'accent' | 'warn';
    /** Material button appearance: filled (flat), outlined (stroked), elevated (raised), text, tonal */
    appearance?: 'filled' | 'outlined' | 'elevated' | 'text' | 'tonal';
    action: string;
    target?: {
        scope: 'collection' | 'selection';
        cardinality?: {
            min: number;
            max?: number;
        };
    };
    globalAction?: GlobalActionRef;
    effects?: PraxisRuntimeGlobalActionEffect[];
    position: 'start' | 'end';
    order?: number;
    disabled?: boolean;
    visible?: boolean;
    shortcut?: string;
    shortcutScope?: 'toolbar' | 'global';
    tooltip?: string;
    visibleWhen?: JsonLogicExpression | null;
    children?: ToolbarAction[];
}
interface RowAction {
    id: string;
    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 {
    id: string;
    label: string;
    icon: string;
    action: string;
    globalAction?: GlobalActionRef;
    effects?: PraxisRuntimeGlobalActionEffect[];
    color?: 'primary' | 'accent' | 'warn';
    tooltip?: string;
    requiresConfirmation?: boolean;
    autoDelete?: boolean;
    minSelections?: number;
    maxSelections?: number;
}
interface ToolbarActionsChange {
    type: 'toolbar' | 'rowActions' | 'bulkActions' | 'export';
    property: string;
    value: any;
    fullConfig: TableConfig;
}
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;
    label: string;
    description: string;
}
declare class ToolbarActionsEditorComponent implements OnInit, OnDestroy, OnChanges {
    private fb;
    private iconPicker;
    config: TableConfig;
    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
    toolbarActionsChange: EventEmitter<ToolbarActionsChange>;
    toolbarForm: FormGroup;
    isV2: boolean;
    toolbarActions: ToolbarAction[];
    rowActions: RowAction[];
    bulkActions: BulkAction[];
    getActionTrackKey(action: ToolbarAction | RowAction | BulkAction, index: number): string;
    editingToolbarActionIndex: number | null;
    editingRowActionIndex: number | null;
    editingBulkActionIndex: number | null;
    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 destroy$;
    constructor(fb: FormBuilder, iconPicker: IconPickerService);
    tx(key: string, fallback: string): string;
    getGlobalActionSpecLabel(spec: {
        id?: string;
        label?: string;
    }): string;
    getGlobalActionSpecHint(spec: {
        id?: string;
        description?: string;
        param?: {
            hint?: string;
        };
    }): string;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private initializeForm;
    private setupFormListeners;
    private loadActionsFromConfig;
    private syncActionsFromConfig;
    private areActionsEqual;
    private isAddLike;
    private findAddToolbarIndex;
    private ensureAddToolbarAction;
    private removeAddToolbarAction;
    private syncAddFormFromActions;
    private updateConfig;
    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): 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;
    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: 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 buildGlobalActionPayload;
    getToolbarActionShortcutScope(action: ToolbarAction): ToolbarShortcutScope;
    onToolbarActionShortcutScopeChange(action: ToolbarAction, value: ToolbarShortcutScope | string): void;
    onToolbarActionTargetScopeChange(action: ToolbarAction, scope: 'collection' | 'selection'): void;
    onToolbarActionTargetMinChange(action: ToolbarAction, value: unknown): void;
    onToolbarActionTargetMaxChange(action: ToolbarAction, value: unknown): void;
    addToolbarAction(): void;
    editToolbarAction(index: number): void;
    removeToolbarAction(index: number): void;
    dropToolbarAction(event: CdkDragDrop<ToolbarAction[]>): void;
    updateToolbarActions(): void;
    addRowAction(): void;
    editRowAction(index: number): void;
    removeRowAction(index: number): void;
    dropRowAction(event: CdkDragDrop<RowAction[]>): void;
    updateRowActions(): void;
    addBulkAction(): void;
    editBulkAction(index: number): void;
    removeBulkAction(index: number): void;
    dropBulkAction(event: CdkDragDrop<BulkAction[]>): void;
    updateBulkActions(): void;
    applyToolbarTemplate(tpl: 'crudAdd', mode: 'replace' | 'merge'): void;
    applyRowActionsTemplate(tpl: 'crud' | 'editDelete' | 'viewOnly' | 'crudWithBulk', mode: 'replace' | 'merge'): void;
    private mergeRowActions;
    private mergeToolbarActions;
    private mergeBulkActions;
    private sanitizeToolbarActions;
    private sanitizeShortcutScope;
    private warnInvalidShortcutScope;
    private getActionDraftKey;
    private getActionDedupeKey;
    pickAddButtonIcon(): Promise<void>;
    pickToolbarIcon(): Promise<void>;
    private normalizeToolbarIcon;
    private normalizeToolbarTextAlign;
    pickActionIcon(index: number): Promise<void>;
    pickRowActionIcon(index: number): Promise<void>;
    pickBulkActionIcon(index: number): Promise<void>;
    pickRowMenuIcon(): Promise<void>;
    pickRowHeaderIcon(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarActionsEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarActionsEditorComponent, "toolbar-actions-editor", never, { "config": { "alias": "config"; "required": false; }; }, { "configChange": "configChange"; "toolbarActionsChange": "toolbarActionsChange"; }, never, never, true, never>;
}

interface MessagesLocalizationChange {
    type: 'messages' | 'localization' | 'formatting';
    property: string;
    value: any;
    fullConfig: TableConfig;
}
declare class MessagesLocalizationEditorComponent implements OnInit, OnDestroy {
    private fb;
    config: TableConfig;
    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
    messagesLocalizationChange: EventEmitter<MessagesLocalizationChange>;
    private readonly i18n;
    messagesForm: FormGroup;
    isV2: boolean;
    private destroy$;
    constructor(fb: FormBuilder);
    tx(key: string, fallback: string): string;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private initializeForm;
    private setupFormListeners;
    private updateConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessagesLocalizationEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MessagesLocalizationEditorComponent, "messages-localization-editor", never, { "config": { "alias": "config"; "required": false; }; }, { "configChange": "configChange"; "messagesLocalizationChange": "messagesLocalizationChange"; }, never, never, true, never>;
}

declare const ALWAYS_VISIBLE_LAYOUT_LANES: readonly ["actions", "inline", "grid"];
type AlwaysVisibleLayoutLane = (typeof ALWAYS_VISIBLE_LAYOUT_LANES)[number];
type AlwaysVisibleLayoutItem = {
    name: string;
    label: string;
    lane: AlwaysVisibleLayoutLane;
    controlType: string;
    controlTypeLabel: string;
    hasOverride: boolean;
    widthHint: string;
};
type AlwaysVisibleLayoutViewport = 'desktop' | 'tablet' | 'mobile';
declare const ALWAYS_VISIBLE_SECTION_IDS: readonly ["always-visible-order", "always-visible-metadata", "always-visible-json"];
type AlwaysVisibleSectionId = (typeof ALWAYS_VISIBLE_SECTION_IDS)[number];
declare class FilterSettingsComponent implements OnChanges, AfterViewInit, OnDestroy {
    private fb;
    private readonly hostRef;
    private readonly cdr;
    metadata: FieldMetadata[];
    metadataSource: 'filter-dto' | 'columns';
    metadataLoading: boolean;
    metadataErrorMsg: string;
    settings: FilterConfig | undefined;
    configKey?: string;
    settingsChange: EventEmitter<FilterConfig>;
    form: FormGroup<{
        alwaysVisibleFields: FormControl<string[]>;
        showAdvanced: FormControl<boolean>;
        mode: FormControl<'filter'>;
        changeDebounceMs: FormControl<number>;
        allowSaveTags: FormControl<boolean>;
        tagColor: FormControl<'primary' | 'accent' | 'warn' | 'basic'>;
        tagVariant: FormControl<'filled' | 'outlined'>;
        tagButtonColor: FormControl<'primary' | 'accent' | 'warn' | 'basic'>;
        actionsButtonColor: FormControl<'primary' | 'accent' | 'warn' | 'basic'>;
        actionsVariant: FormControl<'standard' | 'outlined'>;
        useInlineSearchableSelectVariant: FormControl<boolean>;
        useInlineRangeVariant: FormControl<boolean>;
        useInlineDateVariant: FormControl<boolean>;
        useInlineDateRangeVariant: FormControl<boolean>;
        useInlineTimeVariant: FormControl<boolean>;
        useInlineTimeRangeVariant: FormControl<boolean>;
        useInlineTreeSelectVariant: FormControl<boolean>;
        placeBooleansInActions: FormControl<boolean>;
        showToggleLabels: FormControl<boolean>;
        alwaysMinWidth: FormControl<number>;
        alwaysColsMd: FormControl<number>;
        alwaysColsLg: FormControl<number>;
        confirmTagDelete: FormControl<boolean>;
        overlayVariant: FormControl<'card' | 'frosted'>;
        overlayBackdrop: FormControl<boolean>;
        advancedOpenMode: FormControl<'modal' | 'drawer'>;
        advancedClearButtonsEnabled: FormControl<boolean>;
        logLevel: FormControl<'none' | 'error' | 'warn' | 'info' | 'debug'>;
        enablePerformanceMetrics: FormControl<boolean>;
    }>;
    /**
     * Emits true when form has changes and is valid, enabling the save button
     */
    canSave$: Observable<boolean>;
    isDirty$: Observable<boolean>;
    isValid$: Observable<boolean>;
    isBusy$: Observable<boolean>;
    private initialSettings;
    private extraSettings;
    private suppressSettingsEmit;
    private readonly droppedLegacySettingKeys;
    private readonly managedSettingKeys;
    effectiveJson: string;
    settingsJsonText: string;
    jsonErrorMsg: string;
    alwaysVisibleOverridesJsonText: string;
    alwaysVisibleOverridesErrorMsg: string;
    alwaysVisibleFieldSearchText: string;
    previewDarkMode: boolean;
    private readonly tagsTabIndex;
    readonly alwaysVisibleLayoutLanes: readonly ["actions", "inline", "grid"];
    readonly alwaysVisibleViewports: AlwaysVisibleLayoutViewport[];
    orderPreviewViewport: AlwaysVisibleLayoutViewport;
    readonly alwaysVisibleSectionIds: readonly ["always-visible-order", "always-visible-metadata", "always-visible-json"];
    activeAlwaysVisibleSectionId: AlwaysVisibleSectionId;
    private scrollTrackingTarget;
    private cleanupScrollTracking;
    private scrollTrackingRafId;
    readonly layoutPreviewFields: string[];
    private readonly storage;
    private readonly filterConfigService;
    private readonly settingsPanel;
    private readonly snackBar;
    private readonly destroyRef;
    private readonly injectedData;
    /** Clears persisted preferences for this filter, falling back to globals. */
    resetPreferences(): Promise<void>;
    constructor(fb: FormBuilder);
    tags: FilterTag[];
    exportJson: string;
    newTagLabel: string;
    newTagPatchText: string;
    private tagsLoaded;
    private tagsKey;
    private schemaMetaScopeKey;
    private schemaMetaIndexKey;
    private schemaMetaKeyForSchemaId;
    private filterSchemaIgnoreKey;
    private filterSchemaSnoozeKey;
    private filterSchemaNotifiedKey;
    private clearPersistedSchemaStateByConfigKey;
    loadTags(): Promise<void>;
    saveTags(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onTabChange(_event: MatTabChangeEvent): void;
    private ensureTagsLoaded;
    clearTags(): void;
    removeTag(index: number): void;
    renameTag(index: number, value: string): void;
    importTags(): void;
    addTag(): void;
    addTagFromCurrent(): void;
    presets: {
        key: string;
        label: string;
        description: string;
        previewClass: string;
        values: Partial<FilterConfig>;
    }[];
    getContrastWarning(): string | null;
    applyPreset(key: string): void;
    isPresetActive(key: string): boolean;
    hasBooleanFieldMetadata(): boolean;
    getFieldLabel(name: string): string;
    onAlwaysVisibleFieldSearchChange(value: string): void;
    clearAlwaysVisibleFieldSearch(): void;
    filteredAlwaysVisibleMetadata(): FieldMetadata[];
    hasAlwaysVisibleMetadataResults(): boolean;
    trackFieldMetadataByName(_: number, meta: FieldMetadata): string;
    alwaysVisibleSelectionCount(): number;
    activeAlwaysVisibleOverrideCount(): number;
    alwaysVisibleLayoutItems(): AlwaysVisibleLayoutItem[];
    alwaysVisibleLaneItems(lane: AlwaysVisibleLayoutLane): AlwaysVisibleLayoutItem[];
    alwaysVisibleLaneLabel(lane: AlwaysVisibleLayoutLane): string;
    alwaysVisibleLaneDropListId(lane: AlwaysVisibleLayoutLane): string;
    alwaysVisibleLaneHint(lane: AlwaysVisibleLayoutLane): string;
    alwaysVisibleLaneEmptyHint(lane: AlwaysVisibleLayoutLane): string;
    alwaysVisibleViewportLabel(viewport: AlwaysVisibleLayoutViewport): string;
    alwaysVisibleViewportHint(viewport: AlwaysVisibleLayoutViewport): string;
    onAlwaysVisibleViewportChange(value: unknown): void;
    alwaysVisibleViewportWidth(): number;
    trackAlwaysVisibleLayoutItemByName(_: number, item: AlwaysVisibleLayoutItem): string;
    alwaysVisibleLayoutItemAriaLabel(item: AlwaysVisibleLayoutItem, lane: AlwaysVisibleLayoutLane, index: number, total: number): string;
    dropAlwaysVisibleLane(lane: AlwaysVisibleLayoutLane, event: CdkDragDrop<AlwaysVisibleLayoutItem[]>): void;
    allowAlwaysVisibleLaneEnter: (drag: CdkDrag<AlwaysVisibleLayoutItem>, drop: CdkDropList<AlwaysVisibleLayoutItem[]>) => boolean;
    canMoveAlwaysVisibleLane(lane: AlwaysVisibleLayoutLane, fieldName: string, delta: -1 | 1): boolean;
    moveAlwaysVisibleLane(lane: AlwaysVisibleLayoutLane, fieldName: string, delta: -1 | 1): void;
    onAlwaysVisibleLaneItemKeydown(event: KeyboardEvent, lane: AlwaysVisibleLayoutLane, fieldName: string): void;
    private resolveToolbarControlType;
    private resolveAlwaysVisibleLayoutLane;
    private getToolbarControlTypeLabel;
    private resolveAlwaysVisibleWidthHint;
    private getAlwaysVisibleFieldNamesByLane;
    private reorderAlwaysVisibleLane;
    private areFieldNameArraysEqual;
    private extractLaneFromDropListId;
    private isAlwaysVisibleViewport;
    isAlwaysVisibleSectionActive(sectionId: string): boolean;
    onAlwaysVisibleSectionFocus(sectionId: string): void;
    sectionEnterDelay(sectionId: string): string;
    scrollToAlwaysVisibleSection(sectionId: string): void;
    private setupAlwaysVisibleScrollTracking;
    private teardownAlwaysVisibleScrollTracking;
    private scheduleAlwaysVisibleSectionEvaluation;
    private updateActiveAlwaysVisibleSection;
    private getAlwaysVisibleSections;
    private getSectionActivationTop;
    private findNearestScrollableParent;
    private isAlwaysVisibleSectionId;
    private prefersReducedMotion;
    hasAlwaysVisibleOverride(fieldName: string): boolean;
    getAlwaysVisibleControlTypeLabel(fieldName: string): string;
    getAlwaysVisibleOverridePreview(fieldName: string): string;
    clearAlwaysVisibleOverride(fieldName: string): void;
    openAlwaysVisibleMetadataEditor(fieldName: string): Promise<void>;
    private loadMetadataEditorModule;
    private importOptionalModule;
    hasCurrentDto(): boolean;
    private getMetadataByName;
    private getAlwaysVisibleOverridesMap;
    private normalizeControlTypeForEditor;
    private inferControlTypeFromMetadata;
    private resolveAlwaysVisibleControlType;
    private buildAlwaysVisibleEditorSeed;
    private isPlainObject;
    private applyAlwaysVisibleMetadataPatch;
    renameTagPrompt(index: number): void;
    dropTags(event: CdkDragDrop<FilterTag[]>): void;
    ngOnChanges(changes: SimpleChanges): void;
    getSettingsValue(): FilterConfig;
    private updateEffectiveJson;
    private buildFullConfigFromForm;
    onJsonReload(): void;
    onJsonFormat(): void;
    onJsonApply(): void;
    formatAlwaysVisibleOverridesJson(): void;
    applyAlwaysVisibleOverridesJson(): void;
    reset(): void;
    private applyAlwaysVisibleOverridesMap;
    private syncAlwaysVisibleControlState;
    private clampDebounce;
    private cloneFieldNames;
    private applySettingsToForm;
    private refreshAlwaysVisibleOverridesEditor;
    private isAllowedOverrideControlType;
    private normalizeAlwaysVisibleMetadataOverrides;
    private extractExtraSettings;
    private withSuppressedSettingsEmit;
    private cloneUnknown;
    private normalizeAdvancedOpenMode;
    private clampMinWidth;
    private clampColsMd;
    private clampColsLg;
    layoutMinWidth(): number;
    layoutColsFor(breakpoint: 'sm' | 'md' | 'lg'): number;
    layoutControlError(controlName: 'alwaysMinWidth' | 'alwaysColsMd' | 'alwaysColsLg'): string | null;
    normalizeLayoutControl(controlName: 'alwaysMinWidth' | 'alwaysColsMd' | 'alwaysColsLg'): void;
    private markDirtyAndEmit;
    dropAlwaysVisible(event: CdkDragDrop<string[]>): void;
    canMoveAlwaysVisible(index: number, delta: -1 | 1): boolean;
    moveAlwaysVisible(index: number, delta: -1 | 1): void;
    onAlwaysVisibleListItemKeydown(event: KeyboardEvent, index: number): void;
    private normalizeText;
    clearPersistedFilters(): void;
    forceSchemaReload(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSettingsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterSettingsComponent, "filter-settings", never, { "metadata": { "alias": "metadata"; "required": false; }; "metadataSource": { "alias": "metadataSource"; "required": false; }; "metadataLoading": { "alias": "metadataLoading"; "required": false; }; "metadataErrorMsg": { "alias": "metadataErrorMsg"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; "configKey": { "alias": "configKey"; "required": false; }; }, { "settingsChange": "settingsChange"; }, never, never, true, never>;
}

type ColumnDataType = 'string' | 'number' | 'date' | 'boolean' | 'currency' | 'percentage' | 'custom';

type OperatorKey = '==' | '!=' | '<' | '<=' | '>' | '>=' | 'contains' | 'startsWith' | 'endsWith' | 'matches' | 'not matches' | 'in' | 'not in' | 'is empty' | 'is not empty' | 'between' | 'is today' | 'in last' | 'weekday is' | 'is true' | 'is false' | 'contains all' | 'contains any' | 'length ==' | 'length >' | 'length <' | 'jsonPath matches' | 'has key' | 'key ==' | 'id ==' | 'id in' | 'has property';
interface OperatorSpec {
    key: OperatorKey;
    label: string;
    icon?: string;
    description?: string;
}
declare class OperatorsRegistryService {
    /** Returns the list of operator specs supported for a given data type. */
    getForType(type: ColumnDataType | 'enum' | 'array' | 'json' | 'relational'): OperatorSpec[];
    get keys(): OperatorKey[];
    private readonly stringOps;
    private readonly numberOps;
    private readonly dateOps;
    private readonly booleanOps;
    private readonly enumOps;
    private readonly arrayOps;
    private readonly jsonOps;
    private readonly relationalOps;
    static ɵfac: i0.ɵɵFactoryDeclaration<OperatorsRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OperatorsRegistryService>;
}

type GroupOp = 'AND' | 'OR' | 'NOT';
interface RuleAtom {
    field: string;
    operator: string;
    value?: any;
    options?: Record<string, any>;
}
interface RuleGroup {
    op: GroupOp;
    conditions: RuleAtom[];
    groups?: RuleGroup[];
}
type StructuredRuleCondition = JsonLogicExpression | null;
declare class RuleCompilerService {
    compileGroupToJsonLogic(group: RuleGroup): StructuredRuleCondition;
    compileAtomToJsonLogic(atom: RuleAtom): JsonLogicExpression | null;
    private toJsonLogicValue;
    private toList;
    static ɵfac: i0.ɵɵFactoryDeclaration<RuleCompilerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RuleCompilerService>;
}

type RuleItem = Omit<PraxisRuntimeConditionalEffectRule<RuleEffectDefinition>, 'effects'> & {
    surfacePresetRef?: {
        id: string;
        catalogVersion: string;
    };
    cssClass?: string;
    style?: Record<string, string>;
    effects?: RuleEffectDefinition[];
    enabled?: boolean;
};
declare class TableRulesEditorComponent implements OnChanges, OnInit, OnDestroy {
    private cdr;
    private registry;
    private compiler;
    private jsonLogic;
    private dynamicForm;
    private crud?;
    private get jsonLogicValidator();
    private readonly i18n;
    config: TableConfig;
    resourcePath?: string;
    fields?: FieldDefinition[] | null;
    i18nRules?: Partial<Record<string, string>>;
    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
    scope: 'row' | 'column';
    selectedColumnField: string | null;
    draftCondition: string;
    draftCssClass: string;
    draftStyleText: string;
    draftSurfacePresetRef?: {
        id: string;
        catalogVersion: string;
    };
    sanitizedStyle: Record<string, string>;
    manualMode: boolean;
    manualErrors: string[];
    testSummary: string;
    normalizationWarning: string;
    importStatus: {
        type: 'success' | 'warning' | 'error';
        message: string;
    } | null;
    editIndex: number;
    get currentRules(): RuleItem[];
    set currentRules(v: RuleItem[]);
    getRuleTrackKey(rule: RuleItem, index: number): string;
    rulesRow: RuleItem[];
    rulesColumn: RuleItem[];
    objectKeys: {
        (o: object): string[];
        (o: {}): string[];
    };
    dynamicValueForm: FormGroup;
    dynamicValueMetas: FieldMetadata[];
    effectsValue?: RuleEffectDefinition;
    dynamicValueActive: boolean;
    private dynamicValueSub?;
    private testSummaryTimer;
    private readonly legacyStyleAllowList;
    basicFieldType: 'enum' | 'array' | 'json' | 'relational' | 'string' | 'number' | 'date' | 'boolean' | 'currency' | 'percentage' | 'custom';
    noValueOperator: boolean;
    i18nValuePlaceholder: string;
    enumOptions: Array<{
        value: any;
        label: string;
    }>;
    private updateDerivedUiProps;
    /** Enable verbose console logging for debugging value editor behavior */
    debugLogs: boolean;
    debugLevel: 'log' | 'info' | 'debug';
    private dbg;
    /** Log a summary table of field metadata and column info for diagnostics */
    private logFieldMetasContext;
    /** Log a focused view for a single field */
    private logSingleFieldMeta;
    private logFieldChoices;
    t(key: string): string;
    constructor(cdr: ChangeDetectorRef, registry: OperatorsRegistryService, compiler: RuleCompilerService, jsonLogic: PraxisJsonLogicService, dynamicForm: DynamicFormService, crud?: GenericCrudService<any> | undefined);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    get columnFields(): string[];
    getOperatorsForField(fieldName: string | null): string[];
    getFieldDisplayLabel(fieldName: string | null): string;
    onScopeChange(scope: 'row' | 'column'): void;
    onColumnSelect(field: string): void;
    private initFromConfig;
    private loadColumnRules;
    private normalizePersistedRules;
    rebuildCondition(): void;
    onDraftChange(): void;
    applyTextPreset(preset: string): void;
    generateSampleData(): void;
    runTest(): void;
    onRelSearch(ev: any): void;
    clearRelSelection(): void;
    onRelSelectSingle(opt: any): void;
    onRelAddMulti(opt: any): void;
    removeRelMulti(i: number): void;
    private fetchRelOptions;
    private getRelationalConfig;
    validateDraft(): void;
    canCommitDraft(): boolean;
    private toPersistedCellClassAndStyle;
    addOrUpdateRule(): void;
    editRule(index: number): void;
    removeRule(index: number): void;
    duplicateRule(index: number): void;
    onRuleToggle(): void;
    private emitRulesConfigChange;
    buildAppliedConfig(baseConfig?: TableConfig): TableConfig;
    private isGeneratedRendererMatch;
    private stableRendererSignature;
    private stripRulesEditorMarker;
    onApply(): void;
    isValid(): boolean;
    onExportRules(): void;
    onImportRules(): void;
    private sanitizeRule;
    private normalizeSurfacePresetRef;
    private normalizeRuleEffects;
    getPrimaryEffect(r: RuleItem | null | undefined): RuleEffectDefinition | undefined;
    getAnimationLabel(r: RuleItem): string | null;
    private normalizeRendererAnimation;
    private buildRendererOverrideFromRule;
    private buildLegacyRendererOverrideFromRule;
    private buildRowRendererOverrideFromRule;
    private stringifyValue;
    getConditionLabel(condition: RuleItem['condition'] | null | undefined): string;
    private buildPersistedCondition;
    private sanitizePersistedCondition;
    private parseLegacyStyle;
    private normalizeLegacyStyleObject;
    resetDraft(): void;
    private parseManualCondition;
    private tryParseManualCondition;
    private validateManualCondition;
    private getInvalidVarPaths;
    private collectVarPaths;
    private isKnownJsonLogicPath;
    private isManualExpressionCandidate;
    private looksLikeLegacyExpression;
    private toManualValidationMessage;
    basicField: string;
    basicOperator: string;
    basicValue: any;
    basicMin: any;
    basicMax: any;
    basicListCsv: string;
    basicDate: Date | null;
    basicDateStart: Date | null;
    basicDateEnd: Date | null;
    basicEnumValue: string | number | null;
    basicEnumValues: Array<string | number>;
    basicLength: number | null;
    relationalSelected: {
        id: any;
        label: string;
        raw: any;
    } | null;
    relationalSelectedMulti: Array<{
        id: any;
        label: string;
        raw: any;
    }>;
    relationalOptions: Array<{
        id: any;
        label: string;
        raw: any;
    }>;
    basicRelPath: string;
    private relSearchTerm;
    private relCache;
    basicLastN: number | null;
    basicLastUnit: 'days' | 'weeks' | 'months';
    basicWeekdays: number[];
    weekdayOptions: {
        value: number;
        label: string;
    }[];
    basicJsonPath: string;
    basicJsonPattern: string;
    basicJsonKey: string;
    basicJsonExpected: any;
    draftGroup: RuleGroup;
    editAtomIndex: number;
    activeGroupTarget: 'root' | number;
    onEffectsChange(v: RuleEffectDefinition): void;
    private hasRuleEffectsValue;
    getFieldType(fieldName: string | null): 'enum' | 'array' | 'json' | 'relational' | 'string' | 'number' | 'date' | 'boolean' | 'currency' | 'percentage' | 'custom';
    getEnumOptions(fieldName: string | null): Array<{
        value: any;
        label: string;
    }>;
    isNoValueOperator(op: string): boolean;
    getValuePlaceholder(): string;
    getI18nValuePlaceholder(): string;
    private toIsoDateString;
    setManualMode(v: boolean): void;
    onBasicFieldChange(_val: string): void;
    onBasicOperatorChange(_val: string): void;
    private refreshDynamicValueInitialValueOnly;
    refreshDynamicValueHost(): void;
    private buildAtomFromBasic;
    canBuildAtom(): boolean;
    onAddOrUpdateAtom(): void;
    editAtom(index: number): void;
    removeAtom(index: number): void;
    resetAtomEdit(): void;
    private focusAddCondition;
    clearGroup(): void;
    onDropCondition(evt: CdkDragDrop<RuleAtom[]>): void;
    updateDraftFromGroup(): void;
    getAtomPreview(a: RuleAtom): string;
    private stringifyJsonLogicPreview;
    private stringifyJsonLogicInlinePreview;
    addSubgroup(): void;
    removeSubgroup(index: number): void;
    getGroupPreview(g: RuleGroup): string;
    private isNumericFieldType;
    private parseNumericCsv;
    private toFiniteNumber;
    private getActiveGroupRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableRulesEditorComponent, [null, null, null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableRulesEditorComponent, "table-rules-editor", never, { "config": { "alias": "config"; "required": false; }; "resourcePath": { "alias": "resourcePath"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "i18nRules": { "alias": "i18nRules"; "required": false; }; "debugLogs": { "alias": "debugLogs"; "required": false; }; "debugLevel": { "alias": "debugLevel"; "required": false; }; }, { "configChange": "configChange"; }, never, never, true, never>;
}

type ResourcePathIntent = 'set' | 'clear' | 'unchanged';
type EffectiveDataMode = 'remote' | 'local' | 'empty';
declare class PraxisTableConfigEditor implements OnInit, OnDestroy, SettingsValueProvider {
    private cdr;
    private configService;
    private readonly i18n;
    private readonly globalActionCatalogSource;
    private readonly globalActionCatalog;
    filterSettingsEditor?: FilterSettingsComponent;
    behaviorEditor?: BehaviorConfigEditorComponent;
    rulesEditor?: TableRulesEditorComponent;
    set crudEditorSetter(ref: any);
    private crudEditor?;
    private _crudSubscribed;
    sections: {
        id: string;
        label: string;
        icon: string;
    }[];
    activeSectionIndex: number;
    private originalConfig;
    editedConfig: TableConfig;
    resourcePath: string;
    private initialResourcePath;
    idField: string;
    private initialIdField;
    horizontalScroll: 'auto' | 'wrap' | 'none';
    private initialHorizontalScroll;
    crudContext?: {
        tableId: string;
        componentKeyId?: string;
        resourcePath?: string;
        /** Nome do campo identificador do recurso (ex.: 'id', 'codigo'). */
        idField?: string;
        defaults?: {
            openMode?: 'modal' | 'route';
            modal?: Record<string, any>;
            back?: Record<string, any>;
        };
        actions?: Array<{
            action: string;
            label?: string;
            formId?: string;
            route?: string;
            openMode?: 'modal' | 'route';
        }>;
    };
    serverIdField?: string;
    private serverSchemaHash?;
    idFieldDiverges: boolean;
    schemaHashDiverges: boolean;
    schemaSnapshotMissing: boolean;
    isV2Config: boolean;
    canSave: boolean;
    hasErrors: boolean;
    hasSuccess: boolean;
    statusMessage: string;
    private isValidJson;
    private behaviorFeedbackBurstTypes;
    isDirty$: BehaviorSubject<boolean>;
    isValid$: BehaviorSubject<boolean>;
    isBusy$: BehaviorSubject<boolean>;
    columnMetas: FieldMetadata[];
    filterDtoMetas: FieldMetadata[];
    filterDtoMetasLoading: boolean;
    filterDtoMetasErrorMsg: string;
    private hasCrudOverridesDirty;
    private hasLocalDataInput;
    private filterDtoLoadSeq;
    private lastKnownFilterSettings;
    private globalActionValidationIssues;
    private readonly panelData;
    private readonly crudService;
    private readonly panelRef;
    constructor(cdr: ChangeDetectorRef, configService: TableConfigService);
    tx(key: string, fallback: string): string;
    private normalizeSearchText;
    private isDebugLoggingEnabled;
    private debugLog;
    ngOnInit(): void;
    onJsonConfigChange(newValue: TableConfig | TableAuthoringDocument): void;
    onJsonValidationChange(result: JsonValidationResult): void;
    onJsonEditorEvent(event: JsonEditorEvent): void;
    buildJsonAuthoringDocument(): TableAuthoringDocument;
    onColumnsConfigChange(newConfig: TableConfig): void;
    onColumnChange(change: ColumnChange): void;
    onFilterSettingsChange(cfg: FilterConfig): void;
    private cloneFilterSettings;
    private isEffectivelyEmptyFilterSettings;
    getFilterSettingsMetas(): FieldMetadata[];
    getColumnAuthoringMetas(): FieldMetadata[];
    get filteredIdFieldOptions(): FieldMetadata[];
    isUsingFilterDtoMetas(): boolean;
    getEffectiveDataMode(): EffectiveDataMode;
    isEffectiveLocalMode(): boolean;
    private resolveLocalDataModeFeatureEnabled;
    private enforceEffectiveModeStrategyConstraints;
    onRulesConfigChange(newCfg: TableConfig): void;
    private updateColumnMetas;
    private updateCanSaveState;
    private collectGlobalActionValidationIssues;
    private findGlobalActionCatalogEntry;
    private buildGlobalActionCatalog;
    private subscribeCrudEditorChanges;
    private showSuccess;
    private showError;
    private clearMessages;
    /**
     * Normaliza uma configuração de tabela para comparação consistente
     * Remove propriedades undefined, ordena arrays e objetos de forma consistente
     */
    private withCanonicalIdField;
    private normalizeTableConfig;
    /**
     * Realiza comparação profunda de objetos, ignorando ordem de propriedades
     */
    private deepEqual;
    getSettingsValue(): any;
    private syncRulesFromEditor;
    private syncFilterSettingsFromEditor;
    private hasAdvancedSettingsProperty;
    private syncLastKnownFilterSettingsFromEditedConfig;
    onResourcePathChange(val: string): void;
    private loadFilterDtoMetas;
    onIdFieldChange(val: string): void;
    onIdFieldOptionSelected(value: string): void;
    onHorizontalScrollChange(val: 'auto' | 'wrap' | 'none'): void;
    onReconcileIdField(): void;
    onAcceptServerHash(): void;
    reset(): void;
    onResetToDefaults(): void;
    /**
     * Called by the settings panel when the user chooses to persist changes.
     *
     * The returned configuration is sent back to the panel via
     * `panelRef.save(returnedConfig)` and subsequently emitted on `saved$`.
     * Returning the current `TableConfig` is therefore required for the table to
     * apply the new settings.
     */
    onSave(): any;
    /**
     * Atualiza as flags de versão baseado na configuração atual
     * Esta versão pode modificar a configuração, deve ser usada após mudanças
     */
    private updateConfigurationVersion;
    /**
     * Apenas detecta a versão da configuração sem modificá-la
     * Usado durante inicialização para evitar marcar como dirty
     */
    private updateConfigurationVersionInfo;
    /**
     * Retorna a configuração atual (unified architecture)
     */
    getV1Config(): TableConfig;
    /**
     * Legacy migration handler. In the unified architecture this is a no-op
     * and simply refreshes the configuration version information.
     */
    onMigrateToV2(): void;
    /**
     * Verifica se um recurso está disponível na versão atual
     */
    isFeatureAvailable(feature: string): boolean;
    onBehaviorConfigChange(newConfig: TableConfig): void;
    onBehaviorChange(change: BehaviorConfigChange): void;
    private shouldSuppressBehaviorFeedback;
    onToolbarActionsConfigChange(newConfig: TableConfig): void;
    onToolbarActionsChange(change: ToolbarActionsChange): void;
    onMessagesLocalizationConfigChange(newConfig: TableConfig): void;
    onMessagesLocalizationChange(change: MessagesLocalizationChange): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisTableConfigEditor, never>;
    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;
    context: Record<string, unknown>;
    private editorBaseline?;
    tableEditor?: PraxisTableConfigEditor;
    readonly isDirty$: BehaviorSubject<boolean>;
    readonly isValid$: BehaviorSubject<boolean>;
    readonly isBusy$: BehaviorSubject<boolean>;
    private readonly cdr;
    private readonly subscription;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    getSettingsValue(): PraxisTableWidgetEditorValue;
    onSave(): PraxisTableWidgetEditorValue;
    reset(): void;
    private initializeChildEditor;
    private tryInject;
    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; }; "context": { "alias": "context"; "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, AfterViewInit, OnDestroy {
    widgetKey?: string;
    resourceEditor?: ResourceQuickConnectComponent;
    private readonly crud;
    private readonly cdr;
    private readonly i18n;
    resourceError: boolean;
    private loadedResourcePath?;
    private resourceDirty;
    private settingsDirty;
    private loadingResource;
    private fieldRequest;
    tx(key: string): string;
    ngAfterViewInit(): void;
    loadResourceFields(markDirty?: boolean): Promise<void>;
    private optionalInject;
    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;
    columnType: ColumnDataType$1;
    currentFormat: string;
    formatChange: EventEmitter<string>;
    datePresets: FormatPreset[];
    numberPresets: FormatPreset[];
    currencyPresets: FormatPreset[];
    percentagePresets: FormatPreset[];
    stringPresets: FormatPreset[];
    booleanPresets: FormatPreset[];
    selectedPreset: string;
    customFormat: string;
    decimalMode: string;
    variableRange: string;
    thousandsSeparator: boolean;
    currencyCode: string;
    currencyDecimals: string;
    currencySymbol: boolean;
    currencyThousands: boolean;
    percentageDecimals: string;
    percentageMultiplier: boolean;
    stringTransform: string;
    maskFormat: string;
    enableTruncate: boolean;
    truncateLength: number;
    truncateSuffix: string;
    booleanDisplay: string;
    customTrueValue: string;
    customFalseValue: string;
    previewValue: string;
    constructor(cdr: ChangeDetectorRef, formattingService: DataFormattingService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    getTypeIcon(): string;
    getTypeLabel(): string;
    getTypeDescription(): string;
    private parseCurrentFormat;
    private setDefaultValues;
    private parseDateFormat;
    private parseNumberFormat;
    private parseCurrencyFormat;
    private parsePercentageFormat;
    private parseStringFormat;
    private parseBooleanFormat;
    onPresetChange(): void;
    onCustomFormatChange(): void;
    onDecimalModeChange(): void;
    onFormatOptionChange(): void;
    onTruncateToggle(): void;
    onBooleanDisplayChange(): void;
    onMaskChange(mask: string): void;
    private generateFormatString;
    private generatePreview;
    /**
     * Get appropriate sample value for each data type
     */
    private getSampleValue;
    /**
     * Get the current format string based on component state
     */
    private getCurrentFormatString;
    private isMaskFormat;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataFormatterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DataFormatterComponent, "data-formatter", never, { "columnType": { "alias": "columnType"; "required": false; }; "currentFormat": { "alias": "currentFormat"; "required": false; }; }, { "formatChange": "formatChange"; }, never, never, true, never>;
}

interface AnalyticsTableConfigAdapterOptions {
    title?: PraxisTextValue;
    subtitle?: PraxisTextValue;
}
declare class AnalyticsTableConfigAdapterService {
    private readonly i18n?;
    constructor(i18n?: PraxisI18nService | undefined);
    toTableConfig(projection: PraxisAnalyticsProjection, options?: AnalyticsTableConfigAdapterOptions): TableConfig;
    private buildColumns;
    private buildComparisonMetricColumns;
    private comparisonValueLabel;
    private getDisplayMetrics;
    private resolveTextValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsTableConfigAdapterService, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsTableConfigAdapterService>;
}

declare class AnalyticsTableContractService {
    private readonly analyticsSchema;
    private readonly resolver;
    private readonly configAdapter;
    private readonly statsApi;
    constructor(analyticsSchema: AnalyticsSchemaContractService, resolver: AnalyticsPresentationResolver, configAdapter: AnalyticsTableConfigAdapterService, statsApi: AnalyticsTableStatsApiService);
    buildBootstrapTableViews<TKey extends string>(definitions: readonly AnalyticsTableContractDefinition<TKey>[]): Record<TKey, AnalyticsTableViewModel>;
    loadTableViews<TKey extends string>(definitions: readonly AnalyticsTableContractDefinition<TKey>[], options?: AnalyticsTableContractLoadOptions<TKey>): Promise<AnalyticsTableContractLoadResult<TKey>>;
    private loadSingleTableView;
    private buildTableView;
    private assertAnalyticTableProjection;
    private resolveQueryContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<AnalyticsTableContractService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AnalyticsTableContractService>;
}

type TableRichContentP0Node = RichPresenterNode | RichComposeNode;
declare function isTableRendererSupportedByRichContentP0(renderer?: ColumnDefinition['renderer'] | null): boolean;
declare function mapTableRendererToRichContentP0(renderer?: ColumnDefinition['renderer'] | null): TableRichContentP0Node | null;

declare function createTableAuthoringDocument(source: {
    config?: unknown;
    bindings?: unknown;
}): TableAuthoringDocument;
declare function parseLegacyOrTableDocument(raw: unknown): TableAuthoringDocument;
declare function normalizeTableAuthoringDocument(doc: TableAuthoringDocument): TableAuthoringDocument;
declare function validateTableAuthoringDocument(doc: TableAuthoringDocument, context?: TableValidationContext): EditorDiagnostic[];
declare function toCanonicalTableConfig(doc: TableAuthoringDocument, context?: TableProjectionContext): TableConfig;
declare function buildTableApplyPlan(doc: TableAuthoringDocument, runtime?: TableRuntimeContext, options?: {
    saveConfig?: boolean;
    saveBindings?: boolean;
    attachServerMeta?: boolean;
}): 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.2.5
 * @status COMPLIANT - Alinhado com o contrato v2 e TableConfig canônico.
 */
declare const PRAXIS_TABLE_AUTHORING_MANIFEST: ComponentAuthoringManifest;

/**
 * Governed authoring contract for the standalone Praxis Filter widget.
 *
 * The document is the existing FilterConfig itself. TableConfig and
 * behavior.filtering.advancedFilters remain owned by the praxis-table manifest.
 */
declare const PRAXIS_FILTER_AUTHORING_MANIFEST: ComponentAuthoringManifest;

declare class PraxisTableInlineAuthoringEditorComponent implements OnChanges {
    private readonly i18n;
    config: TableConfig;
    readonly: boolean;
    configChange: EventEmitter<_praxisui_core.TableConfigModern>;
    workingConfig: TableConfig;
    toolbarTitle: string;
    toolbarSubtitle: string;
    toolbarIcon: string;
    toolbarTextAlign: 'start' | 'center' | 'end';
    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;
    pageSize: number;
    pageSizeOptionsText: string;
    showFirstLastButtons: boolean;
    paginationStrategy: 'client' | 'server';
    paginationPosition: 'top' | 'bottom' | 'both';
    paginationStyle: 'default' | 'simple' | 'advanced' | 'compact';
    sortingEnabled: boolean;
    sortingStrategy: 'client' | 'server';
    allowClearSort: boolean;
    defaultSortField: string;
    defaultSortDirection: 'asc' | 'desc';
    loadingMessage: string;
    emptyMessage: string;
    noResultsMessage: string;
    errorMessage: string;
    loadingMoreMessage: string;
    private lastInputSignature;
    constructor(i18n: PraxisI18nService);
    ngOnChanges(): void;
    setToolbarTitle(value: string): void;
    setToolbarSubtitle(value: string): void;
    setToolbarIcon(value: string): void;
    setToolbarTextAlign(value: 'start' | 'center' | 'end'): void;
    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;
    setPaginationPageSize(value: number | string): void;
    setPaginationPageSizeOptions(value: string): void;
    setPaginationShowFirstLastButtons(value: boolean): void;
    setPaginationStrategy(value: 'client' | 'server'): void;
    setPaginationPosition(value: 'top' | 'bottom' | 'both'): void;
    setPaginationStyle(value: 'default' | 'simple' | 'advanced' | 'compact'): void;
    setSortingEnabled(value: boolean): void;
    setSortingStrategy(value: 'client' | 'server'): void;
    setSortingAllowClear(value: boolean): void;
    setSortingDefaultField(value: string): void;
    setSortingDefaultDirection(value: 'asc' | 'desc'): void;
    setStateMessage(key: 'loading' | 'empty' | 'noResults' | 'error', value: string): void;
    onColumnsConfigChange(config: TableConfig): void;
    columnCountLabel(): string;
    toolbarSummary(): string;
    densitySummary(): string;
    actionsPositionSummary(): string;
    behaviorSummary(): string;
    statesSummary(): string;
    columnsPreviewSummary(): string;
    private normalizeToolbarTextAlign;
    private normalizeToolbarIcon;
    serializedConfig(): string;
    tx(key: string, fallback: string): string;
    private emitConfig;
    private patchToolbar;
    private patchToolbarAppearance;
    private patchBehavior;
    private patchPagination;
    private patchSorting;
    private patchMessages;
    private arrayToString;
    private parseNumberList;
    private buildDefaultSort;
    private getDefaultSortField;
    private getDefaultSortDirection;
    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisTableInlineAuthoringEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisTableInlineAuthoringEditorComponent, "praxis-table-inline-authoring-editor", never, { "config": { "alias": "config"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "configChange": "configChange"; }, never, never, true, never>;
}

interface ValueMappingPair {
    key: string | number | boolean;
    value: string;
    keyInput: string;
    hasError?: boolean;
    errorMessage?: string;
}
declare class ValueMappingEditorComponent implements OnInit, OnChanges {
    private cdr;
    private dialog;
    private snackBar;
    currentMapping: {
        [key: string | number]: string;
    };
    keyInputType: 'text' | 'number' | 'boolean';
    labelKey: string;
    labelValue: string;
    mappingChange: EventEmitter<{
        [key: string]: string;
        [key: number]: string;
    }>;
    mappingPairs: ValueMappingPair[];
    dataSource: MatTableDataSource<ValueMappingPair, _angular_material_paginator.MatPaginator>;
    displayedColumns: string[];
    showImportDialog: boolean;
    importJsonText: string;
    importError: string;
    constructor(cdr: ChangeDetectorRef, dialog: MatDialog, snackBar: MatSnackBar);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private initializeMappingPairs;
    private updateDataSource;
    private parseKeyByType;
    isKeyTruthy(pair: ValueMappingPair): boolean;
    getKeyPlaceholder(): string;
    addNewPair(): void;
    removePair(index: number): void;
    onKeyChange(index: number, value: string): void;
    onBooleanKeyChange(index: number, change: MatCheckboxChange): void;
    onValueChange(index: number, value: string): void;
    private validateAndEmitMapping;
    exportToJson(): void;
    importFromJson(): void;
    cancelImport(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ValueMappingEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ValueMappingEditorComponent, "value-mapping-editor", never, { "currentMapping": { "alias": "currentMapping"; "required": false; }; "keyInputType": { "alias": "keyInputType"; "required": false; }; "labelKey": { "alias": "labelKey"; "required": false; }; "labelValue": { "alias": "labelValue"; "required": false; }; }, { "mappingChange": "mappingChange"; }, never, never, true, never>;
}

declare class FormulaGeneratorService {
    /**
     * Generates a safe JavaScript expression from a formula definition
     */
    generateExpression(formula: FormulaDefinition): string;
    /**
     * Validates a formula definition
     */
    validateFormula(formula: FormulaDefinition): {
        valid: boolean;
        errors: string[];
    };
    private generateConcatenationExpression;
    private generateArithmeticExpression;
    private generateNestedPropertyExpression;
    private generateConditionalMappingExpression;
    private generateDefaultValueExpression;
    private validateConcatenationParams;
    private validateArithmeticParams;
    private validateNestedPropertyParams;
    private validateConditionalMappingParams;
    private validateDefaultValueParams;
    private sanitizeFieldName;
    private sanitizeStringValue;
    private sanitizeValue;
    private sanitizeOperator;
    private parseOperand;
    private generateSafePropertyPath;
    private isValidPropertyPath;
    /**
     * Get a sample data object for testing formulas
     */
    getSampleData(): any;
    /**
     * Test a formula with sample data
     */
    testFormula(formula: FormulaDefinition, sampleData?: any): {
        success: boolean;
        result?: any;
        error?: string;
    };
    private evaluateFormula;
    private evaluateConcatenation;
    private evaluateArithmetic;
    private evaluateNestedProperty;
    private evaluateConditionalMapping;
    private evaluateDefaultValue;
    private compareValues;
    private resolveOperand;
    private resolveFieldValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormulaGeneratorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FormulaGeneratorService>;
}

declare class VisualFormulaBuilderComponent implements OnInit, OnChanges {
    private formulaGenerator;
    private cdr;
    availableDataSchema: FieldSchema[];
    currentFormula?: FormulaDefinition;
    formulaChange: EventEmitter<FormulaDefinition>;
    generatedExpressionChange: EventEmitter<string>;
    formulaTemplates: FormulaTemplate[];
    selectedFormulaType: FormulaType;
    selectedTemplate?: FormulaTemplate;
    currentParams: any;
    generatedExpressionValue: string;
    validationErrors: string[];
    valueInputStates: {
        [key: string]: {
            mode: 'field' | 'literal';
            value: any;
        };
    };
    showSampleData: boolean;
    testResult?: {
        success: boolean;
        result?: any;
        error?: string;
    };
    sampleDataJson: string;
    constructor(formulaGenerator: FormulaGeneratorService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private initializeFromCurrentFormula;
    onFormulaTypeChange(formulaType: FormulaType): void;
    private updateSelectedTemplate;
    onParameterChange(): void;
    private generateAndEmitExpression;
    get generatedExpression(): string;
    isMultiSelectField(paramKey: string): boolean;
    getFieldTypeIcon(fieldType: string): string;
    testFormula(): void;
    formatTestResult(result: any): string;
    getValueInputMode(paramKey: string): 'field' | 'literal';
    getValueInputValue(paramKey: string): any;
    onValueInputModeChange(paramKey: string, mode: 'field' | 'literal'): void;
    onValueInputFieldChange(paramKey: string, fieldName: string): void;
    onValueInputLiteralChange(paramKey: string, value: string): void;
    onValueInputBooleanChange(paramKey: string, change: MatCheckboxChange): void;
    private updateParameterFromValueInput;
    private initializeValueInputStates;
    static ɵfac: i0.ɵɵFactoryDeclaration<VisualFormulaBuilderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VisualFormulaBuilderComponent, "visual-formula-builder", never, { "availableDataSchema": { "alias": "availableDataSchema"; "required": false; }; "currentFormula": { "alias": "currentFormula"; "required": false; }; }, { "formulaChange": "formulaChange"; "generatedExpressionChange": "generatedExpressionChange"; }, never, never, true, never>;
}

/** Metadata for PraxisTable component */
declare const PRAXIS_TABLE_COMPONENT_METADATA: ComponentDocMeta;
/**
 * Provider que registra o metadata no ComponentMetadataRegistry durante o bootstrap.
 */
declare function providePraxisTableMetadata(): Provider;

/**
 * Catálogo de capacidades do TableConfig v2 para uso da IA.
 * Focado em paths permitidos, enums e flags críticas para validação de patches.
 */

declare module '@praxisui/core' {
    interface AiCapabilityCategoryMap {
        meta: true;
        columns: true;
        renderer: true;
        conditional: true;
        mapping: true;
        format: true;
        filtering: true;
        sorting: true;
        selection: true;
        pagination: true;
        interaction: true;
        toolbar: true;
        actions: true;
        export: true;
        runtime: true;
        performance: true;
        messages: true;
        localization: true;
    }
}
type CapabilityCategory$1 = AiCapabilityCategory;
type ValueKind$1 = AiValueKind;
interface Capability$1 extends AiCapability {
    /** Path com [] para arrays (ex.: columns[].renderer.type) */
    path: string;
    category: CapabilityCategory$1;
    valueKind: ValueKind$1;
    allowedValues?: Array<string | number>;
    description?: string;
    critical?: boolean;
    intentExamples?: string[];
    dependsOn?: string;
    example?: string;
    safetyNotes?: string;
}
interface CapabilityCatalog$1 extends AiCapabilityCatalog {
    capabilities: Capability$1[];
}
declare const ENUMS: Record<string, string[]>;
declare const TABLE_AI_CAPABILITIES: CapabilityCatalog$1;
/**
 * Agrupamentos lógicos de tarefas para facilitar a injeção de contexto no prompt da IA.
 * A IA pode receber apenas o grupo relevante para a intenção do usuário.
 */
declare const TASK_PRESETS: {
    'visual-refresh': string[];
    'data-analysis': string[];
    'interaction-setup': string[];
    'expansion-detail': string[];
    'export-governance': string[];
    'layout-structure': string[];
};
declare function getTableCapabilities(): Capability$1[];
declare function getEnum(name: keyof typeof ENUMS): string[];

/**
 * Component-level capabilities for PraxisTable.
 * Paths assume a wrapper shape: { inputs: {...}, outputs: {...} }.
 */

declare module '@praxisui/core' {
    interface AiCapabilityCategoryMap {
        inputs: true;
        outputs: true;
    }
}
type CapabilityCategory = AiCapabilityCategory;
type ValueKind = AiValueKind;
interface Capability extends AiCapability {
    category: CapabilityCategory;
}
interface CapabilityCatalog extends AiCapabilityCatalog {
    capabilities: Capability[];
}
declare const TABLE_COMPONENT_AI_CAPABILITIES: CapabilityCatalog;

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' | 'row.styleRule.update' | '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;
    surfacePresetRef?: 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", "plain"];
                };
                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 surfacePresetRef: 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 surfacePresetRef: {
                                    readonly type: "object";
                                    readonly additionalProperties: false;
                                    readonly required: readonly ["id", "catalogVersion"];
                                    readonly properties: {
                                        readonly id: {
                                            readonly enum: readonly ["success", "warning", "danger", "highlight"];
                                        };
                                        readonly catalogVersion: {
                                            readonly const: "0.2.0";
                                        };
                                    };
                                };
                                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 ["surfacePresetRef"];
                            }, {
                                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 { ANALYTICS_TABLE_ROW_KEY_FIELD, 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_AUTHORING_MANIFEST, PRAXIS_FILTER_COMPONENT_METADATA, PRAXIS_FILTER_VIEW_CONTEXT_SCHEMA_VERSION, PRAXIS_TABLE_AUTHORING_MANIFEST, PRAXIS_TABLE_COMPONENT_METADATA, PRAXIS_TABLE_TOOLBAR_APPEARANCE_PRESETS, 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, analyticsComparisonMetricField, buildTableApplyPlan, coerceTableComponentEditPlan, coerceTableComponentEditPlans, compileTableComponentEditPlan, compileTableComponentEditPlans, createTableAuthoringDocument, getActionId, getEnum, getTableCapabilities, getTableComponentEditPlanCapabilities, isTableRendererSupportedByRichContentP0, mapTableRendererToRichContentP0, normalizeTableAuthoringDocument, parseLegacyOrTableDocument, providePraxisFilterMetadata, providePraxisTableMetadata, providePraxisTableToolbarAppearance, serializeTableAuthoringDocument, toCanonicalTableConfig, validateTableAuthoringDocument };
export type { ActionLike, AnalyticsComparisonMetricValueKind, 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, PraxisFilterViewContext, PraxisFilterViewField, 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, TableConfigPersistenceStrategy, TableHorizontalScroll, TableProjectionContext, TableRichContentP0Node, TableRuntimeContext, TableValidationContext, ToolbarAction, ToolbarActionsChange, ValueKind$1 as ValueKind, ValueMappingPair };