@acorex/platform 21.0.0-next.3 → 21.0.0-next.34

package/types/acorex-platform-layout-components.d.ts

@@ -0,0 +1,2927 @@
+import * as _angular_core from '@angular/core';
+import { Signal, InjectionToken, InputSignal, TemplateRef, ElementRef, OnDestroy, OnInit, Type, QueryList, OnChanges, EventEmitter, WritableSignal } from '@angular/core';
+import { AXPActivityLog, AXPSystemActionType, AXPCategoryEntity, AXPColumnQuery, AXPContextData, AXPFilterClause, AXPFilterDefinition, AXPFilterQuery, AXPContextChangeEvent, AXPSortDefinition, AXPSortQuery, AXPMetaData, AXPViewQuery, AXPMultiLanguageString, AXPActionMenuItem, AXPExecuteCommand, AXPExecuteCommandResult, containsHtmlMarkup } from '@acorex/platform/core';
+import { AXPMenuItem } from '@acorex/platform/common';
+import { AXValueChangedEvent, AXClickEvent, AXDataSource, AXDataSourceFilterOption, AXDataSourceOperator, AXFilterLogic, AXHtmlEvent, AXEvent, AXRange } from '@acorex/cdk/common';
+import { AXTreeViewLegacyComponent, AXTreeItemClickBaseEventLegacy } from '@acorex/components/tree-view-legacy';
+import { AXPopoverComponent } from '@acorex/components/popover';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as _acorex_platform_layout_widget_core from '@acorex/platform/layout/widget-core';
+import { AXPWidgetNode, AXPWidgetRendererDirective, AXPWidgetProperty, AXPWidgetConfig } from '@acorex/platform/layout/widget-core';
+import { AXDataTableComponent, AXDataTableRowDbClick, AXDataTableRowClick } from '@acorex/components/data-table';
+import { AXBasePageComponent } from '@acorex/components/page';
+import { AXDropListDroppedEvent } from '@acorex/cdk/drag-drop';
+import { AXTagBoxComponent } from '@acorex/components/tag-box';
+import { AXCalendarService } from '@acorex/core/date-time';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXFormComponent } from '@acorex/components/form';
+import { AXTreeViewNode, AXTreeViewDragBehavior, AXTreeViewDragArea, AXTreeViewComponent, AXTreeViewBeforeDropEvent, AXTreeViewDropEvent } from '@acorex/components/tree-view';
+import { AXTabStripChangedEvent, AXTabsComponent } from '@acorex/components/tabs';
+import { AXValidationSummary } from '@acorex/core/validation';
+import { AXPopupSizeType, AXPopupService } from '@acorex/components/popup';
+import { Observable, Subject } from 'rxjs';
+import { AXSelectBoxComponent } from '@acorex/components/select-box';
+import { AXContextMenuOpeningEvent, AXContextMenuItemsClickEvent } from '@acorex/components/menu';
+import { AXSchedulerComponent, AXSchedulerView, AXSchedulerResource, AXSchedulerAppointment, AXSchedulerDateRange } from '@acorex/components/scheduler';
+import * as _acorex_platform_layout_components from '@acorex/platform/layout/components';
+
+declare class AXPActivityLogComponent {
+    private readonly translateService;
+    private readonly workflowService;
+    /**
+     * Array of activity logs to display
+     */
+    activities: _angular_core.InputSignal<AXPActivityLog[]>;
+    /**
+     * Whether the component is in loading state
+     */
+    loading: _angular_core.InputSignal<boolean>;
+    protected readonly i18nScope = "activity-log";
+    protected readonly Object: ObjectConstructor;
+    /**
+     * Set of expanded activity IDs
+     */
+    private expandedItems;
+    /**
+     * Flag to track if component has been initialized
+     */
+    private isInitialized;
+    /**
+     * Set of items that have been manually toggled (for animation control)
+     */
+    private manuallyToggledItems;
+    constructor();
+    /**
+     * Gets the appropriate CSS class for the change type
+     */
+    protected getChangeClasses(changeType: AXPSystemActionType): {
+        surface: string;
+        text: string;
+        icon: string;
+    };
+    /**
+ * Checks if an activity item is expanded
+ */
+    protected isExpanded(activityId: string): boolean;
+    /**
+ * Toggles the expanded state of an activity item
+ */
+    protected toggleExpanded(activityId: string): void;
+    /**
+     * Checks if an item should have expand/collapse animation
+     */
+    protected shouldAnimate(activityId: string): boolean;
+    /**
+     * Checks if an activity has expandable content (changes)
+     */
+    protected hasExpandableContent(activity: AXPActivityLog): boolean;
+    /**
+     * Handles the compare action for an activity
+     */
+    protected handleCompare(activity: AXPActivityLog, event: Event): Promise<void>;
+    /**
+     * Checks if an activity can be compared (has a previous version)
+     */
+    protected canCompare(activity: AXPActivityLog): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPActivityLogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPActivityLogComponent, "axp-activity-log", never, { "activities": { "alias": "activities"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AXPTaskBadgeService {
+    private badgeMap;
+    private providers;
+    private computedCache;
+    constructor();
+    getCount(key: string): Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTaskBadgeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTaskBadgeService>;
+}
+
+declare const AXP_TASK_BADGE_PROVIDERS: InjectionToken<AXPTaskBadgeProvider[]>;
+declare abstract class AXPTaskBadgeProvider {
+    abstract key: string;
+    abstract count: Signal<number>;
+}
+
+declare class AXPTaskBadgeDirective {
+    #private;
+    private badgeService;
+    private host;
+    private hostElement;
+    badgeKey: InputSignal<string | undefined>;
+    count: InputSignal<number>;
+    private readonly displayCount;
+    private setValueOfInputSignal;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTaskBadgeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXPTaskBadgeDirective, "[axp-task-badge]", never, { "badgeKey": { "alias": "badgeKey"; "required": false; "isSignal": true; }; "count": { "alias": "axp-task-badge"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AXPMenuBadgeHelper {
+    private static cache;
+    static getTotalCount(item: AXPMenuItem, badgeService: AXPTaskBadgeService): Signal<number>;
+}
+
+declare class AXPThemeLayoutPagePrimaryActionsComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutPagePrimaryActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutPagePrimaryActionsComponent, "axp-layout-actions-primary", never, {}, {}, never, ["ax-button,ax-dropdown-button"], true, never>;
+}
+declare class AXPThemeLayoutPageSecondaryActionsComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutPageSecondaryActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutPageSecondaryActionsComponent, "axp-layout-actions-secondary", never, {}, {}, never, ["ax-button-item,ax-divider,ng-container"], true, never>;
+}
+declare class AXPThemeLayoutActionsComponent {
+    readonly primaryTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    private readonly primaryContent;
+    hasPrimary: _angular_core.Signal<boolean>;
+    readonly secondaryTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    private readonly secondaryContent;
+    hasSecondary: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutActionsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutActionsComponent, "axp-layout-actions", never, {}, {}, ["primaryContent", "secondaryContent"], ["axp-layout-actions-primary", "axp-layout-actions-secondary", "*"], true, never>;
+}
+
+declare class AXPThemeLayoutBlockComponent {
+    protected readonly elementRef: ElementRef<any>;
+    readonly hostElement: any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutBlockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutBlockComponent, "    axp-page-content,     axp-page-footer-container,    axp-page-footer,    axp-page-header,    axp-page-header-container,    axp-page-toolbar,    axp-layout-content,     axp-layout-page-content,     axp-layout-sections,    axp-layout-body,    axp-layout-page-body,    axp-layout-prefix,    axp-layout-suffix,    axp-layout-title-bar,    axp-layout-title,     axp-layout-title-actions,     axp-layout-nav-button,     axp-layout-description,     axp-layout-breadcrumbs,    axp-layout-list-action,    ", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class AXPThemeLayoutFooterComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutFooterComponent, "axp-layout-footer, axp-layout-page-footer", never, {}, {}, never, ["axp-layout-prefix", "*", "axp-layout-suffix"], true, never>;
+}
+
+declare class AXPThemeLayoutPageHeaderComponent {
+    readonly title: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly description: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly actions: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly navbar: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly breadcrumbs: _angular_core.Signal<TemplateRef<any> | undefined>;
+    readonly navButton: _angular_core.Signal<TemplateRef<any> | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutPageHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutPageHeaderComponent, "axp-layout-page-header", never, {}, {}, never, ["axp-layout-breadcrumbs", "axp-layout-toolbar", "axp-layout-actions", "axp-layout-description", "axp-layout-title", "axp-layout-nav-button"], true, never>;
+}
+declare class AXPThemeLayoutHeaderComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutHeaderComponent, "axp-layout-header", never, {}, {}, never, ["axp-layout-prefix", "*", "axp-layout-suffix"], true, never>;
+}
+
+declare class AXPThemeLayoutListComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutListComponent, "axp-layout-list", never, {}, {}, never, ["axp-layout-list-item,axp-layout-list-group,ng-container"], true, never>;
+}
+declare class AXPThemeLayoutListItemsGroupComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutListItemsGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutListItemsGroupComponent, "axp-layout-list-group", never, {}, {}, never, ["axp-layout-list-item, axp-layout-title, axp-layout-header ,ng-container"], true, never>;
+}
+declare class AXPThemeLayoutListItemComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutListItemComponent, "axp-layout-list-item", never, {}, {}, never, ["axp-layout-content,axp-layout-prefix,axp-layout-suffix,ng-container"], true, never>;
+}
+
+declare class AXPThemeLayoutSectionComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutSectionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutSectionComponent, "axp-layout-section", never, {}, {}, never, ["axp-layout-header", "axp-layout-content"], true, never>;
+}
+
+declare class AXPThemeLayoutStartSideComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutStartSideComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutStartSideComponent, "axp-layout-page-start-side, axp-layout-start-side", never, {}, {}, never, ["axp-layout-header", "axp-layout-content", "axp-layout-footer", "*"], true, never>;
+}
+declare class AXPThemeLayoutEndSideComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutEndSideComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutEndSideComponent, "axp-layout-page-end-side, axp-layout-end-side", never, {}, {}, never, ["axp-layout-header", "axp-layout-content", "axp-layout-footer"], true, never>;
+}
+
+declare class AXPThemeLayoutToolbarComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutToolbarComponent, "axp-layout-toolbar", never, {}, {}, never, ["axp-layout-prefix", "axp-layout-suffix", "*"], true, never>;
+}
+
+declare class AXPThemeLayoutContainerComponent {
+    protected readonly elementRef: ElementRef<HTMLDivElement>;
+    readonly hostElement: HTMLDivElement;
+    private _isEmptySignal;
+    readonly isEmpty: Signal<boolean>;
+    private mutationObserver?;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPThemeLayoutContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPThemeLayoutContainerComponent, "axp-layout-container", never, {}, {}, never, ["*"], true, never>;
+}
+
+interface AXPCategoryTreeNode extends AXPCategoryEntity {
+    children?: AXPCategoryTreeNode[];
+    expand?: boolean;
+    hasChild?: boolean;
+    [key: string]: any;
+}
+interface AXPCategoryTreeConfig {
+    textField?: string;
+    valueField?: string;
+    expandedField?: string;
+    showCheckbox?: boolean;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    emptyStateTitle?: string;
+    emptyStateDescription?: string;
+    emptyStateIcon?: string;
+}
+interface AXPCategoryTreeEvents {
+    onNodeClick?: (node: AXPCategoryEntity) => void;
+    onNodeSelect?: (node: AXPCategoryEntity) => void;
+    onNodeCreate?: (parentNode?: AXPCategoryEntity) => void;
+    onNodeUpdate?: (node: AXPCategoryEntity) => void;
+    onNodeDelete?: (node: AXPCategoryEntity) => void;
+    onSearchChange?: (searchValue: string) => void;
+    onCollapseChange?: (node: AXPCategoryEntity) => void;
+}
+interface AXPCategoryTreeActions {
+    canCreate?: boolean;
+    canUpdate?: boolean;
+    canDelete?: boolean;
+    canCreateChild?: boolean;
+    createLabel?: string;
+    updateLabel?: string;
+    deleteLabel?: string;
+    createChildLabel?: string;
+}
+interface AXPCategoryTreeDataSource {
+    loadRootNodes: () => Promise<AXPCategoryEntity[]>;
+    loadChildNodes?: (parentId: string) => Promise<AXPCategoryEntity[]>;
+    searchNodes?: (searchValue: string) => Promise<AXPCategoryEntity[]>;
+}
+
+declare class AXPCategoryTreeComponent {
+    /** i18n key for the synthetic root row; resolved in the template with the translate pipe. */
+    protected readonly categoryTreeRootTitleI18nKey = "@general:terms.interface.selection.all-items";
+    dataSource: _angular_core.InputSignal<AXPCategoryTreeDataSource>;
+    config: _angular_core.InputSignal<AXPCategoryTreeConfig>;
+    actions: _angular_core.InputSignal<AXPCategoryTreeActions>;
+    events: _angular_core.InputSignal<AXPCategoryTreeEvents>;
+    nodeClick: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
+    nodeSelect: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
+    nodeCreate: _angular_core.OutputEmitterRef<AXPCategoryEntity<string> | undefined>;
+    nodeUpdate: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
+    nodeDelete: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
+    searchChange: _angular_core.OutputEmitterRef<string>;
+    collapseChange: _angular_core.OutputEmitterRef<AXPCategoryEntity<string>>;
+    tree: _angular_core.Signal<AXTreeViewLegacyComponent | undefined>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    searchValue: _angular_core.WritableSignal<string>;
+    private loadingTimeoutId;
+    private readonly LOADING_DELAY;
+    protected treeItems: _angular_core.WritableSignal<AXPCategoryTreeNode[]>;
+    protected emptyStateTitle: _angular_core.Signal<string>;
+    protected emptyStateDescription: _angular_core.Signal<string>;
+    ngOnInit(): Promise<void>;
+    loadRootNodes(): Promise<void>;
+    loadChildNodes(parentId: string): Promise<void>;
+    searchNodes(searchValue: string): Promise<void>;
+    handleNodeClick(event: AXTreeItemClickBaseEventLegacy): Promise<void>;
+    handleCollapseChanged(event: AXTreeItemClickBaseEventLegacy): Promise<void>;
+    handleSearchChange(event: AXValueChangedEvent): Promise<void>;
+    handleCreateRootClick(event: AXClickEvent): Promise<void>;
+    handleCreateChildClick(node: AXPCategoryTreeNode, event: AXClickEvent): Promise<void>;
+    handleUpdateNodeClick(node: AXPCategoryTreeNode, event: AXClickEvent): Promise<void>;
+    handleDeleteNodeClick(node: AXPCategoryTreeNode, event: AXClickEvent): Promise<void>;
+    private convertEntitiesToTreeNodes;
+    private updateNodeChildren;
+    refreshTree(parentId?: string): Promise<void>;
+    /**
+     * Set loading state with delay to avoid flickering for fast responses
+     */
+    private setLoadingWithDelay;
+    /**
+     * Clear loading state and cancel any pending timeout
+     */
+    private clearLoadingState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPCategoryTreeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPCategoryTreeComponent, "axp-category-tree", never, { "dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; }, { "nodeClick": "nodeClick"; "nodeSelect": "nodeSelect"; "nodeCreate": "nodeCreate"; "nodeUpdate": "nodeUpdate"; "nodeDelete": "nodeDelete"; "searchChange": "searchChange"; "collapseChange": "collapseChange"; }, never, never, true, never>;
+}
+
+/**
+ * Color Palette Picker Component
+ * Displays a grid of color swatches for selection
+ */
+declare class AXPColorPalettePickerComponent {
+    /**
+     * Array of color codes to display
+     */
+    colors: _angular_core.InputSignal<string[]>;
+    /**
+     * Currently selected color
+     */
+    selectedColor: _angular_core.InputSignal<string | null | undefined>;
+    /**
+     * Disable the entire palette
+     */
+    disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Make the palette readonly
+     */
+    readonly: _angular_core.InputSignal<boolean>;
+    /**
+     * Show empty/null option to clear selection
+     */
+    allowClear: _angular_core.InputSignal<boolean>;
+    /**
+     * Emits when a color is selected or cleared (null/undefined)
+     */
+    colorSelected: _angular_core.OutputEmitterRef<string | null | undefined>;
+    /**
+     * Handle color selection
+     */
+    protected handleColorSelect(color: string | null | undefined): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPColorPalettePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPColorPalettePickerComponent, "axp-color-palette-picker", never, { "colors": { "alias": "colors"; "required": false; "isSignal": true; }; "selectedColor": { "alias": "selectedColor"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "allowClear": { "alias": "allowClear"; "required": false; "isSignal": true; }; }, { "colorSelected": "colorSelected"; }, never, never, true, never>;
+}
+
+interface AXPColumnItemListItem {
+    id: string;
+    content: string;
+}
+declare class AXPColumnItemListComponent implements OnDestroy {
+    items: _angular_core.InputSignal<AXPColumnItemListItem[]>;
+    itemTemplate: _angular_core.InputSignal<TemplateRef<{
+        $implicit: AXPColumnItemListItem;
+    }> | null>;
+    itemClick: _angular_core.OutputEmitterRef<AXPColumnItemListItem>;
+    protected itemsContainer: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    protected moreButton: _angular_core.Signal<ElementRef<any> | undefined>;
+    protected morePopover: _angular_core.Signal<AXPopoverComponent | undefined>;
+    protected isMorePopoverOpen: _angular_core.WritableSignal<boolean>;
+    protected hasOverflow: _angular_core.WritableSignal<boolean>;
+    private resizeObserver?;
+    constructor();
+    ngOnDestroy(): void;
+    protected showMoreItems(): void;
+    protected onMorePopoverOpenChange(event: any): void;
+    private openMorePopover;
+    protected submitClick(event: AXPColumnItemListItem): void;
+    private checkOverflow;
+    private setupResizeObserver;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPColumnItemListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPColumnItemListComponent, "axp-column-item-list", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
+}
+
+declare class AXPQueryColumnsComponent {
+    columns: _angular_core.ModelSignal<AXPColumnQuery[]>;
+    handleVisibilityChange(e: AXValueChangedEvent<boolean>, name: string): void;
+    protected drop(event: CdkDragDrop<unknown[]>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryColumnsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryColumnsComponent, "axp-query-columns", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; }, { "columns": "columnsChange"; }, never, never, true, never>;
+}
+
+interface AXPCompareViewField {
+    path: string;
+    title: string;
+    description?: string;
+    widget: AXPWidgetNode;
+}
+interface AXPCompareViewObject {
+    id: string;
+    title: string;
+    description?: string;
+    context: AXPContextData;
+}
+interface AXPCompareViewInputs {
+    fields: AXPCompareViewField[];
+    objects: AXPCompareViewObject[];
+}
+type AXPCompareViewMode = 'compare' | 'changes';
+declare class AXPCompareViewComponent implements OnInit, OnDestroy {
+    inputs: _angular_core.InputSignal<AXPCompareViewInputs | undefined>;
+    showOnlyChanges: _angular_core.WritableSignal<boolean>;
+    mode: _angular_core.InputSignal<AXPCompareViewMode>;
+    private removedObjects;
+    protected isChangesMode: _angular_core.Signal<boolean>;
+    /**
+     * Filtered fields based on showOnlyChanges toggle
+     */
+    filteredFields: _angular_core.Signal<AXPCompareViewField[]>;
+    remainingObjects: _angular_core.Signal<AXPCompareViewObject[]>;
+    /**
+     * Check if a field value will change in the next object (to show arrow in current cell)
+     */
+    protected hasValueChangingToNext(fieldPath: string, currentObjectIndex: number): boolean;
+    /**
+     * Check if a field value has changed compared to the previous object
+     */
+    hasValueChangedFromPrevious(fieldPath: string, currentObjectIndex: number): boolean;
+    /**
+     * Check if a field has unequal values across objects
+     */
+    hasUnequalValues(fieldPath: string): boolean;
+    /**
+     * Check if a field has equal values across objects
+     */
+    hasEqualValues(fieldPath: string): boolean;
+    /**
+     * Compare two values for equality (deep comparison for objects/arrays)
+     */
+    private areValuesEqual;
+    /**
+     * Toggle the show only changes filter
+     */
+    toggleShowOnlyChanges(): void;
+    /**
+     * Remove an object from the comparison
+     */
+    removeObject(objectId: string): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPCompareViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPCompareViewComponent, "axp-compare-view", never, { "inputs": { "alias": "inputs"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type AXPDataSelectorAllowCreate = 'none' | 'full' | 'quick';
+interface AXPDataSelectorColumn {
+    name: string;
+    title: string;
+    visible: boolean;
+    dataPath?: string;
+    width?: string;
+    widget: {
+        type: string;
+        options: any;
+    };
+}
+interface AXPDataSelectorConfig {
+    title: string;
+    dataSource: AXDataSource<any>;
+    columns: AXPDataSelectorColumn[];
+    selectionMode: 'single' | 'multiple';
+    searchFields?: {
+        name: string;
+        title: string;
+    }[];
+    initialSearchTerm?: string;
+    parentField?: string;
+    allowCreate?: AXPDataSelectorAllowCreate;
+    onCreate?: (mode: 'full' | 'quick') => Promise<any | null>;
+    filters?: AXDataSourceFilterOption;
+    selectedItemIds?: string[] | number[];
+    categoryFilter?: {
+        enabled: boolean;
+        title: string;
+        dataSource: AXPCategoryTreeDataSource;
+        filterField: string;
+        filterOperator?: 'equal' | 'contains' | 'in';
+        width?: string;
+    };
+}
+declare class AXPDataSelectorComponent extends AXBasePageComponent {
+    protected config: _angular_core.WritableSignal<AXPDataSelectorConfig>;
+    protected searchTerm: string;
+    protected searchPlaceholderText: _angular_core.WritableSignal<string>;
+    protected filter: AXDataSourceFilterOption;
+    protected grid: _angular_core.Signal<AXDataTableComponent | undefined>;
+    protected selectedItems: _angular_core.WritableSignal<any[]>;
+    private initialSelectionApplied;
+    private userHasInteracted;
+    private isApplyingInitialSelection;
+    private initialSelectedItems;
+    protected activeCategoryFilter: _angular_core.WritableSignal<{
+        node: AXPCategoryEntity;
+        filterValue: any;
+    } | null>;
+    private placeholderUpdateToken;
+    private initialSearchApplied;
+    private readonly translationService;
+    constructor();
+    protected allowSelect: _angular_core.Signal<boolean>;
+    protected selectedCount: _angular_core.Signal<number>;
+    protected hasSearch: _angular_core.Signal<boolean | undefined>;
+    protected categoryTreeConfig: _angular_core.Signal<{
+        textField: string;
+        valueField: string;
+        showCheckbox: boolean;
+        searchable: boolean;
+        searchPlaceholder: string;
+        emptyStateTitle: string;
+        emptyStateDescription: string;
+        emptyStateIcon: string;
+    }>;
+    protected categoryTreeActions: _angular_core.Signal<{
+        canCreate: boolean;
+        canUpdate: boolean;
+        canDelete: boolean;
+        canCreateChild: boolean;
+    }>;
+    protected ngOnInit(): void;
+    protected ngAfterViewInit(): Promise<void>;
+    protected handleRowDbClick(e: AXDataTableRowDbClick): void;
+    protected handleRowClick(e: AXDataTableRowClick): void;
+    protected handleSelectedRowsChange(rows: unknown[]): Promise<void>;
+    protected handleChangeSearchValue(e: AXValueChangedEvent): void;
+    protected handleCreateNewClick(mode: 'full' | 'quick'): Promise<void>;
+    protected handleCloseClick(): void;
+    protected handleSelectClick(): void;
+    protected handleExpandRow(row: any): Promise<void>;
+    protected handleCategoryFilterClick(node: AXPCategoryEntity): void;
+    protected clearCategoryFilter(): void;
+    private applySearchFilter;
+    private applyFilterAndSort;
+    private applyCategoryFilter;
+    private updateSearchPlaceholder;
+    /**
+     * Apply initial selection based on selectedItemIds from config
+     * Loads items by IDs using the data source's byKey method, then selects them in the grid
+     */
+    private applyInitialSelection;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDataSelectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPDataSelectorComponent, "axp-data-selector", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPDataSelectorService {
+    private readonly popupService;
+    private readonly expressionService;
+    private readonly columnWidthService;
+    /**
+     * Open data selector popup
+     */
+    open(config: AXPDataSelectorConfig): Promise<{
+        items: any[];
+    } | null>;
+    /**
+     * Open data selector with category filter
+     */
+    openWithCategoryFilter(config: Omit<AXPDataSelectorConfig, 'categoryFilter'>, categoryFilterConfig: {
+        title: string;
+        dataSource: AXPCategoryTreeDataSource;
+        filterField: string;
+        filterOperator?: 'equal' | 'contains' | 'in';
+        width?: string;
+    }): Promise<{
+        items: any[];
+    } | null>;
+    /**
+     * Apply column width resolution to all columns using the column width service
+     */
+    private applyColumnWidths;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDataSelectorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPDataSelectorService>;
+}
+
+/**
+ * Definition for a page component that can be registered and loaded dynamically
+ */
+interface AXPPageComponentDefinition {
+    /**
+     * Unique key to identify the component
+     */
+    key: string;
+    /**
+     * Loader function that returns the component type (supports lazy loading)
+     */
+    loader: () => Type<any> | Promise<Type<any>>;
+}
+/**
+ * Provider interface for registering page components
+ * Similar to AXPDataSourceDefinitionProvider pattern
+ */
+interface AXPPageComponentProvider {
+    /**
+     * Returns all component definitions provided by this provider
+     */
+    components(): Promise<AXPPageComponentDefinition[]>;
+}
+
+/**
+ * Service for managing page components from multiple providers
+ * Similar to AXPDataSourceDefinitionProviderService pattern
+ *
+ * @example
+ * ```typescript
+ * // In a module providers array:
+ * {
+ *   provide: AXP_PAGE_COMPONENT_PROVIDER,
+ *   useClass: MyPageComponentProvider,
+ *   multi: true,
+ * }
+ *
+ * // Example provider implementation:
+ * export class MyPageComponentProvider implements AXPPageComponentProvider {
+ *   async components(): Promise<AXPPageComponentDefinition[]> {
+ *     return [
+ *       {
+ *         key: 'my-custom-page',
+ *         loader: () => import('./my-page.component').then(m => m.MyPageComponent),
+ *       },
+ *     ];
+ *   }
+ * }
+ *
+ * // Later, get the component loader:
+ * const loader = await pageComponentService.find('my-custom-page');
+ * if (loader) {
+ *   const ComponentType = await loader();
+ *   // Use ComponentType
+ * }
+ * ```
+ */
+declare class AXPPageComponentRegistryService {
+    private providers;
+    /**
+     * Get all component definitions from all providers
+     */
+    components(): Promise<AXPPageComponentDefinition[]>;
+    /**
+     * Find a component loader by key
+     */
+    find(key: string): Promise<(() => Type<any> | Promise<Type<any>>) | undefined>;
+    /**
+     * Check if a component exists by key
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Get all registered component keys
+     */
+    getAll(): Promise<string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPPageComponentRegistryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPPageComponentRegistryService>;
+}
+
+/**
+ * Injection token for page component providers
+ * Use with multi: true to register multiple providers
+ *
+ * @example
+ * ```typescript
+ * providers: [
+ *   {
+ *     provide: AXP_PAGE_COMPONENT_PROVIDER,
+ *     useClass: MyPageComponentProvider,
+ *     multi: true,
+ *   }
+ * ]
+ * ```
+ */
+declare const AXP_PAGE_COMPONENT_PROVIDER: InjectionToken<AXPPageComponentProvider[]>;
+
+interface AXPDragDropListItem {
+    id: string;
+    content: string;
+    data?: any;
+    disabled?: boolean;
+    cssClass?: string;
+}
+interface AXPDragDropListConfig {
+    allowReorder?: boolean;
+    allowTransfer?: boolean;
+}
+interface AXPDragDropListDropEvent {
+    previousIndex: number;
+    currentIndex: number;
+    item: AXPDragDropListItem;
+    container: any;
+    previousContainer?: any;
+    isTransfer: boolean;
+}
+
+declare class AXPDragDropListComponent {
+    items: _angular_core.ModelSignal<AXPDragDropListItem[]>;
+    listId: _angular_core.InputSignal<string>;
+    dropListGroup: _angular_core.InputSignal<string>;
+    orientation: _angular_core.InputSignal<"vertical" | "horizontal">;
+    emptyMessage: _angular_core.InputSignal<string>;
+    disable: _angular_core.InputSignal<boolean>;
+    itemClick: _angular_core.OutputEmitterRef<AXPDragDropListItem>;
+    dropListDropped: _angular_core.OutputEmitterRef<AXDropListDroppedEvent>;
+    onDrop(event: AXDropListDroppedEvent): void;
+    onItemClick(item: AXPDragDropListItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDragDropListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPDragDropListComponent, "axp-drag-drop-list", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "listId": { "alias": "listId"; "required": false; "isSignal": true; }; "dropListGroup": { "alias": "dropListGroup"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "disable": { "alias": "disable"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; "itemClick": "itemClick"; "dropListDropped": "dropListDropped"; }, never, never, true, never>;
+}
+
+/**
+ * Shared types for expression builders (expression-builder, sort-builder, group-builder, etc.)
+ */
+/** Unique identifier for expression nodes */
+type AXPExpressionNodeId = string;
+/** Logical operator type (AND, OR, etc.) */
+type AXPExpressionLogicType = 'and' | 'or' | 'not';
+/** Operation type (add, multiply, equal, etc.) */
+type AXPExpressionOperationType = string;
+/** Value source type (literal, field, parameter, etc.) */
+type AXPExpressionValueSourceType = 'literal' | 'field' | 'parameter';
+/** Field definition for value selectors */
+interface AXPExpressionFieldDefinition {
+    id: string;
+    title: string;
+    dataType?: string;
+    path?: string;
+    /** Optional: for nested/related fields */
+    children?: AXPExpressionFieldDefinition[];
+}
+/** Value operand in an expression */
+interface AXPExpressionValueOperand {
+    sourceType: AXPExpressionValueSourceType;
+    /** For field: field id; for literal: the value; for parameter: param key */
+    value?: unknown;
+    fieldId?: string;
+}
+/** Single operation node (leftOperand operator rightOperand) */
+interface AXPExpressionOperationNode {
+    id: AXPExpressionNodeId;
+    type: 'operation';
+    operator: AXPExpressionOperationType;
+    leftOperand: AXPExpressionValueOperand;
+    rightOperand: AXPExpressionValueOperand;
+    order?: number;
+}
+/** Group of operations with logical connective */
+interface AXPExpressionGroupNode {
+    id: AXPExpressionNodeId;
+    type: 'group';
+    logic: AXPExpressionLogicType;
+    children: AXPExpressionNode[];
+    order?: number;
+}
+/** Union of expression node types */
+type AXPExpressionNode = AXPExpressionOperationNode | AXPExpressionGroupNode;
+/** Root expression tree */
+interface AXPExpressionTree {
+    id: AXPExpressionNodeId;
+    logic: AXPExpressionLogicType;
+    children: AXPExpressionNode[];
+}
+
+/**
+ * Field definitions for expression builders.
+ * Used by expression-builder, sort-builder, group-builder for value/field selection.
+ */
+
+/** Registry of available field definitions per context */
+declare const AXPExpressionFieldDefinitions: Record<string, AXPExpressionFieldDefinition[]>;
+/** Add field definitions for a given context */
+declare function registerFieldDefinitions(context: string, fields: AXPExpressionFieldDefinition[]): void;
+/** Get field definitions for a context */
+declare function getFieldDefinitions(context: string): AXPExpressionFieldDefinition[];
+
+/**
+ * Logic operator definitions (AND, OR, NOT) for expression groups.
+ */
+
+interface AXPExpressionLogicDefinition {
+    value: AXPExpressionLogicType;
+    text: string;
+    /** Optional icon/key for UI */
+    icon?: string;
+}
+declare const AXP_EXPRESSION_LOGIC_DEFINITIONS: AXPExpressionLogicDefinition[];
+declare function getLogicDefinition(logic: AXPExpressionLogicType): AXPExpressionLogicDefinition | undefined;
+
+/**
+ * Operation definitions (arithmetic, comparison, logical) for expression builder.
+ */
+
+interface AXPExpressionOperationDefinition {
+    value: AXPExpressionOperationType;
+    text: string;
+    /** Optional icon/symbol for UI */
+    symbol?: string;
+    /** Category for grouping in UI */
+    category?: 'arithmetic' | 'comparison' | 'logical' | 'string';
+}
+declare const AXP_EXPRESSION_OPERATION_DEFINITIONS: AXPExpressionOperationDefinition[];
+declare function getOperationDefinition(operation: AXPExpressionOperationType): AXPExpressionOperationDefinition | undefined;
+
+/**
+ * Selected field data emitted when condition changes
+ */
+type ConditionBuilderSelectedField = {
+    id: string;
+    field: string;
+    operator: AXDataSourceOperator['type'];
+    value: unknown;
+    isParametric?: boolean;
+};
+declare class AXPConditionBuilderConditionComponent implements OnInit {
+    item: _angular_core.InputSignal<AXPFilterClause>;
+    filterDefinitions: _angular_core.InputSignal<AXPFilterDefinition[]>;
+    onResolveWidget: _angular_core.InputSignal<((fieldId: string) => string) | undefined>;
+    showFillByUser: _angular_core.InputSignal<boolean>;
+    itemChange: _angular_core.OutputEmitterRef<ConditionBuilderSelectedField>;
+    removeItem: _angular_core.OutputEmitterRef<string>;
+    protected selectedField: _angular_core.WritableSignal<ConditionBuilderSelectedField | null>;
+    protected filterNode: _angular_core.WritableSignal<AXPWidgetNode>;
+    protected context: _angular_core.WritableSignal<Record<string, unknown>>;
+    protected readonly availableFields: _angular_core.Signal<{
+        value: string | undefined;
+        text: string;
+        definition: AXPFilterDefinition;
+    }[]>;
+    protected readonly currentFilterDefinition: _angular_core.Signal<AXPFilterDefinition | undefined>;
+    protected readonly selectedFieldValue: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    constructor();
+    private updateFilterWidgetNode;
+    private updateContext;
+    onFieldChange(event: AXValueChangedEvent): void;
+    onContextChange(event: {
+        data?: {
+            filter?: {
+                value?: unknown;
+                operation?: {
+                    type?: string;
+                };
+            };
+        };
+    }): void;
+    onFillByUserChange(checked: boolean): void;
+    onRemoveClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPConditionBuilderConditionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPConditionBuilderConditionComponent, "axp-condition-builder-condition", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "filterDefinitions": { "alias": "filterDefinitions"; "required": false; "isSignal": true; }; "onResolveWidget": { "alias": "onResolveWidget"; "required": false; "isSignal": true; }; "showFillByUser": { "alias": "showFillByUser"; "required": false; "isSignal": true; }; }, { "itemChange": "itemChange"; "removeItem": "removeItem"; }, never, never, true, never>;
+}
+
+/**
+ * Generic condition builder component.
+ * Builds AXPFilterClause (logic/filters, field/operator/value) for use in outcome rules,
+ * outcome actions, query builders, etc.
+ *
+ * Same structure as axp-where-builder: groups, AND/OR logic, add condition/group, drag-drop, move/remove.
+ */
+declare class AXPConditionBuilderComponent {
+    private readonly widgetRegistry;
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly platformId;
+    private readonly isBrowser;
+    value: _angular_core.InputSignal<AXPFilterClause>;
+    filterDefinitions: _angular_core.InputSignal<AXPFilterDefinition[]>;
+    /** When true, show "Fill by user" checkbox on each condition (e.g. for query parameters) */
+    showFillByUser: _angular_core.InputSignal<boolean>;
+    valueChange: _angular_core.OutputEmitterRef<AXPFilterClause>;
+    protected queryData: _angular_core.WritableSignal<AXPFilterClause>;
+    protected readonly logicalOperatorsItems: {
+        value: AXFilterLogic;
+        text: string;
+    }[];
+    protected getLogicDisplayText(logic: AXFilterLogic | undefined): string;
+    private connectorLayoutRafId;
+    private connectorResizeObserver;
+    private initConnectorAutoLayout;
+    private scheduleConnectorLayoutUpdate;
+    private updateConnectorCssVars;
+    constructor();
+    private generateId;
+    private updateValue;
+    private normalizeOrder;
+    protected getSortedFilters(filters: AXPFilterClause[]): AXPFilterClause[];
+    private findGroupById;
+    protected getFilterDefinition(fieldId: string): AXPFilterDefinition | undefined;
+    resolveDefaultFilterWidget(fieldId: string): string;
+    addConditionToGroup(groupId: string): void;
+    addGroupToGroup(parentGroupId: string): void;
+    removeItem(id: string): void;
+    updateCondition(condition: ConditionBuilderSelectedField): void;
+    updateGroupLogicalOperator(groupId: string, operator: AXFilterLogic): void;
+    reorderGroupItemsEvent(groupId: string, event: AXDropListDroppedEvent): void;
+    reorderGroupItems(groupId: string, previousIndex: number, currentIndex: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPConditionBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPConditionBuilderComponent, "axp-condition-builder", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "filterDefinitions": { "alias": "filterDefinitions"; "required": false; "isSignal": true; }; "showFillByUser": { "alias": "showFillByUser"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare class AXPQueryFiltersComponent {
+    #private;
+    protected translate: AXTranslationService;
+    protected calendarService: AXCalendarService;
+    private filterOperatorMiddleware;
+    private settingsService;
+    private readonly expressionEvaluator;
+    filtersDefinitions: _angular_core.InputSignal<AXPFilterDefinition[]>;
+    initialFilters: _angular_core.InputSignal<AXPFilterQuery[]>;
+    onFiltersChanged: _angular_core.OutputEmitterRef<AXPFilterQuery[]>;
+    protected dateFormat: _angular_core.WritableSignal<string>;
+    protected tagBox: _angular_core.Signal<AXTagBoxComponent | undefined>;
+    protected widgetRenderer: _angular_core.Signal<AXPWidgetRendererDirective | undefined>;
+    tagBoxInput: any;
+    listItems: QueryList<any>;
+    protected selectedField: _angular_core.WritableSignal<string | null>;
+    protected selectedFilters: _angular_core.WritableSignal<AXPFilterDefinition[]>;
+    context: _angular_core.WritableSignal<any>;
+    protected activeFilter: _angular_core.WritableSignal<AXPFilterDefinition | null>;
+    protected asyncTags: _angular_core.WritableSignal<any[]>;
+    protected popover: _angular_core.Signal<AXPopoverComponent | undefined>;
+    inputValue: _angular_core.WritableSignal<string>;
+    protected readonly disabledByField: _angular_core.WritableSignal<Record<string, boolean>>;
+    /** Emits when a filter context entry changes (aligned with `widget-renderer` `events.context`). */
+    private readonly filterContextPath$;
+    private filterContextPathSnapshotReady;
+    private previousFilterContextSnapshot;
+    inlineFilters: () => AXPFilterDefinition[];
+    protected getDisplayValue: (filter: AXPFilterDefinition, val: any) => Promise<any>;
+    protected convertIfISOStringDate: (val: string) => string;
+    convertQueriesToDefinitions(queries: AXPFilterQuery[]): AXPFilterDefinition[];
+    convertQueriesToContext(queries: AXPFilterQuery[]): any;
+    filterFields: () => AXPFilterDefinition[];
+    ngOnInit(): void;
+    handleSelectField(field: AXPFilterDefinition): void;
+    handleFieldKeyDown(e: KeyboardEvent, field: AXPFilterDefinition): void;
+    onContextChanged(e: AXPContextChangeEvent): void;
+    handleApplyFilter(): void;
+    handleButtonKeyDown(e: Event): void;
+    handleKeyDown(e: AXHtmlEvent<KeyboardEvent>): void;
+    onEnterKeyPressed(e: Event): void;
+    handleTagClick(item: any): void;
+    handleRemoveTag(e: Event, index: number): void;
+    handleSelectFilters(e: AXValueChangedEvent): void;
+    handleAddAllInlineFilters(): void;
+    protected getActiveOperator(filter: AXPFilterDefinition | null): string | undefined;
+    handleSelectInlineFilter(filter: AXPFilterDefinition): void;
+    handleInlineFilterKeyDown(e: KeyboardEvent, filter: AXPFilterDefinition): void;
+    handlePopoverClosed(e: AXEvent): void;
+    protected onPopoverOpened(e: AXEvent): void;
+    protected deactivateAllListItems(): void;
+    protected isFilterDisabled(definition: AXPFilterDefinition): boolean;
+    private createExpressionScope;
+    private isObservableLike;
+    private buildFilterTriggerScope;
+    private getFilterEventScope;
+    private getFilterWidgetScopeForDefinition;
+    private removeFilterFieldByName;
+    protected handleKeyboardEvent(event: KeyboardEvent): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryFiltersComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryFiltersComponent, "axp-query-filters", never, { "filtersDefinitions": { "alias": "filtersDefinitions"; "required": false; "isSignal": true; }; "initialFilters": { "alias": "initialFilters"; "required": false; "isSignal": true; }; }, { "onFiltersChanged": "onFiltersChanged"; }, never, never, true, never>;
+}
+
+interface AXPPreloadFiltersApplyEvent {
+    filterValues: Record<string, any>;
+}
+declare class AXPPreloadFiltersComponent {
+    /**
+     * Filter definitions to display
+     */
+    filterDefinitions: _angular_core.InputSignal<AXPFilterDefinition[]>;
+    /**
+     * Whether to show the "Show All" button
+     */
+    showAllButton: _angular_core.InputSignal<boolean>;
+    /**
+     * Emitted when user applies filters
+     */
+    apply: _angular_core.OutputEmitterRef<AXPPreloadFiltersApplyEvent>;
+    /**
+     * Emitted when user clicks "Show All"
+     */
+    showAll: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Context for widgets container
+     */
+    context: _angular_core.WritableSignal<any>;
+    /**
+     * On context changed
+     */
+    onContextChanged(event: AXPContextChangeEvent): void;
+    /**
+     * Handle apply filters
+     */
+    handleApply(form: AXFormComponent): Promise<void>;
+    /**
+     * Handle form keydown events
+     */
+    onFormKeyDown(event: KeyboardEvent, form: AXFormComponent): void;
+    /**
+     * Handle show all (skip filters and go to list).
+     * Prevents implicit form submit when the control renders as a submit button inside ax-form.
+     */
+    handleShowAll(event?: AXClickEvent): void;
+    /**
+     * Check if field is required
+     */
+    isFieldRequired(filterDef: AXPFilterDefinition): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPPreloadFiltersComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPPreloadFiltersComponent, "axp-preload-filters", never, { "filterDefinitions": { "alias": "filterDefinitions"; "required": true; "isSignal": true; }; "showAllButton": { "alias": "showAllButton"; "required": false; "isSignal": true; }; }, { "apply": "apply"; "showAll": "showAll"; }, never, never, true, never>;
+}
+
+declare class AXPImageEditorPopupComponent extends AXBasePageComponent {
+    private readonly fileStorage;
+    image: _angular_core.InputSignal<Blob>;
+    showHistory: _angular_core.InputSignal<boolean>;
+    look: _angular_core.InputSignal<"solid" | "outline" | "blank">;
+    aspectRatio: _angular_core.InputSignal<string | undefined>;
+    private container;
+    private blobUrl;
+    protected url: _angular_core.WritableSignal<string | null>;
+    protected context: _angular_core.WritableSignal<{
+        image: Blob | null;
+    }>;
+    ngOnInit(): Promise<void>;
+    handleValueChanged(e: any): void;
+    handleSave(): void;
+    handleCancel(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPImageEditorPopupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPImageEditorPopupComponent, "axp-image-editor-popup", never, { "image": { "alias": "image"; "required": true; "isSignal": true; }; "showHistory": { "alias": "showHistory"; "required": false; "isSignal": true; }; "look": { "alias": "look"; "required": false; "isSignal": true; }; "aspectRatio": { "alias": "aspectRatio"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface AXPImageEditorOpenOptions {
+    title?: string;
+    image: Blob;
+    showHistory?: boolean;
+    look?: 'solid' | 'outline' | 'blank';
+    aspectRatio?: string;
+}
+declare class AXPImageEditorService {
+    private readonly popupService;
+    private readonly translate;
+    open(options?: AXPImageEditorOpenOptions): Promise<Blob | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPImageEditorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPImageEditorService>;
+}
+
+declare class AXPLogoComponent implements OnInit, OnChanges {
+    source: any;
+    protected logoType: string;
+    private platform;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    protected setLogoType(): void;
+    protected setLogoTheme(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLogoComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPLogoComponent, "axp-logo", never, { "source": { "alias": "source"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Menu item type definitions.
+ * - 'menu': Standard navigable menu item
+ * - 'group': Menu group/category header
+ * - 'break': Visual separator/divider
+ */
+type AXPMenuCustomizerItemType = 'menu' | 'group' | 'break';
+/**
+ * Menu item interface for customizer.
+ * Represents a single menu item with its properties.
+ */
+interface AXPMenuCustomizerItem {
+    /** Unique identifier/key for the menu item */
+    name?: string;
+    /** Display text (can be an i18n key) */
+    text?: string;
+    /** Icon class (e.g., 'fa-light fa-home') */
+    icon?: string;
+    /** Navigation path/route */
+    path?: string;
+    /** Type of menu item */
+    type?: AXPMenuCustomizerItemType;
+    /** Priority for ordering (lower = higher priority) */
+    priority?: number;
+    /** Description/tooltip text */
+    description?: string;
+    /** Child menu items */
+    children?: AXPMenuCustomizerItem[];
+}
+/**
+ * Metadata for menu tree nodes.
+ * Contains flags and original values for tracking customizations.
+ */
+interface AXPMenuCustomizerNodeMetadata {
+    /** Whether this is a built-in (system) menu item */
+    isBuiltIn: boolean;
+    /** Whether this is a custom (user-created) menu item */
+    isCustom: boolean;
+    /** Whether this menu item is currently hidden */
+    isHidden: boolean;
+    /** Original priority before any customizations */
+    originalPriority?: number;
+    /** Original parent name before any move operations */
+    originalParentName?: string;
+}
+/**
+ * Data structure for tree node combining menu item with metadata.
+ * This is stored in the tree node's 'data' field.
+ */
+interface AXPMenuCustomizerNodeData {
+    /** The menu item properties */
+    menuItem: AXPMenuCustomizerItem;
+    /** Metadata about the menu item's state */
+    metadata: AXPMenuCustomizerNodeMetadata;
+}
+/**
+ * Available actions that can be performed on menu items.
+ */
+type AXPMenuCustomizerAction = 'show' | 'hide' | 'edit' | 'delete' | 'add-child' | 'move';
+/**
+ * Component state for loading/error handling.
+ */
+type AXPMenuCustomizerState = {
+    status: 'idle';
+} | {
+    status: 'loading';
+} | {
+    status: 'success';
+} | {
+    status: 'error';
+    message: string;
+};
+/**
+ * Abstract service interface for menu customization operations.
+ * Implement this interface and provide it via AXP_MENU_CUSTOMIZER_SERVICE token.
+ */
+declare abstract class AXPMenuCustomizerService {
+    /**
+     * Get menu tree nodes for the given scope key
+     */
+    abstract getMenuTree(scopeKey: string): Promise<AXTreeViewNode[]>;
+    /**
+     * Sync tree changes (reorder, move) to storage
+     */
+    abstract syncTreeChanges(scopeKey: string, treeNodes: AXTreeViewNode[]): Promise<void>;
+    /**
+     * Show a hidden menu item
+     */
+    abstract showMenuItem(scopeKey: string, menuName: string): Promise<void>;
+    /**
+     * Hide a menu item
+     */
+    abstract hideMenuItem(scopeKey: string, menuName: string): Promise<void>;
+    /**
+     * Add a custom menu item
+     */
+    abstract addCustomMenuItem(scopeKey: string, menuItem: AXPMenuCustomizerItem, parentName: string | null): Promise<void>;
+    /**
+     * Update a custom menu item
+     */
+    abstract updateCustomMenuItem(scopeKey: string, menuName: string, menuItem: AXPMenuCustomizerItem): Promise<void>;
+    /**
+     * Update menu item properties (for built-in items)
+     */
+    abstract updateMenuProperties(scopeKey: string, menuName: string, properties: Partial<AXPMenuCustomizerItem>): Promise<void>;
+    /**
+     * Delete a custom menu item
+     */
+    abstract deleteCustomMenuItem(scopeKey: string, menuName: string): Promise<void>;
+    /**
+     * Reset all customizations for the scope
+     */
+    abstract resetCustomizations(scopeKey: string): Promise<void>;
+}
+/**
+ * Injection token for menu customizer service
+ */
+declare const AXP_MENU_CUSTOMIZER_SERVICE: InjectionToken<AXPMenuCustomizerService>;
+
+/**
+ * Reusable menu customizer component that allows users to reorder, show/hide,
+ * and manage menu items using a tree-like interface.
+ * Can be used standalone or within popups/dialogs.
+ *
+ * @description
+ * This component provides a visual interface for customizing menu structures.
+ * It supports:
+ * - Drag and drop reordering of menu items
+ * - Showing/hiding menu items
+ * - Adding custom menu items
+ * - Editing menu item properties
+ * - Resetting customizations to defaults
+ *
+ * @example
+ * ```html
+ * <axp-menu-customizer
+ *   [scopeKey]="'edition:my-edition'"
+ *   [showToolbar]="true"
+ *   [allowAddItems]="true"
+ *   (saved)="onSaved()"
+ * />
+ * ```
+ *
+ * @requires AXP_MENU_CUSTOMIZER_SERVICE - Must provide an implementation of AXPMenuCustomizerService
+ */
+declare class AXPMenuCustomizerComponent implements OnInit {
+    private readonly menuCustomizerService;
+    private readonly layoutBuilder;
+    private readonly dialogService;
+    private readonly toastService;
+    private readonly translationService;
+    private readonly destroyRef;
+    /** The scope key for loading/saving menu customizations (e.g., 'edition:{id}', 'tenant:{id}') */
+    scopeKey: _angular_core.InputSignal<string>;
+    /** Whether to show the toolbar with collapse/expand/reset actions */
+    showToolbar: _angular_core.InputSignal<boolean>;
+    /** Whether to allow adding custom menu items */
+    allowAddItems: _angular_core.InputSignal<boolean>;
+    /** Drag behavior for the tree view: 'none' | 'order-only' | 'move' | 'both' */
+    dragBehavior: _angular_core.InputSignal<AXTreeViewDragBehavior>;
+    /** Drag area for the tree view: 'handler' | 'item' */
+    dragArea: _angular_core.InputSignal<AXTreeViewDragArea>;
+    /** Emitted when changes are saved */
+    saved: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the customizer is closed/cancelled */
+    cancelled: _angular_core.OutputEmitterRef<void>;
+    /** Reference to the tree view component */
+    protected readonly tree: _angular_core.Signal<AXTreeViewComponent | undefined>;
+    /** Tree nodes data source */
+    protected readonly treeNodes: _angular_core.WritableSignal<AXTreeViewNode[]>;
+    /** Current loading/error state */
+    protected readonly state: _angular_core.WritableSignal<AXPMenuCustomizerState>;
+    /** Flag to prevent concurrent sync operations */
+    private isSyncing;
+    /** Whether the component is currently loading */
+    protected readonly isLoading: _angular_core.Signal<boolean>;
+    /** Whether there is an error state */
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    /** The current error message, if any */
+    protected readonly errorMessage: _angular_core.Signal<string>;
+    /** Whether the tree has nodes to display */
+    protected readonly hasNodes: _angular_core.Signal<boolean>;
+    /** Whether to show the content (tree view) */
+    protected readonly showContent: _angular_core.Signal<boolean>;
+    /** Whether to show the empty state */
+    protected readonly showEmptyState: _angular_core.Signal<boolean>;
+    ngOnInit(): Promise<void>;
+    /**
+     * Handle before drop validation.
+     * Prevents dropping into items with paths (leaf nodes that can't have children).
+     *
+     * @param event - The before drop event from tree view
+     */
+    protected handleBeforeDrop(event: AXTreeViewBeforeDropEvent): void;
+    /**
+     * Handle order change event (reordering within the same parent).
+     *
+     * @param event - The drop event from tree view
+     */
+    protected handleOrderChange(event: AXTreeViewDropEvent): Promise<void>;
+    /**
+     * Handle move change event (moving to a different parent).
+     *
+     * @param event - The drop event from tree view
+     */
+    protected handleMoveChange(event: AXTreeViewDropEvent): Promise<void>;
+    /**
+     * Load menu tree for current scope.
+     * Updates the component state to loading, then success or error.
+     * Creates new array reference to ensure UI updates.
+     */
+    loadMenuItems(): Promise<void>;
+    /**
+     * Sync tree changes to backend.
+     * Prevents concurrent sync operations using the isSyncing flag.
+     * Reloads data with new reference after successful sync.
+     */
+    private syncTreeChanges;
+    /**
+     * Collapse all tree nodes.
+     */
+    collapseAll(): void;
+    /**
+     * Expand all tree nodes.
+     */
+    expandAll(): Promise<void>;
+    /**
+     * Reset all customizations to defaults.
+     * Shows a confirmation dialog before resetting.
+     */
+    resetCustomizations(): Promise<void>;
+    /**
+     * Add new root menu item.
+     * Opens the menu item dialog without a parent.
+     */
+    addRootMenuItem(): Promise<void>;
+    /**
+     * Reload the menu items from the service.
+     * Useful for external refresh triggers.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Handle menu item action dispatched from the template.
+     *
+     * @param action - The action to perform
+     * @param nodeData - The node data to perform the action on
+     */
+    protected onAction(action: AXPMenuCustomizerAction, nodeData: AXPMenuCustomizerNodeData): Promise<void>;
+    /**
+     * Add new child menu item to a parent.
+     *
+     * @param parentNodeData - The parent node data
+     */
+    private addChildMenuItem;
+    /**
+     * Show a hidden menu item.
+     *
+     * @param nodeData - The node data containing the menu item to show
+     */
+    private showMenuItem;
+    /**
+     * Hide a menu item.
+     *
+     * @param nodeData - The node data containing the menu item to hide
+     */
+    private hideMenuItem;
+    /**
+     * Edit a menu item.
+     *
+     * @param nodeData - The node data containing the menu item to edit
+     */
+    private editMenuItem;
+    /**
+     * Delete a custom menu item.
+     * Shows a confirmation dialog before deleting.
+     *
+     * @param nodeData - The node data containing the menu item to delete
+     */
+    private deleteMenuItem;
+    /**
+     * Show menu item dialog (add/edit).
+     *
+     * @param nodeData - The node data for editing, or null for adding
+     * @param parentName - The parent menu name for adding child items
+     */
+    private showMenuItemDialog;
+    /**
+     * Build the dialog context for add/edit dialog.
+     *
+     * @param item - The menu item to build context for, or undefined for new items
+     */
+    private buildDialogContext;
+    /**
+     * Build the dialog form fields.
+     * Note: Priority is not included as item order is controlled by drag-drop.
+     *
+     * @param flex - The flex layout builder
+     * @param isEdit - Whether this is an edit operation
+     * @param isBuiltIn - Whether the item is built-in
+     */
+    private buildDialogFields;
+    /**
+     * Save menu item (create or update).
+     *
+     * @param formData - The form data from the dialog
+     * @param nodeData - The original node data (for edit) or null (for add)
+     * @param parentName - The parent menu name (for add child)
+     * @param isEdit - Whether this is an edit operation
+     */
+    private saveMenuItem;
+    /**
+     * Execute a menu action with common error handling and reload.
+     *
+     * @param action - The action to execute
+     * @param successMessageKey - The i18n key for success message
+     * @param errorMessageKey - The i18n key for error message
+     */
+    private executeMenuAction;
+    /**
+     * Show a confirmation dialog.
+     *
+     * @param titleKey - The i18n key for the dialog title
+     * @param messageKey - The i18n key for the dialog message
+     * @returns True if confirmed, false otherwise
+     */
+    private confirmAction;
+    /**
+     * Show a success toast message.
+     *
+     * @param messageKey - The i18n key for the message
+     */
+    private showSuccessMessage;
+    /**
+     * Show an error toast message.
+     *
+     * @param messageKey - The i18n key for the message
+     */
+    private showErrorMessage;
+    /**
+     * Show a warning toast message.
+     *
+     * @param messageKey - The i18n key for the message
+     */
+    private showWarningMessage;
+    private readonly eff;
+    private readonly eff2;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMenuCustomizerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPMenuCustomizerComponent, "axp-menu-customizer", never, { "scopeKey": { "alias": "scopeKey"; "required": true; "isSignal": true; }; "showToolbar": { "alias": "showToolbar"; "required": false; "isSignal": true; }; "allowAddItems": { "alias": "allowAddItems"; "required": false; "isSignal": true; }; "dragBehavior": { "alias": "dragBehavior"; "required": false; "isSignal": true; }; "dragArea": { "alias": "dragArea"; "required": false; "isSignal": true; }; }, { "saved": "saved"; "cancelled": "cancelled"; }, never, never, true, never>;
+}
+
+interface AXPPropertyViewerGroup {
+    name: string;
+    title: string;
+    isCollapsed: boolean;
+    props: AXPWidgetProperty[];
+}
+interface AXPPropertyViewerTab {
+    name: string;
+    title: string;
+    groups: AXPPropertyViewerGroup[];
+}
+interface AXPPropertyViewerChangedEvent {
+    values: any;
+    mode: 'init' | 'update';
+}
+/** Payload when the property viewer popup closes after Apply. */
+type AXPPropertyViewerResult = AXPPropertyViewerChangedEvent;
+/**
+ * Dialog-style ref passed to property viewer `onAction` (same shape as the layout dialog `AXPDialogRef`).
+ */
+interface AXPPropertyViewerActionRef {
+    close(): void;
+    context(): any;
+    action(): string | undefined;
+    setLoading(loading: boolean): void;
+}
+
+declare class AXPPropertyViewerComponent {
+    private readonly defaultMultiLanguageConfig;
+    /**
+     * List of tabs that should be rendered inside the property viewer.
+     */
+    tabsInput: _angular_core.InputSignal<AXPPropertyViewerTab[]>;
+    /**
+     * Determines rendering mode.
+     */
+    mode: _angular_core.InputSignal<"simple" | "advanced">;
+    /**
+     * When a property uses binding expressions, controls how the expression is edited:
+     * `inline` — code editor in the panel (default); `popup` — button that opens the dialog editor.
+     */
+    bindingExpressionEditorMode: _angular_core.InputSignal<"inline" | "popup">;
+    /**
+     * Emits when property context changes.
+     */
+    onChanged: EventEmitter<AXPPropertyViewerChangedEvent>;
+    protected currentTabIndex: WritableSignal<number>;
+    protected tabs: _angular_core.Signal<AXPPropertyViewerTab[]>;
+    protected groups: _angular_core.Signal<AXPPropertyViewerGroup[]>;
+    protected context: WritableSignal<any>;
+    /**
+     * Per-expression-path override for "use expression" vs "use value" when binding.enabled.
+     * Updated when user toggles the ax-switch; otherwise derived from isExpression(valueAtPath).
+     */
+    protected expressionModeState: WritableSignal<Record<string, boolean>>;
+    /**
+     * Evaluated visibility for properties whose {@link AXPWidgetProperty.visible} is a `{{ }}` expression.
+     * Keys match {@link AXPPropertyViewerComponent.propertyVisibilityKey}.
+     */
+    private propertyVisibility;
+    protected groupCollapsedStates: Map<string, boolean>;
+    private readonly expressionEvaluator;
+    private readonly popupService;
+    private readonly form;
+    constructor();
+    /**
+     * Replaces the current context with the provided value and emits an init event.
+     */
+    initializeContext(value: any): void;
+    /**
+     * Merges the provided value into the current context and emits an update event.
+     */
+    update(value: any): void;
+    /**
+     * Runs registered validation rules on fields inside this viewer (requires {@link AXFormModule} host).
+     */
+    validate(): Promise<AXValidationSummary>;
+    /**
+     * Stable key for visibility map entries (avoids collisions when the same `name` appears twice).
+     */
+    protected propertyVisibilityKey(prop: AXPWidgetProperty): string;
+    /**
+     * Whether a property row should render. Booleans are static; `{{ }}` strings are evaluated against
+     * {@link context} with `context.eval(path)` like {@link AXPWidgetRendererDirective.updateVisibility}.
+     */
+    protected isPropertyVisible(prop: AXPWidgetProperty): boolean;
+    private recomputePropertyVisibility;
+    /**
+     * Handles context changes produced by rendered widgets.
+     */
+    protected handleContextChange(event: AXPContextChangeEvent): void;
+    /**
+     * Handles tab selection changes.
+     */
+    protected handleTabChange(event: AXTabStripChangedEvent): void;
+    /**
+     * Stores collapsed state for a group.
+     */
+    protected handleCollapsedChange(groupName: string, isCollapsed: boolean): void;
+    /**
+     * Returns the config path used for the binding value (and expression) for a property with binding.enabled.
+     */
+    protected getExpressionPath(prop: AXPWidgetProperty): string;
+    /**
+     * True when the property is in "expression" mode: show only the expression editor button, not the widget.
+     * Uses expressionModeState when set; otherwise derives from template `{{ }}` expressions and, when
+     * {@link AXPWidgetProperty.binding} is enabled, bare scripts persisted without wrappers.
+     */
+    protected isExpressionMode(prop: AXPWidgetProperty): boolean;
+    /**
+     * Returns the default value when switching from expression to value mode.
+     * Source of truth is prop.schema.defaultValue (widget.types): plain value, or function (context) => value.
+     * A minimal dataType fallback is used only when the schema provides no default.
+     */
+    private getDefaultValueForProperty;
+    /**
+     * Updates the expression/value toggle state for a binding-enabled property.
+     * When switching to value: resets the value at path to a type-appropriate default so the
+     * widget renderer does not receive the expression string (e.g. checkbox gets false, not a string).
+     * When switching to expression: sets the value at path to an empty string so the editor starts
+     * blank instead of keeping the previous literal (e.g. true/false).
+     */
+    protected setExpressionMode(prop: AXPWidgetProperty, useExpression: boolean): void;
+    /**
+     * Current binding expression string at the property path (for inline editor ngModel).
+     */
+    protected getBindingExpressionValue(prop: AXPWidgetProperty): string;
+    /**
+     * Persists inline code editor changes into context.
+     */
+    protected setBindingExpressionValue(prop: AXPWidgetProperty, value: string): void;
+    /**
+     * Opens the binding/expression code editor for a property with binding.enabled.
+     * Ensures the value passed to the popup is always a string to avoid code-editor crashes.
+     */
+    protected openBindingEditor(prop: AXPWidgetProperty): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPPropertyViewerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPPropertyViewerComponent, "axp-property-viewer", never, { "tabsInput": { "alias": "tabsInput"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "bindingExpressionEditorMode": { "alias": "bindingExpressionEditorMode"; "required": false; "isSignal": true; }; }, { "onChanged": "onChanged"; }, never, never, true, never>;
+}
+
+/**
+ * Whether a binding-enabled property should show expression UI (toggle to code + open editor)
+ * instead of the literal widget.
+ *
+ * - Values already wrapped in `{{ ... }}` are expressions (see `AXPExpressionEvaluatorService.isExpression`).
+ * - Persisted domain data often stores **bare** scripts; for `dataType: 'boolean'` (typical toggle + binding),
+ *   any non-empty string that is not a boolean literal is treated as an expression.
+ * - For `number`, strings that are not plain numeric literals are treated as expressions.
+ * - For other types, `isLikelyBareBindingScript` reduces false positives for plain text.
+ */
+declare function isPropertyBindingExpressionFormValue(property: AXPWidgetProperty, value: unknown, isTemplateExpression: (s: string) => boolean): boolean;
+
+declare class AXPPropertyViewerPopupComponent extends AXBasePageComponent {
+    private readonly toastService;
+    private readonly translationService;
+    tabs: _angular_core.InputSignal<AXPPropertyViewerTab[]>;
+    mode: _angular_core.InputSignal<"simple" | "advanced">;
+    context: _angular_core.InputSignal<any>;
+    /**
+     * Optional hook from `data.onApply`. Throw or reject to keep the popup open.
+     * Return a value (not `undefined`) to use as the `close()` payload; otherwise `{ values, mode }` is used.
+     */
+    onApply?: (result: AXPPropertyViewerResult) => void | Promise<unknown>;
+    protected readonly propertyViewer: _angular_core.Signal<AXPPropertyViewerComponent | undefined>;
+    protected readonly currentValues: _angular_core.WritableSignal<Record<string, unknown>>;
+    protected readonly isApplying: _angular_core.WritableSignal<boolean>;
+    protected currentMode: 'init' | 'update';
+    constructor();
+    protected handlePropertyChanged(event: AXPPropertyViewerChangedEvent): void;
+    protected handleCloseClick(): void;
+    protected handleApplyClick(): Promise<void>;
+    private showValidationErrorToast;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPPropertyViewerPopupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPPropertyViewerPopupComponent, "axp-property-viewer-popup", never, { "tabs": { "alias": "tabs"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface IAXPPropertyViewerRoot {
+    dialog<T = unknown>(delegate: (container: IAXPPropertyViewerDialogBuilder<T>) => void): IAXPPropertyViewerDialogBuilder<T>;
+}
+interface IAXPPropertyViewerDialogBuilder<T = unknown> {
+    setTitle(title: string): IAXPPropertyViewerDialogBuilder<T>;
+    setSize(size: AXPopupSizeType): IAXPPropertyViewerDialogBuilder<T>;
+    setCloseButton(closeButton: boolean): IAXPPropertyViewerDialogBuilder<T>;
+    setContext(context: any): IAXPPropertyViewerDialogBuilder<T>;
+    setTabs(tabs: AXPPropertyViewerTab[]): IAXPPropertyViewerDialogBuilder<T>;
+    setMode(mode: 'simple' | 'advanced'): IAXPPropertyViewerDialogBuilder<T>;
+    /**
+     * Runs on Save. Throw or reject to keep the popup open (same idea as layout dialog `onAction`).
+     * Return a value to resolve `show()`; omit return (or return void) to resolve with `{ values, mode }`.
+     */
+    onAction(handler: (dialogRef: AXPPropertyViewerActionRef) => T | Promise<T> | void | Promise<void>): IAXPPropertyViewerDialogBuilder<T>;
+    show(): Promise<T | AXPPropertyViewerResult | null>;
+}
+interface AXPPropertyViewerConfig {
+    title: string;
+    tabs: AXPPropertyViewerTab[];
+    context?: any;
+    mode?: 'simple' | 'advanced';
+    size?: AXPopupSizeType;
+    /**
+     * When set, runs before close on Save. Throw or reject to keep the popup open.
+     */
+    onApply?: (result: AXPPropertyViewerResult) => void | Promise<void>;
+}
+declare class AXPPropertyViewerService {
+    private readonly popupService;
+    private readonly defaultMultiLanguageConfig;
+    /**
+     * Same entry shape as `layoutBuilder.create()` — use `.dialog((d) => { ... }).show()`.
+     */
+    create(): IAXPPropertyViewerRoot;
+    /**
+     * Opens the property viewer popup in one call (delegates to {@link #create} `.dialog().show()`).
+     */
+    open(config: AXPPropertyViewerConfig): Promise<AXPPropertyViewerResult | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPPropertyViewerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPPropertyViewerService>;
+}
+
+/**
+ * Copies {@link AXPWidgetProperty.validations} onto `schema.interface.options` so the property
+ * viewer binds a stable widget node.
+ */
+declare function withValidationsOnEditorNode(prop: AXPWidgetProperty): AXPWidgetProperty;
+declare function preparePropertyForViewer(prop: AXPWidgetProperty, applyDefaultMultiLanguage: boolean): AXPWidgetProperty;
+/**
+ * Deep-clone-safe: mutates cloned tab trees only when caller passes a fresh clone.
+ * Applies the same widget-property pipeline as {@link AXPPropertyViewerComponent}.
+ */
+declare function preparePropertyViewerTabs(tabs: AXPPropertyViewerTab[], applyDefaultMultiLanguage: boolean): AXPPropertyViewerTab[];
+/**
+ * Builds a single "General" tab for {@link AXPPropertyViewerService} from {@link AXPWidgetProperty} rows
+ * (schema shape is shared with widget metadata; the edited payload is arbitrary context, not an {@link AXPWidgetNode}).
+ */
+declare function buildPropertyViewerTabsFromProperties(properties: AXPWidgetProperty[]): AXPPropertyViewerTab[];
+/**
+ * Initial {@link AXPPropertyViewerService#setContext} value: property default paths merged with the current saved values.
+ */
+declare function buildPropertyViewerInitialContextFromProperties(properties: AXPWidgetProperty[], existing: Record<string, unknown>): Record<string, unknown>;
+
+/**
+ * Presentational layout for indexed rows: optional drag-and-drop, remove controls,
+ * empty state, and add action. Row body is provided via {@link rowTemplate}.
+ */
+declare class AXPRepeaterRowsLayoutComponent {
+    count: _angular_core.InputSignal<number>;
+    disabled: _angular_core.InputSignal<boolean>;
+    hasControls: _angular_core.InputSignal<boolean>;
+    allowReorder: _angular_core.InputSignal<boolean>;
+    rowTemplate: _angular_core.InputSignal<TemplateRef<{
+        index: number;
+    }>>;
+    /** i18n keys (e.g. `@general:...`) for labels; override per usage. */
+    addItemLabelKey: _angular_core.InputSignal<string>;
+    emptyTitleKey: _angular_core.InputSignal<string>;
+    emptyDescriptionKey: _angular_core.InputSignal<string>;
+    addFirstItemLabelKey: _angular_core.InputSignal<string>;
+    addClick: _angular_core.OutputEmitterRef<void>;
+    removeClick: _angular_core.OutputEmitterRef<number>;
+    drop: _angular_core.OutputEmitterRef<AXDropListDroppedEvent>;
+    protected readonly rowIndices: _angular_core.Signal<number[]>;
+    protected readonly rowRowClass: _angular_core.Signal<string>;
+    protected onDrop(e: AXDropListDroppedEvent): void;
+    protected onAddClick(): void;
+    protected onRemoveClick(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPRepeaterRowsLayoutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPRepeaterRowsLayoutComponent, "axp-repeater-rows-layout", never, { "count": { "alias": "count"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hasControls": { "alias": "hasControls"; "required": false; "isSignal": true; }; "allowReorder": { "alias": "allowReorder"; "required": false; "isSignal": true; }; "rowTemplate": { "alias": "rowTemplate"; "required": true; "isSignal": true; }; "addItemLabelKey": { "alias": "addItemLabelKey"; "required": false; "isSignal": true; }; "emptyTitleKey": { "alias": "emptyTitleKey"; "required": false; "isSignal": true; }; "emptyDescriptionKey": { "alias": "emptyDescriptionKey"; "required": false; "isSignal": true; }; "addFirstItemLabelKey": { "alias": "addFirstItemLabelKey"; "required": false; "isSignal": true; }; }, { "addClick": "addClick"; "removeClick": "removeClick"; "drop": "drop"; }, never, never, true, never>;
+}
+
+declare class AXPQuerySortsComponent {
+    sortDefinitions: _angular_core.ModelSignal<AXPSortDefinition[]>;
+    sortQueries: _angular_core.WritableSignal<AXPSortQuery[]>;
+    initialSortQueries: _angular_core.InputSignal<AXPSortQuery[]>;
+    sortQueriesChange: _angular_core.OutputEmitterRef<AXPSortQuery[]>;
+    constructor();
+    protected drop(event: CdkDragDrop<unknown[]>): void;
+    getSortDirection(item: AXPSortDefinition): "desc" | "asc" | undefined;
+    protected changeItemSort(item: AXPSortDefinition): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQuerySortsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQuerySortsComponent, "axp-query-sorts", never, { "sortDefinitions": { "alias": "sortDefinitions"; "required": false; "isSignal": true; }; "initialSortQueries": { "alias": "initialSortQueries"; "required": false; "isSignal": true; }; }, { "sortDefinitions": "sortDefinitionsChange"; "sortQueriesChange": "sortQueriesChange"; }, never, never, true, never>;
+}
+
+/**
+ * Represents a spreadsheet item (row or column header) with id, text, and optional description
+ */
+interface AXPSpreadsheetItem {
+    id: string;
+    title: string;
+    description?: string;
+    /**
+     * Optional CSS class for cell styling (e.g., 'ax-bg-success-lightest ax-text-success' for green)
+     * Used when this item is used as a cell value to color-code the cell
+     * Allows proper control of both background and text colors
+     */
+    cssClass?: string;
+}
+/**
+ * Represents the value structure for spreadsheet cells
+ * Stores only the ID reference to the item in cellOptions
+ */
+type AXPSpreadsheetCellValue = string | null;
+/**
+ * Matrix data structure: { [rowId]: { [columnId]: cellValueId } }
+ * cellValueId is the ID of an item from cellOptions
+ */
+type AXPSpreadsheetData = Record<string, Record<string, AXPSpreadsheetCellValue>>;
+/**
+ * Represents a column definition in the spreadsheet
+ */
+interface AXPSpreadsheetColumn {
+    /**
+     * Column identifier (unique name)
+     */
+    name: string;
+    /**
+     * Display title for column header
+     */
+    title: string;
+    /**
+     * Optional description for column header
+     */
+    description?: string;
+    /**
+     * Path to access row property (e.g., 'user.name', 'age')
+     * Used to get/set values in row objects
+     */
+    path: string;
+    /**
+     * Widget configuration for this column
+     * All cells in this column will use this widget
+     */
+    widget: AXPWidgetNode;
+    /**
+     * Optional column width
+     */
+    width?: string;
+    /**
+     * Column-level readonly override
+     */
+    readonly?: boolean;
+}
+/**
+ * Spreadsheet row mode
+ * - 'fixed': Rows are provided as input, cannot add/remove (like matrix)
+ * - 'dynamic': Users can add/remove rows dynamically (like Excel)
+ */
+type AXPSpreadsheetRowMode = 'fixed' | 'dynamic';
+/**
+ * Event emitted when a single cell value changes
+ */
+interface AXPSpreadsheetCellChangeEvent {
+    /**
+     * Row identifier (name for fixed mode, generated ID for dynamic mode)
+     */
+    rowId: string;
+    /**
+     * Column name
+     */
+    columnName: string;
+    /**
+     * New cell value (whatever the widget returns)
+     */
+    value: any;
+    /**
+     * Full row object after update
+     */
+    row: Record<string, any>;
+}
+/**
+ * Event emitted when a row is added or removed (dynamic mode only)
+ */
+interface AXPSpreadsheetRowChangeEvent {
+    /**
+     * Type of change: 'add' or 'remove'
+     */
+    type: 'add' | 'remove';
+    /**
+     * Row identifier
+     */
+    rowId: string;
+    /**
+     * Full row object (for 'add' events)
+     */
+    row?: Record<string, any>;
+    /**
+     * All rows after the change
+     */
+    rows: Record<string, any>[];
+}
+/**
+ * Configuration for the spreadsheet component
+ */
+interface AXPSpreadsheetConfig {
+    /**
+     * Widget configuration for cell editing (SelectBox)
+     */
+    cellWidget?: AXPWidgetNode;
+    /**
+     * Whether the spreadsheet is in readonly mode
+     */
+    readonly?: boolean;
+    /**
+     * Placeholder text for empty cells
+     */
+    emptyCellPlaceholder?: string;
+}
+
+declare class AXPSpreadsheetComponent {
+    protected readonly translationService: AXTranslationService;
+    /**
+     * Translated column titles
+     */
+    protected translatedColumnTitles: _angular_core.WritableSignal<Map<string, string>>;
+    /**
+     * Title for the spreadsheet (displayed in corner cell)
+     */
+    title: _angular_core.InputSignal<string>;
+    /**
+     * Column definitions
+     */
+    columns: _angular_core.InputSignal<AXPSpreadsheetColumn[]>;
+    /**
+     * Row mode: 'fixed' or 'dynamic'
+     */
+    rowMode: _angular_core.InputSignal<AXPSpreadsheetRowMode>;
+    /**
+     * Rows data (for fixed mode - input only)
+     * Each row must have a 'name' property for identification
+     */
+    rowsInput: _angular_core.InputSignal<Record<string, any>[]>;
+    /**
+     * Rows data (for dynamic mode - two-way binding)
+     */
+    rowsModel: _angular_core.ModelSignal<Record<string, any>[]>;
+    /**
+     * Whether the spreadsheet is in readonly mode
+     */
+    readonly: _angular_core.InputSignal<boolean>;
+    /**
+     * Placeholder text for empty cells (default: "–")
+     */
+    emptyCellPlaceholder: _angular_core.InputSignal<string>;
+    /**
+     * Path to property in row object to display as row header title
+     * Example: 'name', 'title', 'user.name'
+     */
+    rowTitlePath: _angular_core.InputSignal<string | null>;
+    /**
+     * Path to property in row object to display as row header description
+     * Example: 'description', 'details', 'user.description'
+     */
+    rowDescriptionPath: _angular_core.InputSignal<string | null>;
+    /**
+     * Whether to allow adding rows (dynamic mode only, default: true)
+     */
+    allowAddRows: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether to allow removing rows (default: true for dynamic mode, false for fixed mode)
+     * Can be enabled for fixed mode if needed
+     */
+    allowRemoveRows: _angular_core.InputSignal<boolean>;
+    /**
+     * Emitted when a single cell value changes
+     */
+    cellChange: _angular_core.OutputEmitterRef<AXPSpreadsheetCellChangeEvent>;
+    /**
+     * Emitted when rows are added or removed (dynamic mode only)
+     */
+    rowChange: _angular_core.OutputEmitterRef<AXPSpreadsheetRowChangeEvent>;
+    /**
+     * Emitted when the entire spreadsheet data changes
+     */
+    spreadsheetChange: _angular_core.OutputEmitterRef<Record<string, any>[]>;
+    /**
+     * Currently editing cell: { rowId, columnName } | null
+     */
+    protected editingCell: _angular_core.WritableSignal<{
+        rowId: string;
+        columnName: string;
+    } | null>;
+    /**
+     * Original value when entering edit mode (for cancel functionality)
+     */
+    private originalCellValue;
+    /**
+     * Internal rows state (for fixed mode)
+     */
+    private internalRows;
+    /**
+     * Row ID mapping: rowId -> row index (for tracking)
+     */
+    private rowIdMap;
+    /**
+     * Cache for widget nodes to prevent re-rendering
+     * Key: `${rowIndex}_${columnName}`, Value: AXPWidgetNode
+     */
+    private widgetNodeCache;
+    /**
+     * Cache for cell values to detect actual changes
+     * Key: `${rowIndex}_${columnName}`, Value: any
+     */
+    private cellValueCache;
+    /**
+     * Get current rows based on mode
+     */
+    protected currentRows: _angular_core.Signal<Record<string, any>[]>;
+    /**
+     * Context for widgets-container (all rows as an object with rows array)
+     * This allows widgets to access their cell via path like: rows[index].column.path
+     */
+    protected spreadsheetContext: _angular_core.Signal<{
+        rows: Record<string, any>[];
+    }>;
+    /**
+     * Get rows with IDs (ensure all rows have identifiers)
+     */
+    protected rowsWithIds: _angular_core.Signal<{
+        rowId: string;
+        row: Record<string, any>;
+    }[]>;
+    /**
+     * Check if spreadsheet is completely empty (both columns and rows)
+     */
+    protected isEmpty: _angular_core.Signal<boolean>;
+    /**
+     * Check if columns are empty (regardless of rows)
+     * When columns are empty, we should show a message about missing columns, not rows
+     */
+    protected isColumnsEmpty: _angular_core.Signal<boolean>;
+    /**
+     * Check if only rows are empty (columns exist but no rows)
+     */
+    protected isRowsEmpty: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Get the value for a specific cell by row index
+     */
+    protected getCellValue(rowIndex: number, columnName: string): any;
+    /**
+     * Get row title from row object using rowTitlePath
+     */
+    protected getRowTitle(row: Record<string, any>, path: string): string;
+    /**
+     * Get row description from row object using rowDescriptionPath
+     */
+    protected getRowDescription(row: Record<string, any>, path: string): string;
+    /**
+     * Get row by ID
+     */
+    protected getRowById(rowId: string): Record<string, any> | null;
+    /**
+     * Check if a cell is currently being edited
+     */
+    protected isCellEditing(rowId: string, columnName: string): boolean;
+    /**
+     * Check if a column is readonly
+     */
+    protected isColumnReadonly(column: AXPSpreadsheetColumn): boolean;
+    /**
+     * Get widget node for a cell with dynamic path based on row index
+     * Path format: rows[rowIndex].column.path
+     * Uses caching to prevent unnecessary re-renders
+     */
+    protected getCellWidgetNode(column: AXPSpreadsheetColumn, rowIndex: number): AXPWidgetNode;
+    /**
+     * Handle cell click to start editing
+     */
+    protected handleCellClick(rowId: string, columnName: string, event?: MouseEvent): void;
+    /**
+     * Handle cell value change from widget
+     * The widget sets the value at path like rows[index].column.path
+     */
+    protected handleCellValueChange(rowIndex: number, columnName: string, event: AXPContextChangeEvent): void;
+    /**
+     * Handle spreadsheet context change from widgets-container
+     * This is called when any widget in the spreadsheet changes
+     */
+    protected handleSpreadsheetContextChange(event: AXPContextChangeEvent): void;
+    /**
+     * Handle blur event to stop editing (when user clicks away from cell)
+     */
+    protected handleCellBlur(rowId: string, columnName: string): void;
+    /**
+     * Handle Escape key to cancel editing
+     */
+    protected handleKeyDown(event: KeyboardEvent): void;
+    /**
+     * Commit cell edit (save changes and close editing mode)
+     */
+    protected commitCellEdit(): void;
+    /**
+     * Cancel cell edit (discard changes and close editing mode - same as escape)
+     */
+    protected cancelCellEdit(): void;
+    /**
+     * Handle click outside to stop editing
+     */
+    protected handleClickOutside(event: MouseEvent): void;
+    /**
+     * Handle add row (dynamic mode only)
+     */
+    protected handleAddRow(): void;
+    /**
+     * Handle remove row (works for both fixed and dynamic modes)
+     */
+    protected handleRemoveRow(rowId: string, _event: AXClickEvent): void;
+    /**
+     * Generate unique row ID for dynamic mode
+     */
+    private generateRowId;
+    /**
+     * Update rows array (sync internal state)
+     */
+    private updateRows;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPSpreadsheetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPSpreadsheetComponent, "axp-spreadsheet", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rowMode": { "alias": "rowMode"; "required": false; "isSignal": true; }; "rowsInput": { "alias": "rowsInput"; "required": false; "isSignal": true; }; "rowsModel": { "alias": "rowsModel"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "emptyCellPlaceholder": { "alias": "emptyCellPlaceholder"; "required": false; "isSignal": true; }; "rowTitlePath": { "alias": "rowTitlePath"; "required": false; "isSignal": true; }; "rowDescriptionPath": { "alias": "rowDescriptionPath"; "required": false; "isSignal": true; }; "allowAddRows": { "alias": "allowAddRows"; "required": false; "isSignal": true; }; "allowRemoveRows": { "alias": "allowRemoveRows"; "required": false; "isSignal": true; }; }, { "rowsModel": "rowsModelChange"; "cellChange": "cellChange"; "rowChange": "rowChange"; "spreadsheetChange": "spreadsheetChange"; }, never, never, true, never>;
+}
+
+type StateMode = 'empty' | 'error' | 'loading' | 'warning' | 'info' | 'success';
+declare class AXPStateMessageComponent {
+    mode: _angular_core.InputSignal<StateMode>;
+    icon: _angular_core.InputSignal<string>;
+    title: _angular_core.InputSignal<string>;
+    description: _angular_core.InputSignal<string>;
+    variant: _angular_core.InputSignal<"default" | "compact" | "minimal">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPStateMessageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPStateMessageComponent, "axp-state-message", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["[slot=actions]"], true, never>;
+}
+
+declare class AXPStopwatchComponent implements OnDestroy {
+    mode: _angular_core.InputSignal<"count-up" | "count-down">;
+    timeLimit: _angular_core.InputSignal<number | undefined>;
+    format: _angular_core.InputSignal<"hh:mm:ss" | "mm:ss" | "ss">;
+    autoStart: _angular_core.InputSignal<boolean>;
+    showControls: _angular_core.InputSignal<boolean>;
+    value: _angular_core.InputSignal<number>;
+    valueChange: _angular_core.OutputEmitterRef<number>;
+    timeUp: _angular_core.OutputEmitterRef<void>;
+    private readonly currentTime;
+    protected readonly isRunning: _angular_core.WritableSignal<boolean>;
+    private intervalId;
+    protected readonly isTimeUp: _angular_core.Signal<boolean>;
+    protected readonly displayTime: _angular_core.Signal<string>;
+    constructor();
+    ngOnDestroy(): void;
+    start(): void;
+    pause(): void;
+    reset(): void;
+    private stop;
+    private onTimeUp;
+    private formatTime;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPStopwatchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPStopwatchComponent, "axp-stopwatch", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "timeLimit": { "alias": "timeLimit"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "autoStart": { "alias": "autoStart"; "required": false; "isSignal": true; }; "showControls": { "alias": "showControls"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "timeUp": "timeUp"; }, never, never, true, never>;
+}
+
+/**
+ * Builds the AXPWidgetNode tree for the table-columns-editor when using AXPLayoutRendererComponent.
+ * Root: repeater-layout (path: 'columns') with add/remove controls.
+ * Each row: form-field for name (text-editor), form-field for title (text-editor), form-field for widget (widget-field-configurator).
+ */
+declare function buildTableColumnsEditorLayout(): AXPWidgetNode;
+
+/**
+ * Definition for a single table column (name, title, widget).
+ * Used by table-columns-editor and table-data-editor.
+ */
+interface AXPTableColumnDefinition {
+    name: string;
+    title: string;
+    widget: AXPWidgetNode;
+}
+
+declare class AXPTableColumnsEditorPopupComponent extends AXBasePageComponent {
+    protected readonly I18N: {
+        readonly title: "@general:widgets.table-columns-editor.popup-title";
+        readonly cancel: "@general:actions.cancel.title";
+        readonly save: "@general:actions.save.title";
+    };
+    columns: _angular_core.InputSignal<AXPTableColumnDefinition[]>;
+    localColumns: _angular_core.ModelSignal<AXPTableColumnDefinition[]>;
+    constructor();
+    protected handleCancel(): void;
+    protected handleSave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTableColumnsEditorPopupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPTableColumnsEditorPopupComponent, "axp-table-columns-editor-popup", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "localColumns": { "alias": "localColumns"; "required": false; "isSignal": true; }; }, { "localColumns": "localColumnsChange"; }, never, never, true, never>;
+}
+
+declare class AXPTableColumnsEditorComponent {
+    /** Layout tree: repeater (path: columns) with form-fields for name, title, widget. */
+    protected readonly columnsEditorLayout: _angular_core.WritableSignal<_acorex_platform_layout_widget_core.AXPWidgetNode>;
+    /** Two-way: list of column definitions (synced with editorContext.columns). */
+    columns: _angular_core.ModelSignal<AXPTableColumnDefinition[]>;
+    /** Context for the layout renderer; must hold { columns: AXPTableColumnDefinition[] }. */
+    protected readonly editorContext: _angular_core.ModelSignal<{
+        columns: AXPTableColumnDefinition[];
+    }>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTableColumnsEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPTableColumnsEditorComponent, "axp-table-columns-editor", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "editorContext": { "alias": "editorContext"; "required": false; "isSignal": true; }; }, { "columns": "columnsChange"; "editorContext": "editorContextChange"; }, never, never, true, never>;
+}
+
+interface AXPTableColumnsEditorOpenOptions {
+    title?: string;
+    columns?: AXPTableColumnDefinition[];
+}
+declare class AXPTableColumnsEditorService {
+    private readonly popupService;
+    private readonly translationService;
+    open(options?: AXPTableColumnsEditorOpenOptions): Promise<AXPTableColumnDefinition[] | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTableColumnsEditorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTableColumnsEditorService>;
+}
+
+declare class AXPTableDataEditorPopupComponent extends AXBasePageComponent {
+    protected readonly I18N: {
+        readonly title: "@general:widgets.table-data-editor.popup-title";
+        readonly cancel: "@general:actions.cancel.title";
+        readonly save: "@general:actions.save.title";
+    };
+    columns: _angular_core.InputSignal<AXPTableColumnDefinition[]>;
+    rows: _angular_core.InputSignal<Record<string, unknown>[]>;
+    localRows: _angular_core.ModelSignal<Record<string, unknown>[]>;
+    constructor();
+    protected handleCancel(): void;
+    protected handleSave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTableDataEditorPopupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPTableDataEditorPopupComponent, "axp-table-data-editor-popup", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "localRows": { "alias": "localRows"; "required": false; "isSignal": true; }; }, { "localRows": "localRowsChange"; }, never, never, true, never>;
+}
+
+declare class AXPTableDataEditorComponent {
+    columns: _angular_core.InputSignal<AXPTableColumnDefinition[]>;
+    rowsModel: _angular_core.ModelSignal<Record<string, unknown>[]>;
+    protected readonly spreadsheetColumns: _angular_core.Signal<AXPSpreadsheetColumn[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTableDataEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPTableDataEditorComponent, "axp-table-data-editor", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rowsModel": { "alias": "rowsModel"; "required": false; "isSignal": true; }; }, { "rowsModel": "rowsModelChange"; }, never, never, true, never>;
+}
+
+interface AXPTableDataEditorOpenOptions {
+    title?: string;
+    columns: AXPTableColumnDefinition[];
+    rows?: Record<string, unknown>[];
+}
+declare class AXPTableDataEditorService {
+    private readonly popupService;
+    private readonly translationService;
+    open(options: AXPTableDataEditorOpenOptions): Promise<Record<string, unknown>[] | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTableDataEditorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTableDataEditorService>;
+}
+
+interface AXPTemplateViewerConfig {
+    template: AXPWidgetNode | string;
+    title?: string;
+    size?: AXPopupSizeType;
+    context?: any;
+    metadata?: AXPMetaData;
+    readOnly?: boolean;
+    showActions?: boolean;
+}
+interface AXPTemplateViewerResult {
+    context: any;
+    cancelled: boolean;
+    metadata?: AXPMetaData;
+}
+
+declare class AXPTemplateViewerComponent extends AXBasePageComponent {
+    set config(value: AXPTemplateViewerConfig | undefined);
+    get config(): AXPTemplateViewerConfig | undefined;
+    protected context: any;
+    protected readonly document: _angular_core.WritableSignal<AXPWidgetNode>;
+    protected readonly currentPageIndex: _angular_core.WritableSignal<number>;
+    protected readonly _config: _angular_core.WritableSignal<AXPTemplateViewerConfig | undefined>;
+    protected readonly currentPage: _angular_core.Signal<AXPWidgetNode>;
+    protected ngOnInit(): Promise<void>;
+    private loadTemplate;
+    protected handleContextChanged(e: AXPContextChangeEvent): void;
+    protected handleSubmit(form: AXFormComponent): Promise<void>;
+    protected handleCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTemplateViewerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPTemplateViewerComponent, "axp-template-viewer", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AXPTemplateViewerService {
+    private readonly popupService;
+    /**
+     * Show a template viewer dialog with the given configuration
+     * @param config Template viewer configuration including template, title, and UI options
+     * @returns Promise resolving to viewer result with form values and cancellation status
+     */
+    showTemplate(config: AXPTemplateViewerConfig): Promise<AXPTemplateViewerResult>;
+    /**
+     * Show a template viewer in read-only mode
+     * @param config Template viewer configuration
+     * @returns Promise resolving to viewer result
+     */
+    showTemplateReadOnly(config: Omit<AXPTemplateViewerConfig, 'readOnly' | 'showActions'>): Promise<AXPTemplateViewerResult>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTemplateViewerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTemplateViewerService>;
+}
+
+/**
+ * Generic avatar renderer with image and initials fallback.
+ */
+declare class AXPAvatarComponent {
+    /** Avatar size in pixels. */
+    readonly size: _angular_core.InputSignal<number>;
+    /** Optional image source for the avatar. */
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    /** Display name used for title and initials fallback. */
+    readonly fullName: _angular_core.InputSignal<string | undefined>;
+    /** Optional override for fallback text shown when image is not available. */
+    readonly fallbackText: _angular_core.InputSignal<string | undefined>;
+    /** Forces placeholder mode and '?' fallback. */
+    readonly placeholder: _angular_core.InputSignal<boolean>;
+    protected readonly isAvatarLoaded: _angular_core.WritableSignal<boolean>;
+    protected readonly normalizedName: _angular_core.Signal<string>;
+    protected readonly resolvedSrc: _angular_core.Signal<string>;
+    protected readonly hasAvatar: _angular_core.Signal<boolean>;
+    protected readonly isLoading: _angular_core.Signal<boolean>;
+    protected readonly avatarText: _angular_core.Signal<string>;
+    protected readonly avatarColor: _angular_core.Signal<string>;
+    protected readonly title: _angular_core.Signal<string>;
+    protected onImageError(event: AXHtmlEvent<ErrorEvent>): void;
+    protected onImageLoad(event: AXHtmlEvent<Event>): void;
+    private computeInitials;
+    private hashString;
+    private pickColor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPAvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPAvatarComponent, "axp-avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; "fullName": { "alias": "fullName"; "required": false; "isSignal": true; }; "fallbackText": { "alias": "fallbackText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type AXPUserAvatarSize = 'small' | 'medium' | 'large';
+type AXPUserAvatarStatus = 'online' | 'offline';
+type AXPUserAvatarData = {
+    id: string;
+    status: AXPUserAvatarStatus;
+    username: string;
+    firstName: string;
+    lastName?: string;
+    avatarUrl?: string;
+};
+interface AXPUserAvatarProvider {
+    provide(userId: string): Promise<AXPUserAvatarData>;
+}
+
+declare class AXPUserAvatarService {
+    private provider;
+    private readonly cacheExpiryTime;
+    private readonly refreshInterval;
+    private cache;
+    /**
+     * Gets user information with caching and auto-refresh
+     * @param userId The username to fetch information for
+     * @returns Observable that emits user avatar data
+     */
+    getUserInfo$(userId: string): Observable<AXPUserAvatarData>;
+    /**
+     * Gets user information (Promise-based for backward compatibility)
+     * @param userId The username to fetch information for
+     * @returns Promise that resolves to user avatar data
+     */
+    getUserInfo(userId: string): Promise<AXPUserAvatarData>;
+    /**
+     * Clears the entire cache or a specific user's cache
+     * @param userId Optional username to clear specific cache
+     */
+    clearCache(userId?: string): void;
+    /**
+     * Force refresh data for a specific username
+     * @param userId The username to refresh
+     * @returns Promise that resolves to the refreshed data
+     */
+    refreshUserInfo(userId: string): Promise<AXPUserAvatarData>;
+    /**
+     * Checks if a cache entry is expired
+     */
+    private isExpired;
+    /**
+     * Fetches data from provider and updates the cache
+     */
+    private fetchAndUpdateCache;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPUserAvatarService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPUserAvatarService>;
+}
+
+declare const AXP_USER_AVATAR_PROVIDER: InjectionToken<AXPUserAvatarProvider>;
+
+declare class AXPUserAvatarComponent implements OnInit, OnDestroy {
+    private readonly userAvatarService;
+    private readonly destroy$;
+    protected userInfo: _angular_core.WritableSignal<AXPUserAvatarData | null>;
+    size: _angular_core.InputSignal<number>;
+    userId: _angular_core.InputSignal<string>;
+    src: _angular_core.WritableSignal<string>;
+    userName: _angular_core.Signal<string>;
+    firstName: _angular_core.Signal<string>;
+    lastName: _angular_core.Signal<string>;
+    title: _angular_core.Signal<string>;
+    isOnline: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private loadUserData;
+    /**
+     * Generate avatar image source
+     * This is a placeholder - implement based on your actual requirements
+     */
+    private generateAvatarSrc;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPUserAvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPUserAvatarComponent, "axp-user-avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "userId": { "alias": "userId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AXPQueryViewsComponent {
+    #private;
+    protected popupService: AXPopupService;
+    protected translate: AXTranslationService;
+    protected tabs: _angular_core.Signal<AXTabsComponent | undefined>;
+    views: _angular_core.ModelSignal<AXPViewQuery[]>;
+    selectedView: _angular_core.ModelSignal<AXPViewQuery>;
+    protected isMounted: _angular_core.WritableSignal<boolean>;
+    ngAfterViewInit(): void;
+    setView(view: AXPViewQuery): void;
+    handleActiveChange(e: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQueryViewsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPQueryViewsComponent, "axp-query-views", never, { "views": { "alias": "views"; "required": false; "isSignal": true; }; "selectedView": { "alias": "selectedView"; "required": true; "isSignal": true; }; }, { "views": "viewsChange"; "selectedView": "selectedViewChange"; }, never, never, true, never>;
+}
+
+/**
+ * One selectable entry for {@link AXPItemConfiguratorComponent}.
+ * Parents map external data into this shape. {@link propertyDefinitions} drive {@link AXPPropertyViewerService} tabs.
+ */
+interface ItemConfiguratorListItem {
+    id: string;
+    /** Shown in the list and in the configure dialog title; plain string, i18n key, or locale map. */
+    title: AXPMultiLanguageString;
+    icon?: string;
+    description?: AXPMultiLanguageString;
+    propertyDefinitions?: AXPWidgetProperty[];
+}
+interface ItemConfiguratorSelectRow {
+    value: string;
+    text: string;
+    icon?: string;
+    description?: string;
+}
+/**
+ * Select an item from a list and edit its settings via {@link AXPPropertyViewerService}.
+ * Bound state: {@link selectedItemId} and {@link values} (context returned from the viewer). Not tied to {@link AXPWidgetNode}.
+ */
+declare class AXPItemConfiguratorComponent {
+    private readonly mlResolver;
+    /** Selected list entry id ({@link ItemConfiguratorListItem.id}). */
+    selectedItemId: _angular_core.ModelSignal<string>;
+    /** Values edited in the property viewer (merged from dialog result). */
+    values: _angular_core.ModelSignal<Record<string, unknown>>;
+    label: _angular_core.InputSignal<string>;
+    readonly: _angular_core.InputSignal<boolean>;
+    items: _angular_core.InputSignal<ItemConfiguratorListItem[]>;
+    headerActions: _angular_core.InputSignal<AXPActionMenuItem[]>;
+    private readonly propertyViewerService;
+    private readonly translationService;
+    private readonly workflow;
+    private readonly commandExecutor;
+    protected isEditMode: _angular_core.WritableSignal<boolean>;
+    protected availableItems: _angular_core.Signal<ItemConfiguratorSelectRow[]>;
+    protected selectedListItem: _angular_core.Signal<ItemConfiguratorListItem | null>;
+    protected resolvedPropertyDefinitions: _angular_core.Signal<AXPWidgetProperty[]>;
+    protected currentItemConfig: _angular_core.Signal<{
+        title: string;
+        description: AXPMultiLanguageString | undefined;
+        icon: string | undefined;
+        hasProperties: boolean;
+    } | null>;
+    protected canConfigure: _angular_core.Signal<boolean>;
+    protected isConfigured: _angular_core.Signal<boolean>;
+    protected visibleHeaderActions: _angular_core.Signal<AXPActionMenuItem[]>;
+    protected itemSelectBox: _angular_core.Signal<AXSelectBoxComponent | undefined>;
+    protected enterEditMode(): void;
+    protected exitEditMode(): void;
+    constructor();
+    protected onSelectionChange(event: {
+        value?: string | null;
+    }): Promise<void>;
+    protected openConfigureDialog(): Promise<void>;
+    protected onHeaderActionClick(action: AXPActionMenuItem): void;
+    protected isHeaderActionDisabled(action: AXPActionMenuItem): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPItemConfiguratorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPItemConfiguratorComponent, "axp-item-configurator", never, { "selectedItemId": { "alias": "selectedItemId"; "required": false; "isSignal": true; }; "values": { "alias": "values"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "headerActions": { "alias": "headerActions"; "required": false; "isSignal": true; }; }, { "selectedItemId": "selectedItemIdChange"; "values": "valuesChange"; }, never, never, true, never>;
+}
+
+/**
+ * Widget field configurator for entity forms: composes {@link AXPItemConfiguratorComponent} with
+ * {@link AXPWidgetRegistryService} list items and widget preview.
+ */
+declare class AXPWidgetFieldConfiguratorComponent {
+    widget: _angular_core.ModelSignal<AXPWidgetNode>;
+    label: _angular_core.InputSignal<string>;
+    fieldName: _angular_core.InputSignal<string>;
+    fieldTitle: _angular_core.InputSignal<AXPMultiLanguageString>;
+    readonly: _angular_core.InputSignal<boolean>;
+    private readonly widgetRegistry;
+    private readonly translation;
+    protected selectedItemIdModel: _angular_core.ModelSignal<string>;
+    protected valuesModel: _angular_core.ModelSignal<Record<string, unknown>>;
+    /**
+     * List entries from {@link AXPWidgetRegistryService} (form editors), with
+     * {@link ItemConfiguratorListItem.propertyDefinitions} from each registered config.
+     */
+    protected configuratorItems: _angular_core.Signal<ItemConfiguratorListItem[]>;
+    protected previewHeaderActions: _angular_core.Signal<AXPActionMenuItem[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetFieldConfiguratorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetFieldConfiguratorComponent, "axp-widget-field-configurator", never, { "widget": { "alias": "widget"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "fieldName": { "alias": "fieldName"; "required": false; "isSignal": true; }; "fieldTitle": { "alias": "fieldTitle"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "selectedItemIdModel": { "alias": "selectedItemIdModel"; "required": false; "isSignal": true; }; "valuesModel": { "alias": "valuesModel"; "required": false; "isSignal": true; }; }, { "widget": "widgetChange"; "selectedItemIdModel": "selectedItemIdModelChange"; "valuesModel": "valuesModelChange"; }, never, never, true, never>;
+}
+
+/**
+ * Generic interface for widget item data
+ */
+interface AXPWidgetItemData {
+    /** Display title of the widget */
+    title: AXPMultiLanguageString;
+    /** Description text for the widget */
+    description?: AXPMultiLanguageString;
+    /** Icon class (e.g., FontAwesome classes) */
+    icon?: string;
+    /** Whether the widget is pinned/favorited */
+    isPinned: boolean;
+    /** Generic data payload - can be any type based on use case */
+    data?: unknown;
+}
+/**
+ * Event data for widget item interactions
+ */
+interface AXPWidgetItemClickEvent<T = unknown> {
+    /** The mouse event */
+    event: MouseEvent;
+    /** The widget item data */
+    widget: AXPWidgetItemData & {
+        data?: T;
+    };
+}
+
+/**
+ * Generic widget item component for displaying selectable widgets with icons, titles, and descriptions.
+ * Can be used across different modules for consistent widget display and interaction.
+ */
+declare class AXPWidgetItemComponent {
+    protected readonly i18n: {
+        readonly pin: "@general:widgets.widget-item.pin";
+        readonly unpin: "@general:widgets.widget-item.unpin";
+    };
+    /** The widget data to display */
+    widget: _angular_core.InputSignal<AXPWidgetItemData>;
+    /** Whether this widget is currently selected */
+    isSelected: _angular_core.InputSignal<boolean>;
+    /** Whether to show the pin button */
+    showPinButton: _angular_core.InputSignal<boolean>;
+    /** Custom CSS classes to apply to the widget item */
+    customClasses: _angular_core.InputSignal<string>;
+    /** Emitted when the widget item is clicked */
+    onWidgetClick: _angular_core.OutputEmitterRef<AXPWidgetItemClickEvent<unknown>>;
+    /** Emitted when the pin button is clicked */
+    onPinClick: _angular_core.OutputEmitterRef<AXPWidgetItemClickEvent<unknown>>;
+    /**
+     * Handle widget item click event
+     */
+    handleClick(event: MouseEvent): void;
+    /**
+     * Handle pin button click event
+     */
+    handlePinClick(event: MouseEvent): void;
+    /**
+     * Get the effective icon to display
+     */
+    getIconClass(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetItemComponent, "axp-widget-item", never, { "widget": { "alias": "widget"; "required": true; "isSignal": true; }; "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; "showPinButton": { "alias": "showPinButton"; "required": false; "isSignal": true; }; "customClasses": { "alias": "customClasses"; "required": false; "isSignal": true; }; }, { "onWidgetClick": "onWidgetClick"; "onPinClick": "onPinClick"; }, never, never, true, never>;
+}
+
+interface AXPWidgetPropertiesChangedEvent {
+    values: any;
+    mode: 'init' | 'update';
+}
+declare class AXPWidgetPropertyViewerComponent {
+    widget: _angular_core.InputSignal<AXPWidgetNode>;
+    mode: _angular_core.InputSignal<"simple" | "advanced">;
+    onChanged: EventEmitter<AXPWidgetPropertiesChangedEvent>;
+    protected readonly propertyViewerRef: _angular_core.Signal<AXPPropertyViewerComponent | undefined>;
+    protected readonly config: _angular_core.WritableSignal<AXPWidgetConfig<any> | null>;
+    protected readonly tabs: _angular_core.WritableSignal<AXPPropertyViewerTab[]>;
+    protected initialContext: Record<string, unknown>;
+    protected groupCollapsedStates: Map<string, boolean>;
+    /** When true, the next onChanged from the inner viewer was caused by our update(); do not forward to avoid loop. */
+    private suppressNextEmit;
+    private readonly widgetRegistryService;
+    constructor();
+    /**
+     * Merges the given values into the property viewer context. Called by the designer when applying changes (e.g. undo/redo).
+     * The inner viewer will emit onChanged; we ignore that emission to avoid designer -> update -> emit -> designer loop.
+     */
+    update(values: any): void;
+    private fillTabs;
+    protected handlePropertyViewerChanged(ev: AXPPropertyViewerChangedEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetPropertyViewerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetPropertyViewerComponent, "axp-widget-property-viewer", never, { "widget": { "alias": "widget"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "onChanged": "onChanged"; }, never, never, true, never>;
+}
+
+declare class AXPWidgetPropertyViewerPopupComponent extends AXBasePageComponent {
+    widget: _angular_core.InputSignal<AXPWidgetNode>;
+    mode: _angular_core.InputSignal<"simple" | "advanced">;
+    protected currentValues: _angular_core.WritableSignal<any>;
+    protected handlePropertyChanged(event: {
+        values: any;
+        mode: 'init' | 'update';
+    }): void;
+    protected handleCloseClick(): void;
+    protected handleApplyClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetPropertyViewerPopupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPWidgetPropertyViewerPopupComponent, "axp-widget-property-viewer-popup", never, { "widget": { "alias": "widget"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface AXPWidgetPropertyInjection {
+    property: AXPWidgetProperty;
+    tab?: {
+        name?: string;
+        title?: string;
+    };
+    group?: {
+        name?: string;
+        title?: string;
+    };
+}
+interface AXPWidgetPropertyViewerConfig {
+    title: string;
+    widget: AXPWidgetNode;
+    mode?: 'simple' | 'advanced';
+    onApply?: (result: AXPWidgetPropertyViewerResult) => void | Promise<void>;
+    /**
+     * Property names to exclude from the viewer.
+     */
+    exclude?: string[];
+    /**
+     * Custom property injection configuration.
+     */
+    custom?: {
+        /**
+         * Custom property injection entries.
+         */
+        properties: AXPWidgetPropertyInjection[];
+        /**
+         * Default tab fallback if property injection doesn't specify one.
+         * When omitted, falls back to the first tab or "general".
+         */
+        defaultTab?: {
+            name?: string;
+            title?: string;
+        };
+        /**
+         * Default group fallback when injection doesn't specify a group.
+         * When omitted, falls back to the tab's first group or property defined group.
+         */
+        defaultGroup?: {
+            name?: string;
+            title?: string;
+        };
+    };
+}
+/** Emitted when the dialog applies; `values` is the updated viewer context (merge into {@link AXPWidgetNode} as needed). */
+interface AXPWidgetPropertyViewerResult {
+    values: any;
+    mode: 'init' | 'update';
+}
+interface IAXPWidgetPropertyViewerRoot {
+    dialog(delegate: (container: IAXPWidgetPropertyViewerDialogBuilder) => void): IAXPWidgetPropertyViewerDialogBuilder;
+}
+interface IAXPWidgetPropertyViewerDialogBuilder {
+    setTitle(title: string): IAXPWidgetPropertyViewerDialogBuilder;
+    /**
+     * Initial widget state shown in the viewer (type, options, name/path, …). Call before {@link show}.
+     */
+    setWidget(widget: AXPWidgetNode): IAXPWidgetPropertyViewerDialogBuilder;
+    setMode(mode: 'simple' | 'advanced'): IAXPWidgetPropertyViewerDialogBuilder;
+    setExclude(exclude: string[]): IAXPWidgetPropertyViewerDialogBuilder;
+    setCustom(custom: AXPWidgetPropertyViewerConfig['custom']): IAXPWidgetPropertyViewerDialogBuilder;
+    /**
+     * When set to a non-empty array, builds tabs from these properties and skips registry lookup for {@link setWidget}'s type.
+     * Omit or clear to resolve widget config from {@link AXPWidgetRegistryService} as usual.
+     */
+    setPropertyDefinitions(properties: AXPWidgetProperty[] | null): IAXPWidgetPropertyViewerDialogBuilder;
+    onAction(handler: (dialogRef: AXPPropertyViewerActionRef) => void | Promise<void> | unknown | Promise<unknown>): IAXPWidgetPropertyViewerDialogBuilder;
+    /**
+     * Applies edits and returns updated context; merge {@link AXPWidgetPropertyViewerResult.values} into your widget node
+     * (typically `options` and any top-level fields the viewer exposes).
+     */
+    show(): Promise<AXPWidgetPropertyViewerResult | null>;
+}
+declare class AXPWidgetPropertyViewerService {
+    private readonly widgetRegistryService;
+    private readonly propertyViewerService;
+    /**
+     * Same shape as `AXPPropertyViewerService.create()` — use `.dialog((d) => { ... }).show()`.
+     */
+    create(): IAXPWidgetPropertyViewerRoot;
+    /**
+     * One-shot open (delegates to {@link #create} `.dialog().show()`).
+     */
+    open(config: AXPWidgetPropertyViewerConfig): Promise<AXPWidgetPropertyViewerResult | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPWidgetPropertyViewerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPWidgetPropertyViewerService>;
+}
+
+/** Scheduler appointment with optional provider tag for context menu routing. */
+type AppointmentWithProvider = AXSchedulerAppointment & {
+    provider?: string;
+};
+declare class AXPResourceAppointmentComponent implements OnInit {
+    /** Show resource headers in the timeline views. */
+    showResourceHeaders: _angular_core.InputSignal<boolean>;
+    /** Show appointments that have no resourceId. */
+    showUnassignedAppointments: _angular_core.InputSignal<boolean>;
+    /** Optional provider name to filter the board (e.g. from route param). */
+    providerName: _angular_core.InputSignal<string | undefined>;
+    private readonly resourceAppointmentService;
+    private readonly formatService;
+    private readonly contextMenu;
+    protected readonly schedulerRef: _angular_core.Signal<AXSchedulerComponent | undefined>;
+    protected readonly isReady: _angular_core.WritableSignal<boolean>;
+    protected readonly currentDate: _angular_core.WritableSignal<Date>;
+    protected readonly currentView: _angular_core.WritableSignal<AXSchedulerView>;
+    private readonly currentAppointment;
+    /** Raw resources returned by providers. */
+    private readonly rawResources;
+    /** Scheduler resources derived from provider data. */
+    protected readonly schedulerResources: _angular_core.Signal<AXSchedulerResource[]>;
+    /** Flat list of scheduler appointments derived from provider data. */
+    protected readonly schedulerAppointments: _angular_core.Signal<AppointmentWithProvider[]>;
+    /** Formatted date range text for the toolbar. */
+    protected readonly timeText: _angular_core.Signal<string>;
+    constructor();
+    ngOnInit(): Promise<void>;
+    private resolveProvidersAndReady;
+    /** Fetches resource + appointment data from providers and updates signals. */
+    private loadData;
+    /** Re-load data when the scheduler view range changes and sync toolbar date. */
+    protected handleRangeChanged(range: AXSchedulerDateRange): void;
+    /** Navigate to previous/next period based on current view. */
+    protected changeDate(forward: boolean): void;
+    /** Fallback formatted date range when scheduler ref is not yet available. */
+    private formatCurrentDateRange;
+    protected handleAppointmentClick(event: {
+        appointment: AXSchedulerAppointment;
+        nativeEvent: MouseEvent;
+    }): void;
+    protected handleContextMenuOpening(event: AXContextMenuOpeningEvent): Promise<void>;
+    protected handleContextMenuItemClick(event: AXContextMenuItemsClickEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPResourceAppointmentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPResourceAppointmentComponent, "axp-resource-appointment", never, { "showResourceHeaders": { "alias": "showResourceHeaders"; "required": false; "isSignal": true; }; "showUnassignedAppointments": { "alias": "showUnassignedAppointments"; "required": false; "isSignal": true; }; "providerName": { "alias": "providerName"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Minimal appointment data for resource appointment board.
+ * Providers return this; the component converts to scheduler/task shape as needed.
+ */
+interface AXPResourceAppointmentItem {
+    readonly id: string | number;
+    title: string;
+    startDate: Date;
+    endDate: Date;
+    resourceId?: string | number;
+    description?: string;
+    allDay?: boolean;
+}
+/**
+ * Represents a status option for the resource appointment board (e.g. column or filter).
+ * Aligned with task board status shape for provider compatibility.
+ */
+interface AXPResourceAppointmentStatus {
+    key: string;
+    index: number;
+    title: string;
+    color?: string;
+}
+/**
+ * Action menu item for resource appointment board with optional priority.
+ * Primary actions are shown as icon-only buttons, secondary in a dropdown.
+ */
+type AXPResourceAppointmentActionMenuItem = AXPActionMenuItem & {
+    priority?: 'primary' | 'secondary';
+};
+interface AXPResourceAppointmentResource {
+    readonly id: string | number;
+    title: string;
+    description?: string;
+    icon?: string;
+    appointments: AXPResourceAppointmentItem[];
+}
+interface AXPResourceAppointmentBoardFilter {
+    range?: AXRange<Date>;
+    statuses?: (string | number)[];
+    resourceIds?: (string | number)[];
+    /** When set, only these providers are queried. */
+    providerNames?: string[];
+}
+declare abstract class AXPResourceAppointmentBoardProvider<T = Record<string, unknown>> {
+    abstract get name(): string;
+    abstract get title(): string;
+    abstract get icon(): string;
+    abstract getList(filter?: AXPResourceAppointmentBoardFilter): Promise<AXPResourceAppointmentResource[]>;
+    abstract getStatuses(): Promise<AXPResourceAppointmentStatus[]>;
+    abstract getActions(context?: AXPResourceAppointmentItem): Promise<AXPResourceAppointmentActionMenuItem[]>;
+    abstract executeCommand(command: AXPExecuteCommand): Promise<AXPExecuteCommandResult>;
+}
+declare const AXP_RESOURCE_APPOINTMENT_PROVIDER: InjectionToken<AXPResourceAppointmentBoardProvider<Record<string, unknown>>[] | Promise<AXPResourceAppointmentBoardProvider<Record<string, unknown>>>[]>;
+
+declare class AXPResourceAppointmentService {
+    private readonly calendarService;
+    private readonly providers;
+    private resolvedProviders;
+    refresh$: Subject<void>;
+    /**
+     * Resolves providers from injected AXP_RESOURCE_APPOINTMENT_PROVIDER.
+     * The service must be provided in an injector that has access to the token (e.g. component providers).
+     */
+    resolveProviders(): Promise<AXPResourceAppointmentBoardProvider[]>;
+    getProviderTypes(): Promise<AXPResourceAppointmentBoardProvider[]>;
+    getProvider(name: string | undefined): AXPResourceAppointmentBoardProvider | null;
+    getList(filter?: AXPResourceAppointmentBoardFilter): Promise<AXPResourceAppointmentResource[]>;
+    getStatuses(providerName: string): Promise<AXPResourceAppointmentStatus[]>;
+    getActions(context: AXPResourceAppointmentItem | undefined, providerName: string): Promise<AXPResourceAppointmentActionMenuItem[]>;
+    executeCommand(command: AXPExecuteCommand, providerName: string): Promise<AXPExecuteCommandResult>;
+    rangeCalculator(type: string): AXRange<Date> | undefined;
+    private findProvider;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPResourceAppointmentService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPResourceAppointmentService>;
+}
+
+/**
+ * Host-owned item row. Required keys are stable; additional keys are persisted by the host mapper.
+ */
+interface AXPBuilderItem {
+    id: string;
+    order: number;
+    [key: string]: unknown;
+}
+/**
+ * Host-owned section. Items live under `items` (not nested host-specific names).
+ */
+interface AXPBuilderSection {
+    id: string;
+    order: number;
+    items: AXPBuilderItem[];
+    [key: string]: unknown;
+}
+interface AXPBuilderValue {
+    sections: AXPBuilderSection[];
+}
+type AXPBuilderBadgeVariant = 'neutral' | 'accent' | 'warning' | 'danger' | 'success';
+interface AXPBuilderBadge {
+    /** Translation key (e.g. `@general:...`) or plain text. */
+    text: string;
+    variant?: AXPBuilderBadgeVariant;
+}
+type AXPBuilderItemIconTone = 'default' | 'easy' | 'medium' | 'hard';
+/**
+ * View model for one item row (icons, labels, badges). Built by {@link AXPBuilderDefinition.mapItemToView}.
+ */
+interface AXPBuilderItemViewModel {
+    icon: string;
+    iconTone?: AXPBuilderItemIconTone;
+    title: string;
+    name?: string;
+    description?: string;
+    badges: AXPBuilderBadge[];
+}
+interface AXPBuilderTexts {
+    addSection: string;
+    addItem: string;
+    emptySectionsTitle: string;
+    emptySectionsDescription: string;
+    emptyItemsTitle: string;
+    emptyItemsDescription: string;
+    /** Shown when {@link AXPBuilderDefinition.isDefaultSection} is true */
+    defaultSectionBadge?: string;
+}
+/**
+ * Declarative configuration for {@link AXPSectionItemsBuilderComponent}.
+ * Prompts return domain slices; the builder assigns `id` / `order` / `items` where needed.
+ */
+interface AXPBuilderDefinition {
+    texts: AXPBuilderTexts;
+    mapItemToView: (item: AXPBuilderItem, section: AXPBuilderSection) => AXPBuilderItemViewModel;
+    /** When true, renders section technical `name` next to the title (parentheses). */
+    showSectionTechnicalName?: boolean;
+    isDefaultSection?(section: AXPBuilderSection): boolean;
+    /** Minimum number of sections (default 1). */
+    minSectionCount?: number;
+    promptAddSection?(value: AXPBuilderValue): Promise<Record<string, unknown> | null>;
+    promptEditSection?(section: AXPBuilderSection, value: AXPBuilderValue): Promise<Record<string, unknown> | null>;
+    promptAddItems?(sectionId: string, value: AXPBuilderValue): Promise<AXPBuilderItem[] | null>;
+    promptEditItem?(item: AXPBuilderItem, sectionId: string, value: AXPBuilderValue): Promise<AXPBuilderItem | null>;
+    confirmRemoveSection?(section: AXPBuilderSection): Promise<boolean>;
+    confirmRemoveItem?(item: AXPBuilderItem, sectionId: string): Promise<boolean>;
+}
+
+declare class AXPSectionItemsBuilderComponent {
+    /** Used in template to branch between escaped text and sanitized HTML. */
+    protected readonly containsHtmlMarkup: typeof containsHtmlMarkup;
+    readonly value: _angular_core.InputSignal<AXPBuilderValue>;
+    readonly definition: _angular_core.InputSignal<AXPBuilderDefinition>;
+    readonly readonlyMode: _angular_core.InputSignal<boolean>;
+    readonly valueChange: _angular_core.OutputEmitterRef<AXPBuilderValue>;
+    private readonly vm;
+    protected readonly sectionsModel: _angular_core.Signal<AXPBuilderValue>;
+    protected readonly sectionRows: _angular_core.Signal<{
+        section: AXPBuilderSection;
+        itemRows: {
+            item: AXPBuilderItem;
+            view: _acorex_platform_layout_components.AXPBuilderItemViewModel;
+        }[];
+    }[]>;
+    protected readonly itemDropListIds: _angular_core.Signal<string[]>;
+    protected readonly canRemoveSection: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Opens add-section flow (same as primary "Add section" control). For page commands / ViewChild.
+     */
+    addSection(): Promise<void>;
+    protected onAddSectionClick(): Promise<void>;
+    protected onEditSection(section: AXPBuilderSection): Promise<void>;
+    protected onRemoveSection(section: AXPBuilderSection): Promise<void>;
+    protected onAddItems(section: AXPBuilderSection): Promise<void>;
+    protected onEditItem(item: AXPBuilderItem, sectionId: string): Promise<void>;
+    protected onRemoveItem(item: AXPBuilderItem, sectionId: string): Promise<void>;
+    protected onSectionDrop(event: CdkDragDrop<AXPBuilderSection[]>): void;
+    protected onItemDrop(event: CdkDragDrop<AXPBuilderItem[]>, targetSectionId: string): void;
+    protected sectionItemsListId(sectionId: string): string;
+    protected parseSectionIdFromDropListId(listId: string): string | null;
+    protected isDefaultSection(section: AXPBuilderSection): boolean;
+    protected isTranslationKey(text: string): boolean;
+    /** Tooltip for rich HTML rows: plain text, no tags. */
+    protected tooltipPlainTextForHtml(html: string): string;
+    /**
+     * Prefer raw section fields for display so {@link AXPMultiLanguageString} maps are not
+     * lost when {@link AXPBuilderDefinition#mapItemToView} stringifies them on items.
+     */
+    protected sectionTitleValue(section: AXPBuilderSection): AXPMultiLanguageString | string;
+    protected sectionNameValue(section: AXPBuilderSection): AXPMultiLanguageString | string | undefined;
+    protected sectionDescriptionValue(section: AXPBuilderSection): AXPMultiLanguageString | string | undefined;
+    /**
+     * Resolves item title/name/description for display: use raw item values when present
+     * (including ML maps); fall back to {@link AXPBuilderItemViewModel} only when needed.
+     */
+    protected itemMultilingualField(item: AXPBuilderItem, field: 'title' | 'name' | 'description', viewFallback?: string | null): AXPMultiLanguageString | string;
+    private commit;
+    private normalizeValue;
+    private reindexSections;
+    private reindexItems;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPSectionItemsBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPSectionItemsBuilderComponent, "axp-section-items-builder", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "definition": { "alias": "definition"; "required": true; "isSignal": true; }; "readonlyMode": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Host configuration for {@link AXPStandardSectionItemsBuilderComponent}.
+ * Section add/edit UI (identity, content, visibility) and delete prompts are standardized;
+ * item flows stay host-specific.
+ */
+interface AXPStandardSectionItemsBuilderConfig {
+    mapItemToView: AXPBuilderDefinition['mapItemToView'];
+    /** When set, used instead of the built-in section add dialog. */
+    promptAddSection?: AXPBuilderDefinition['promptAddSection'];
+    /** When set, used instead of the built-in section edit dialog. */
+    promptEditSection?: AXPBuilderDefinition['promptEditSection'];
+    promptAddItems?: AXPBuilderDefinition['promptAddItems'];
+    promptEditItem?: AXPBuilderDefinition['promptEditItem'];
+    /** Merged over built-in empty-state / action labels */
+    texts?: Partial<AXPBuilderTexts>;
+    showSectionTechnicalName?: boolean;
+    isDefaultSection?: AXPBuilderDefinition['isDefaultSection'];
+    minSectionCount?: number;
+    /**
+     * Property viewer tabs for section add/edit.
+     * Default: {@link STANDARD_SECTION_ITEMS_SECTION_TABS}.
+     */
+    sectionEditTabs?: AXPPropertyViewerTab[];
+    /** Override default delete-section confirmation. */
+    confirmRemoveSection?: AXPBuilderDefinition['confirmRemoveSection'];
+    /** Override default delete-item confirmation. */
+    confirmRemoveItem?: AXPBuilderDefinition['confirmRemoveItem'];
+}
+/** Context shape bound to the default section property viewer (paths match keys). */
+interface AXPStandardSectionFormContext {
+    /** Unique technical name (section `name` in the builder model). */
+    name?: string;
+    tags?: unknown;
+    title?: string | AXPMultiLanguageString;
+    description?: string | AXPMultiLanguageString;
+    isVisible?: boolean;
+}
+
+/**
+ * Default section editor: Identity (name, tags), Content (title, description), Visibility.
+ */
+declare const STANDARD_SECTION_ITEMS_SECTION_TABS: AXPPropertyViewerTab[];
+
+declare class AXPStandardSectionItemsBuilderComponent {
+    readonly value: _angular_core.InputSignal<AXPBuilderValue>;
+    readonly config: _angular_core.InputSignal<AXPStandardSectionItemsBuilderConfig>;
+    readonly readonlyMode: _angular_core.InputSignal<boolean>;
+    readonly valueChange: _angular_core.OutputEmitterRef<AXPBuilderValue>;
+    private readonly inner;
+    private readonly dialogService;
+    private readonly translationService;
+    private readonly propertyViewerService;
+    protected readonly mergedDefinition: _angular_core.Signal<AXPBuilderDefinition>;
+    /** Same entry as page commands / toolbar: open standardized add-section dialog. */
+    addSection(): Promise<void>;
+    private isDuplicateSectionName;
+    /**
+     * `AXPBuilderSection` uses `[key: string]: unknown`; cast to form-bound type without resolving ML.
+     */
+    private sectionFieldForForm;
+    private buildSectionContext;
+    private openSectionDialog;
+    private defaultConfirmRemoveSection;
+    private defaultConfirmRemoveItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPStandardSectionItemsBuilderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPStandardSectionItemsBuilderComponent, "axp-standard-section-items-builder", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; "readonlyMode": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+export { AXPActivityLogComponent, AXPAvatarComponent, AXPCategoryTreeComponent, AXPColorPalettePickerComponent, AXPColumnItemListComponent, AXPCompareViewComponent, AXPConditionBuilderComponent, AXPConditionBuilderConditionComponent, AXPDataSelectorComponent, AXPDataSelectorService, AXPDragDropListComponent, AXPExpressionFieldDefinitions, AXPImageEditorPopupComponent, AXPImageEditorService, AXPItemConfiguratorComponent, AXPLogoComponent, AXPMenuBadgeHelper, AXPMenuCustomizerComponent, AXPMenuCustomizerService, AXPPageComponentRegistryService, AXPPreloadFiltersComponent, AXPPropertyViewerComponent, AXPPropertyViewerPopupComponent, AXPPropertyViewerService, AXPQueryColumnsComponent, AXPQueryFiltersComponent, AXPQuerySortsComponent, AXPQueryViewsComponent, AXPRepeaterRowsLayoutComponent, AXPResourceAppointmentBoardProvider, AXPResourceAppointmentComponent, AXPResourceAppointmentService, AXPSectionItemsBuilderComponent, AXPSpreadsheetComponent, AXPStandardSectionItemsBuilderComponent, AXPStateMessageComponent, AXPStopwatchComponent, AXPTableColumnsEditorComponent, AXPTableColumnsEditorPopupComponent, AXPTableColumnsEditorService, AXPTableDataEditorComponent, AXPTableDataEditorPopupComponent, AXPTableDataEditorService, AXPTaskBadgeDirective, AXPTaskBadgeProvider, AXPTaskBadgeService, AXPTemplateViewerComponent, AXPTemplateViewerService, AXPThemeLayoutActionsComponent, AXPThemeLayoutBlockComponent, AXPThemeLayoutContainerComponent, AXPThemeLayoutEndSideComponent, AXPThemeLayoutFooterComponent, AXPThemeLayoutHeaderComponent, AXPThemeLayoutListComponent, AXPThemeLayoutListItemComponent, AXPThemeLayoutListItemsGroupComponent, AXPThemeLayoutPageHeaderComponent, AXPThemeLayoutPagePrimaryActionsComponent, AXPThemeLayoutPageSecondaryActionsComponent, AXPThemeLayoutSectionComponent, AXPThemeLayoutStartSideComponent, AXPThemeLayoutToolbarComponent, AXPUserAvatarComponent, AXPUserAvatarService, AXPWidgetFieldConfiguratorComponent, AXPWidgetItemComponent, AXPWidgetPropertyViewerComponent, AXPWidgetPropertyViewerPopupComponent, AXPWidgetPropertyViewerService, AXP_EXPRESSION_LOGIC_DEFINITIONS, AXP_EXPRESSION_OPERATION_DEFINITIONS, AXP_MENU_CUSTOMIZER_SERVICE, AXP_PAGE_COMPONENT_PROVIDER, AXP_RESOURCE_APPOINTMENT_PROVIDER, AXP_TASK_BADGE_PROVIDERS, AXP_USER_AVATAR_PROVIDER, STANDARD_SECTION_ITEMS_SECTION_TABS, buildPropertyViewerInitialContextFromProperties, buildPropertyViewerTabsFromProperties, buildTableColumnsEditorLayout, getFieldDefinitions, getLogicDefinition, getOperationDefinition, isPropertyBindingExpressionFormValue, preparePropertyForViewer, preparePropertyViewerTabs, registerFieldDefinitions, withValidationsOnEditorNode };
+export type { AXPBuilderBadge, AXPBuilderBadgeVariant, AXPBuilderDefinition, AXPBuilderItem, AXPBuilderItemIconTone, AXPBuilderItemViewModel, AXPBuilderSection, AXPBuilderTexts, AXPBuilderValue, AXPCategoryTreeActions, AXPCategoryTreeConfig, AXPCategoryTreeDataSource, AXPCategoryTreeEvents, AXPCategoryTreeNode, AXPColumnItemListItem, AXPCompareViewField, AXPCompareViewInputs, AXPCompareViewMode, AXPCompareViewObject, AXPDataSelectorAllowCreate, AXPDataSelectorColumn, AXPDataSelectorConfig, AXPDragDropListConfig, AXPDragDropListDropEvent, AXPDragDropListItem, AXPExpressionFieldDefinition, AXPExpressionGroupNode, AXPExpressionLogicDefinition, AXPExpressionLogicType, AXPExpressionNode, AXPExpressionNodeId, AXPExpressionOperationDefinition, AXPExpressionOperationNode, AXPExpressionOperationType, AXPExpressionTree, AXPExpressionValueOperand, AXPExpressionValueSourceType, AXPImageEditorOpenOptions, AXPMenuCustomizerAction, AXPMenuCustomizerItem, AXPMenuCustomizerItemType, AXPMenuCustomizerNodeData, AXPMenuCustomizerNodeMetadata, AXPMenuCustomizerState, AXPPageComponentDefinition, AXPPageComponentProvider, AXPPreloadFiltersApplyEvent, AXPPropertyViewerActionRef, AXPPropertyViewerChangedEvent, AXPPropertyViewerConfig, AXPPropertyViewerGroup, AXPPropertyViewerResult, AXPPropertyViewerTab, AXPResourceAppointmentActionMenuItem, AXPResourceAppointmentBoardFilter, AXPResourceAppointmentItem, AXPResourceAppointmentResource, AXPResourceAppointmentStatus, AXPSpreadsheetCellChangeEvent, AXPSpreadsheetCellValue, AXPSpreadsheetColumn, AXPSpreadsheetConfig, AXPSpreadsheetData, AXPSpreadsheetItem, AXPSpreadsheetRowChangeEvent, AXPSpreadsheetRowMode, AXPStandardSectionFormContext, AXPStandardSectionItemsBuilderConfig, AXPTableColumnDefinition, AXPTableColumnsEditorOpenOptions, AXPTableDataEditorOpenOptions, AXPTemplateViewerConfig, AXPTemplateViewerResult, AXPUserAvatarData, AXPUserAvatarProvider, AXPUserAvatarSize, AXPUserAvatarStatus, AXPWidgetItemClickEvent, AXPWidgetItemData, AXPWidgetPropertiesChangedEvent, AXPWidgetPropertyInjection, AXPWidgetPropertyViewerConfig, AXPWidgetPropertyViewerResult, ConditionBuilderSelectedField, IAXPPropertyViewerDialogBuilder, IAXPPropertyViewerRoot, IAXPWidgetPropertyViewerDialogBuilder, IAXPWidgetPropertyViewerRoot, ItemConfiguratorListItem, StateMode };