@acorex/platform 21.0.0-next.7 → 21.0.0-next.70

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

@@ -0,0 +1,4439 @@
+import * as _acorex_platform_core from '@acorex/platform/core';
+import { AXPExecuteCommandResult, AXPMetaData, AXPDataSourceDefinitionProvider, AXPDataSourceDefinition, AXPGridLayoutOptions, AXPMultiLanguageString, AXPBreadcrumbItem, AXPFilterQuery, AXPFilterDefinition, AXPExecuteCommand, AXPQueryRequest, AXPPagedListResult, AXPUserReference, AXPCategoryEntity as AXPCategoryEntity$1, AXPEntityOp, AXPMiddlewareErrorResponse, AXHighlightService, AXPExpression, AXPColumnQuery, AXPSortDefinition, AXPDeviceService, AXPBroadcastEventService, AXPActionMenuItem, AXPFileListItem, AXPContextChangeEvent } from '@acorex/platform/core';
+import { AXPCommand, AXPQueryExecutor, AXPCommandService, AXPQuery } from '@acorex/platform/runtime';
+import * as _angular_core from '@angular/core';
+import { ElementRef, InjectionToken, Injector, Type, EnvironmentProviders, OnInit, ChangeDetectorRef, OnDestroy } from '@angular/core';
+import { AXPopoverComponent } from '@acorex/components/popover';
+import * as i4 from '@acorex/platform/layout/widget-core';
+import { AXPWidgetNode, AXPWidgetColumnNode, AXPWidgetCoreService, AXPColumnWidgetComponent, AXPValueWidgetComponent, AXPWidgetConfig, AXPWidgetRendererDirective, AXPWidgetCoreElementAPI } from '@acorex/platform/layout/widget-core';
+import { AXPPreloadFiltersApplyEvent, AXPColumnItemListItem, AXPDataSelectorRowActionsHandler, AXPCategoryTreeDataSource, AXPDataSelectorAllowCreate } from '@acorex/platform/layout/components';
+import { AXPPageLayoutBaseComponent } from '@acorex/platform/layout/views';
+import * as _acorex_platform_common from '@acorex/platform/common';
+import { AXPRelatedEntity, AXPEntityPage, AXPEntityCommandScope, AXPEntity, AXPEntityAction, AXPEntityProperty, AXPEntityTableColumn, AXPCardField, AXPEntityPropertyLayoutConfig, AXPEntitySectionView, AXPEntityPropertyCreateView, AXPQueryView, AXPEntityMasterListLayoutType, AXPEntityMasterListDisplayMode, AXPEntityMasterListLayoutOption, AXPEntityPropertyView, AXPCategoryEntity, AXPEntityPropertyGroup, AXPEntityMasterCreateLayoutView, AXPEntityMasterUpdateLayoutView, AXPEntityMasterSingleLayoutView, AXPEntityMasterListView, AXPEntityDetailListView, AXPQueryFilter, AXCFileUploaderCapabilities, AXCFileUploaderAction } from '@acorex/platform/common';
+export { AXPEntityDefinitionCrudService, AXP_ENTITY_DEFINITION_CRUD_SERVICE } from '@acorex/platform/domain';
+import { AXStyleColorType, AXDataSource, AXDataSourceFilterOption, AXDataSourceSortOption, AXValueChangedEvent, AXClickEvent, AXFocusEvent, AXHtmlEvent } from '@acorex/cdk/common';
+import * as i1 from '@angular/router';
+import { ResolveFn } from '@angular/router';
+import * as rxjs from 'rxjs';
+import { Subject } from 'rxjs';
+import * as i3 from '@acorex/platform/workflow';
+import { AXPWorkflowService, AXPWorkflow, AXPWorkflowAction, AXPWorkflowContext } from '@acorex/platform/workflow';
+import * as i5 from '@acorex/platform/layout/builder';
+import { IActionBuilder, AXPDialogRef, IFormFieldBuilder } from '@acorex/platform/layout/builder';
+import { AXPSessionService } from '@acorex/platform/auth';
+import { AXTreeViewNode, AXTreeViewComponent, AXTreeViewNodeSelectEvent } from '@acorex/components/tree-view';
+import { AXPopupSizeType, AXPopupService } from '@acorex/components/popup';
+import { AXBasePageComponent } from '@acorex/components/page';
+import { AXFormatService } from '@acorex/core/format';
+import { AXTagBoxComponent } from '@acorex/components/tag-box';
+import * as _acorex_core_translation from '@acorex/core/translation';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXPProviderSelectWidgetEditBase, AXPDataListWidgetComponentOptions } from '@acorex/platform/layout/widgets';
+import * as _acorex_platform_layout_entity from '@acorex/platform/layout/entity';
+import { AXFileService } from '@acorex/core/file';
+
+declare class AXPCreateEntityCommand implements AXPCommand<any, any> {
+    private entityForm;
+    private entityService;
+    private toastService;
+    private translationService;
+    private settingsService;
+    private openEntityDetailsCommand;
+    protected context: {};
+    execute(input: any): Promise<AXPExecuteCommandResult<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPCreateEntityCommand, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPCreateEntityCommand>;
+}
+
+/**
+ * Merged into AI/tool payloads for `Entity:Create` so post-create navigation does not run from agent flows.
+ * Applied in the AI module when normalizing tool arguments (not in the generic command executor).
+ */
+declare const axpCreateEntityAiToolInputDefaults: {
+    readonly __context__: {
+        readonly options: {
+            readonly process: {
+                readonly redirect: false;
+            };
+        };
+    };
+};
+declare const axpCreateEntityCommandDefinition: {
+    key: string;
+    title: string;
+    description: string;
+    executionMode: "frontend";
+    inputs: ({
+        name: string;
+        title: string;
+        description: string;
+        interface: {
+            name: string;
+        };
+        validations?: undefined;
+    } | {
+        name: string;
+        title: string;
+        description: string;
+        interface: {
+            name: string;
+        };
+        validations: {
+            rule: string;
+        }[];
+    })[];
+    outcomes: {
+        mode: "dynamic";
+        summary: string;
+        derivesFrom: string;
+    };
+    capabilities: "ai"[];
+    ai: {
+        shortDescription: string;
+        usage: {
+            whenToUse: string[];
+            avoidWhen: string[];
+            followUpTools: string[];
+        };
+        tags: string[];
+        toolInputDefaults: {
+            __context__: {
+                readonly options: {
+                    readonly process: {
+                        readonly redirect: false;
+                    };
+                };
+            };
+        };
+    };
+    categories: _acorex_platform_core.AXPDefinitionCategory[];
+};
+
+declare class AXPUpdateEntityCommand implements AXPCommand<any, any> {
+    private readonly entityForm;
+    private readonly settingsService;
+    private readonly entityService;
+    private readonly toastService;
+    private readonly translationService;
+    private readonly eventService;
+    execute(input: any): Promise<AXPExecuteCommandResult<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPUpdateEntityCommand, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPUpdateEntityCommand>;
+}
+
+declare class AXPViewEntityDetailsCommand implements AXPCommand<any, any> {
+    private readonly entityForm;
+    private readonly entityService;
+    private readonly translationService;
+    execute(input: any): Promise<AXPExecuteCommandResult<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPViewEntityDetailsCommand, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPViewEntityDetailsCommand>;
+}
+
+interface AXPOpenEntityDetailsCommandInput {
+    entity: string;
+    data: {
+        id: string;
+    };
+}
+/**
+ * Generic command to open entity details view
+ * Can be used by any entity to navigate to its detail page
+ */
+declare class AXPOpenEntityDetailsCommand implements AXPCommand<AXPOpenEntityDetailsCommandInput, AXPExecuteCommandResult> {
+    private readonly router;
+    private readonly sessionService;
+    /**
+     * Execute the command to navigate to entity details
+     * @param input - Command input containing entity and data information
+     */
+    execute(input: AXPOpenEntityDetailsCommandInput): Promise<AXPExecuteCommandResult>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPOpenEntityDetailsCommand, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPOpenEntityDetailsCommand>;
+}
+
+declare class AXPEntityDetailPopoverComponent {
+    private readonly commandService;
+    private readonly queryService;
+    private readonly formatService;
+    private readonly translation;
+    entity: _angular_core.InputSignal<string>;
+    entityId: _angular_core.InputSignal<string | number>;
+    textField: _angular_core.InputSignal<string>;
+    valueField: _angular_core.InputSignal<string>;
+    displayTitle: _angular_core.InputSignal<string>;
+    item: _angular_core.InputSignal<AXPMetaData | undefined>;
+    breadcrumb: _angular_core.InputSignal<string | null>;
+    protected detailPopover: _angular_core.Signal<AXPopoverComponent | undefined>;
+    protected entityDetails: _angular_core.WritableSignal<any>;
+    protected isLoadingDetails: _angular_core.WritableSignal<boolean>;
+    protected isDetailPopoverOpen: _angular_core.WritableSignal<boolean>;
+    /** Placeholder rows for the loading skeleton (matches typical property count). */
+    protected readonly loadingSkeletonRows: readonly [1, 2, 3, 4, 5];
+    protected readonly headerTitle: _angular_core.Signal<string>;
+    /**
+     * Stable list of property widgets for the template. Must be a signal (computed), not a method:
+     * calling a method from the template rebuilds nodes every CD cycle and can make the widget renderer loop.
+     */
+    protected readonly entityPropertiesWithWidgets: _angular_core.Signal<{
+        name: string;
+        title: string;
+        node: AXPWidgetNode;
+    }[]>;
+    /**
+     * Show the entity detail popover
+     */
+    show(target: ElementRef | HTMLElement): Promise<void>;
+    /**
+     * Hide the entity detail popover
+     */
+    hide(): void;
+    protected onDetailPopoverOpenChange(event: any): void;
+    protected navigateToDetails(): Promise<void>;
+    private resolveLookupDisplayLabel;
+    /**
+     * Returns true if a value is meaningful for display (non-empty/non-null).
+     */
+    private hasMeaningfulValue;
+    /**
+     * Calculates an importance score for a property based on its widget type,
+     * whether it currently has a meaningful value, and metadata like title.
+     */
+    private getPropertyImportanceScore;
+    /**
+     * Calculates a name-based importance score to prioritize common key fields
+     * like title, description, status, and important dates.
+     * Name priority MUST come before widget-type priority.
+     */
+    private getNameImportanceScore;
+    private buildEntityPropertiesWithWidgets;
+    /**
+     * Resolves the data path for a property. For lookups with expose, returns the expanded path
+     * when data has it (e.g. personTitle). Otherwise returns property name (e.g. personTitleId).
+     */
+    private resolveDataPath;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityDetailPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPEntityDetailPopoverComponent, "axp-entity-detail-popover", never, { "entity": { "alias": "entity"; "required": true; "isSignal": true; }; "entityId": { "alias": "entityId"; "required": true; "isSignal": true; }; "textField": { "alias": "textField"; "required": false; "isSignal": true; }; "valueField": { "alias": "valueField"; "required": false; "isSignal": true; }; "displayTitle": { "alias": "displayTitle"; "required": false; "isSignal": true; }; "item": { "alias": "item"; "required": false; "isSignal": true; }; "breadcrumb": { "alias": "breadcrumb"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface AXPEntityDetailPopoverOptions {
+    entity: string;
+    id: string | number;
+    item: AXPMetaData;
+    textField?: string;
+    valueField?: string;
+    displayTitle?: string;
+    breadcrumb?: string;
+}
+declare class AXPEntityDetailPopoverService {
+    private readonly applicationRef;
+    private readonly environmentInjector;
+    private activePopoverRef;
+    /**
+     * Show entity detail popover
+     * @param target - The target element to position the popover
+     * @param options - Configuration options for the popover
+     */
+    show(target: ElementRef | HTMLElement, options: AXPEntityDetailPopoverOptions): Promise<void>;
+    /**
+     * Hide the active popover
+     */
+    hide(): void;
+    /**
+     * Check if a popover is currently active
+     */
+    get isActive(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityDetailPopoverService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityDetailPopoverService>;
+}
+
+declare class AXPEntityPreloadFiltersContainerComponent extends AXPPageLayoutBaseComponent {
+    private readonly route;
+    private readonly router;
+    private readonly entityService;
+    private readonly filterOperatorMiddleware;
+    protected readonly noMatchText: _angular_core.WritableSignal<string | null>;
+    private vm;
+    preloadFiltersDef: _angular_core.Signal<_acorex_platform_core.AXPFilterDefinition[]>;
+    hasNoRequiredFilters: _angular_core.Signal<boolean>;
+    protected getPageTitle(): string;
+    protected getPageDescription(): string | null;
+    onApply(event: AXPPreloadFiltersApplyEvent): Promise<void>;
+    onShowAll(): Promise<void>;
+    private buildPreloadFilterQueries;
+    private buildListQueryFilter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityPreloadFiltersContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPEntityPreloadFiltersContainerComponent, "axp-entity-preload-filters-container", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Data source definition provider that returns all entity names
+ * from entity loaders' list() (const.ts in each module).
+ */
+declare class AXPEntitiesListDataSourceDefinition implements AXPDataSourceDefinitionProvider {
+    private readonly entityResolver;
+    items(): Promise<AXPDataSourceDefinition[]>;
+}
+
+/**
+ * Built-in entity detail tabs from plugins. Sidebar order (after related page-list / page-detail
+ * tabs): meta-data-builder → attachments → documents → comments → history.
+ */
+type EntityDetailPluginPageSlot = 'meta-data-builder' | 'attachments' | 'documents' | 'comments' | 'history';
+/** Identifies an `entity.pages` entry when skipping its order during recomputation. */
+interface SkipEntityComponentPageRef {
+    componentKey: string;
+    /** When set, only the page with this `field` is skipped (e.g. attachments / meta-data per field). */
+    field?: string;
+}
+interface ResolveEntityPluginDetailPageOrderOptions {
+    /** Component key of the page being added or updated (used to count sibling tabs in the same slot). */
+    componentKey: string;
+    /**
+     * Ignore this page when counting siblings / recomputing (the page currently being updated).
+     */
+    skipPage?: SkipEntityComponentPageRef;
+    /**
+     * Field name for multi-page slots (`attachments`, `meta-data-builder`). Omit for single-tab slots.
+     */
+    field?: string;
+    /** Gap between auto-assigned related tab orders. Default: 10. */
+    relatedOrderStep?: number;
+    /** Minimum start of the plugin zone (after related tabs). Default: 100_000. */
+    pluginZoneFloor?: number;
+}
+/**
+ * Resolves `layout.order` for a built-in plugin detail tab (`entity.pages`).
+ *
+ * 1. Assigns finite `layout.order` values to related `page-list` / `page-detail` rows that omit
+ *    `order` (the composer otherwise treats them as +Infinity).
+ * 2. Places plugin tabs in a fixed relative order: meta-data-builder → attachments → documents →
+ *    comments → history, after all related tabs.
+ */
+declare function resolveEntityPluginDetailPageOrder(input: {
+    relatedEntities?: AXPRelatedEntity[];
+    pages?: Array<AXPEntityPage & {
+        field?: string;
+    }>;
+}, slot: EntityDetailPluginPageSlot, options: ResolveEntityPluginDetailPageOrderOptions): number;
+
+interface AXPDataSeeder {
+    seed(): Promise<void>;
+}
+declare const AXP_DATA_SEEDER_TOKEN: InjectionToken<AXPDataSeeder[]>;
+declare class AXPDataSeederService {
+    private loaders;
+    seed(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDataSeederService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPDataSeederService>;
+}
+
+declare class AXPEntityCommandTriggerViewModel {
+    priority: 'primary' | 'secondary' | 'none';
+    order: number;
+    color: AXStyleColorType;
+    icon: string;
+    title: string;
+    name: string;
+    key?: string;
+    separated: boolean;
+    scope: AXPEntityCommandScope;
+    disabled: boolean | string;
+    hidden: boolean | string;
+    options: any;
+    metadata?: AXPMetaData;
+    default?: boolean;
+    items?: AXPEntityCommandTriggerViewModel[];
+    isChild?: boolean;
+    constructor(entity: AXPEntity, action: AXPEntityAction, isChild?: boolean);
+}
+declare class AXPEntityListViewColumnViewModel {
+    readonly property: AXPEntityProperty;
+    readonly column: AXPEntityTableColumn;
+    constructor(property: AXPEntityProperty, column: AXPEntityTableColumn);
+    name: string;
+    title: string;
+    visible: string | boolean;
+    sortEnabled: boolean | undefined;
+    width: '';
+    node: _angular_core.Signal<AXPWidgetColumnNode>;
+}
+declare class AXPEntityListViewCardFieldViewModel {
+    readonly property: AXPEntityProperty;
+    readonly field: AXPCardField;
+    constructor(property: AXPEntityProperty, field: AXPCardField);
+    name: string;
+    title: string;
+    visible: string | boolean;
+    layout: _acorex_platform_common.AXPEntityPropertyLayoutConfig | undefined;
+    display: string;
+    isBadgeDisplay: boolean;
+    badgeColor: string | undefined;
+    isStatusWidget: boolean;
+    node: _angular_core.Signal<AXPWidgetColumnNode>;
+    /** Readonly column node for status fields shown as header badges. */
+    headerBadgeNode: _angular_core.Signal<AXPWidgetColumnNode>;
+}
+
+declare class AXPEntityDetailListViewModel {
+    private injector;
+    private detailEntityConfig;
+    private parent;
+    private detailEntity;
+    private formatService;
+    private workflow;
+    private filterOperatorMiddleware;
+    private expressionEvaluator;
+    private queryExecutor;
+    private readonly settingsService;
+    private readonly destroyed;
+    private readonly showRowIndexColumnEnabled;
+    /** Whether the row index column is shown (user setting). */
+    readonly showIndexColumn: _angular_core.Signal<boolean>;
+    dataSource: AXDataSource<any>;
+    parentKey: _angular_core.Signal<string | undefined>;
+    constructor(injector: Injector, detailEntityConfig: AXPRelatedEntity, parent: {
+        entity: AXPEntity;
+        data: any;
+    });
+    private syncShowRowIndexColumnSetting;
+    destroy(): void;
+    initialize(): Promise<void>;
+    selectedItems: _angular_core.WritableSignal<any[]>;
+    hasSelectedItems: _angular_core.Signal<boolean>;
+    clearSelection(): void;
+    title: _angular_core.Signal<string>;
+    hidden: _angular_core.Signal<Promise<boolean>>;
+    inlineFiltersPlaceholders: _angular_core.Signal<string[]>;
+    hasInlineFilters: _angular_core.Signal<boolean>;
+    private allActions;
+    selectedScopeActionsCount: _angular_core.Signal<number>;
+    primaryActions: _angular_core.Signal<AXPEntityCommandTriggerViewModel[]>;
+    secondaryActions: _angular_core.Signal<AXPEntityCommandTriggerViewModel[]>;
+    primaryRowActions: _angular_core.Signal<AXPEntityCommandTriggerViewModel[]>;
+    secondaryRowActions: _angular_core.Signal<AXPEntityCommandTriggerViewModel[]>;
+    private inlineFilters;
+    applyInlineFilter(value: string): void;
+    applyFilterAndSort(): Promise<void>;
+    columns: _angular_core.Signal<AXPEntityListViewColumnViewModel[]>;
+    executeCommand(commandName: string, data?: any): Promise<void>;
+    evaluateExpressions: (actionData: {
+        [key: string]: string;
+    } | string) => Promise<any>;
+    /**
+     * Evaluate hidden/disabled expressions for primary actions and return the visible list.
+     */
+    getPrimaryActions(): Promise<AXPEntityCommandTriggerViewModel[]>;
+    /**
+     * Evaluate hidden/disabled expressions for secondary actions and return the visible list.
+     */
+    getSecondaryActions(): Promise<AXPEntityCommandTriggerViewModel[]>;
+}
+
+declare const AXPEntityEventsKeys: {
+    REFRESH_LAYOUT: string;
+    REFRESH_DATA: string;
+};
+
+/**
+ * Entity Event Dispatcher - A wrapper for entity-specific events
+ * Handles pattern-based dispatching for entity operations with wildcard support
+ */
+declare class AXPEntityEventDispatcherService {
+    private readonly eventService;
+    dispatchEntityEvent(operation: 'inserted' | 'updated' | 'deleted', entityName: string, data: any): Promise<void>;
+    private getAllMatchingEventKeys;
+    private findMatchingWildcardKeys;
+    private matchesEntityPattern;
+    private generateEventKeys;
+    dispatchInserted(entityName: string, data: any): Promise<void>;
+    dispatchUpdated(entityName: string, data: any): Promise<void>;
+    dispatchDeleted(entityName: string, data: any): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityEventDispatcherService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityEventDispatcherService>;
+}
+
+/**
+ * Sort key for entries in `interfaces.master.{create|update|single}.properties`.
+ * Uses `layout.order` when set and finite; otherwise the property index in that list.
+ */
+declare function getMasterInterfacePropertySortKey(interfaceRow: {
+    layout?: AXPEntityPropertyLayoutConfig | undefined;
+} | undefined, indexInMasterInterfaceList: number): number;
+
+interface AXPEntityListExpandRowRef {
+    data: Record<string, unknown>;
+}
+/**
+ * Resolves a stable row id from entity list row data.
+ */
+declare function getEntityListRowId(data: Record<string, unknown>, key?: string): string;
+/**
+ * Finds row data in a hierarchical grid tree (root rows and nested children).
+ */
+declare function findEntityListRowDataInTree(items: unknown[], id: string, key: string): Record<string, unknown> | null;
+/**
+ * Restores expanded rows after data load (parents before children).
+ */
+declare function restoreEntityListExpandedRows(options: {
+    expandedRowIds: string[];
+    rowKey: string;
+    getDisplayedRows: () => unknown[];
+    expandRow: (row: AXPEntityListExpandRowRef) => Promise<void>;
+}): Promise<void>;
+
+interface AXPEntityListPagingState {
+    take: number;
+    skip: number;
+}
+/**
+ * Applies take/skip to the data source without triggering {@link AXDataSource.load}.
+ */
+declare function applyDataSourcePagingWithoutLoad(dataSource: AXDataSource, paging: AXPEntityListPagingState): void;
+declare function getDataSourcePageIndex(dataSource: AXDataSource): number;
+declare function normalizeListPaging(paging: Partial<AXPEntityListPagingState> | undefined, defaultTake: number): AXPEntityListPagingState;
+
+/** How entity list UI state (columns, filters, paging, etc.) is persisted for the user. */
+type AXPEntityListPersistenceMode = 'none' | 'persistent' | 'route';
+declare const AXPEntityListPersistenceModeDefault: AXPEntityListPersistenceMode;
+declare function normalizeEntityListPersistenceMode(value: unknown): AXPEntityListPersistenceMode;
+declare function canPersistEntityListState(mode: AXPEntityListPersistenceMode): boolean;
+/** `none` never reads list state from user settings. */
+declare function shouldLoadEntityListStateFromStorage(mode: AXPEntityListPersistenceMode): boolean;
+/** `route` clears stored list state when the route entity (module + name) changes. */
+declare function shouldResetEntityListStateOnRouteEntry(mode: AXPEntityListPersistenceMode): boolean;
+declare const ENTITY_LIST_ROUTE_CONTEXT_SESSION_KEY = "axp-entity-list-route-context";
+
+declare class AXPEntityCreateViewSectionViewModel {
+    private entity;
+    private section;
+    constructor(entity: AXPEntity, section: AXPEntitySectionView);
+    group: _acorex_platform_common.AXPEntityPropertyGroup;
+    name: _angular_core.WritableSignal<string>;
+    title: _angular_core.Signal<string>;
+    description: _angular_core.Signal<string | null | undefined>;
+    layout: _angular_core.Signal<AXPGridLayoutOptions>;
+    elements: _angular_core.Signal<AXPEntityCreateViewElementViewModel[]>;
+}
+declare class AXPEntityCreateViewElementViewModel {
+    private entity;
+    private section;
+    private property;
+    private createProp;
+    constructor(entity: AXPEntity, section: AXPEntityCreateViewSectionViewModel, property: AXPEntityProperty, createProp: AXPEntityPropertyCreateView);
+    name: _angular_core.WritableSignal<string>;
+    title: _angular_core.WritableSignal<string>;
+    description: _angular_core.WritableSignal<string | undefined>;
+    editable: _angular_core.Signal<boolean>;
+    isVisible: _angular_core.Signal<string | boolean>;
+    isRequired: _angular_core.Signal<boolean>;
+    layout: _angular_core.Signal<AXPEntityPropertyLayoutConfig>;
+    node: _angular_core.Signal<AXPWidgetNode>;
+}
+declare class AXPEntityMasterCreateViewModel {
+    private readonly injector;
+    private readonly config;
+    private readonly initialData;
+    private readonly commandOptions;
+    private entityDef;
+    private workflow;
+    private expressionEvaluator;
+    builder: AXPWidgetCoreService;
+    constructor(injector: Injector, config: AXPEntity, initialData: any | undefined, commandOptions: any);
+    context: _angular_core.WritableSignal<any>;
+    options: _angular_core.WritableSignal<any>;
+    isInProgress: _angular_core.WritableSignal<boolean>;
+    canCreateNewOne: _angular_core.WritableSignal<boolean>;
+    redirect: _angular_core.WritableSignal<boolean>;
+    sections: _angular_core.Signal<AXPEntityCreateViewSectionViewModel[]>;
+    save(): Promise<any | void>;
+    createNewOne(): Promise<void>;
+}
+declare class AXPEntityCreateViewModelFactory {
+    private entityService;
+    private layout;
+    private injector;
+    create(moduleName: string, entityName: string, initialData?: any, options?: {
+        canCreateNewOne: boolean;
+        redirect: boolean;
+    }): Promise<AXPEntityMasterCreateViewModel>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityCreateViewModelFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityCreateViewModelFactory>;
+}
+
+interface AXPEntityMasterListViewSortPropViewModel {
+    name: string;
+    title: string;
+    dir?: string;
+}
+/** Built-in card list row action that toggles multi-select mode via {@link AXPEntityMasterListViewModel.selectedItems}. */
+declare const AXPEntityMasterListCardSelectActionName = "axp-entity-card:select";
+interface AXPEntityMasterListCardSecondaryActionItem {
+    name: string;
+    title: string;
+    icon?: string;
+    color?: string;
+    disabled?: boolean | string;
+    divided?: boolean;
+    isCardSelect?: boolean;
+}
+declare class AXPEntityMasterListViewQueryViewModel {
+    private entity;
+    private section;
+    private view;
+    constructor(entity: AXPEntity, section: AXPEntityMasterListViewModel, view: AXPQueryView);
+    name: string;
+    title: string;
+    sorts: _acorex_platform_common.AXPQuerySort[];
+    columns: string[];
+    conditions: _acorex_platform_common.AXPQueryFilter[];
+    indexCol: boolean | undefined;
+    pageSize: number | undefined;
+}
+declare class AXPEntityMasterListViewModel {
+    private injector;
+    private config;
+    readonly entityDef: AXPEntity;
+    private readonly _viewDef;
+    private readonly formatService;
+    private readonly session;
+    private readonly workflow;
+    private readonly settings;
+    private readonly widgetResolver;
+    private readonly expressionEvaluator;
+    private readonly translation;
+    private readonly commandService;
+    private readonly eventService;
+    private readonly queryExecutor;
+    private readonly filterOperatorMiddleware;
+    private readonly entityDefinitionRegistry;
+    private settingEntityKey;
+    private readonly destroyed;
+    private lastAppliedSortKey;
+    private lastAppliedFilterKey;
+    private hasQueryParamsFilters;
+    /** Persisted expanded row ids for hierarchical lists (per view). */
+    private readonly expandedRowIds;
+    /** When true, row expand/collapse is not written to user settings (restore in progress). */
+    skipExpandedRowPersistence: boolean;
+    /** Resolved take/skip for the current view (null until loaded from settings). */
+    private readonly resolvedListPaging;
+    /** When true, pager changes are not persisted (programmatic UI sync). */
+    skipListPagingPersistence: boolean;
+    private listPersistenceMode;
+    events$: Subject<{
+        action: string;
+        meta?: any;
+    }>;
+    views: _angular_core.Signal<AXPEntityMasterListViewQueryViewModel[]>;
+    view: _angular_core.WritableSignal<AXPEntityMasterListViewQueryViewModel>;
+    private readonly showRowIndexColumnEnabled;
+    /**
+     * Row index column: if the list view defines `indexCol` (true/false), that overrides the user setting;
+     * if `indexCol` is omitted, visibility follows {@link AXPCommonSettings.ShowRowIndexColumn}.
+     */
+    showIndexColumn: _angular_core.Signal<boolean>;
+    /** Layouts enabled via `interfaces.master.list.layouts.*.enabled`. */
+    enabledListLayouts: _angular_core.Signal<AXPEntityMasterListLayoutType[]>;
+    /** True when the user can switch between multiple enabled layouts. */
+    canSwitchListLayout: _angular_core.Signal<boolean>;
+    /** Active list layout for the current view. */
+    activeListLayout: _angular_core.WritableSignal<AXPEntityMasterListLayoutType>;
+    tableLayout: _angular_core.Signal<{
+        enabled?: boolean;
+        columns: AXPEntityTableColumn[];
+    } | undefined>;
+    cardLayout: _angular_core.Signal<{
+        enabled?: boolean;
+        header: {
+            title?: string;
+            description?: string;
+            icon?: string;
+        };
+        fields: AXPCardField[];
+    } | undefined>;
+    /** Global expanded state for all card bodies in card layout. */
+    cardContentExpanded: _angular_core.WritableSignal<boolean>;
+    /** Current presentation mode (table, compact cards, or expanded cards). */
+    listDisplayMode: _angular_core.Signal<AXPEntityMasterListDisplayMode>;
+    /**
+     * Sets global card body visibility for card layout.
+     */
+    setCardContentExpanded(expanded: boolean): void;
+    /**
+     * Switches table vs compact/expanded card presentation.
+     */
+    setListDisplayMode(mode: AXPEntityMasterListDisplayMode): void;
+    /** Enabled layouts with display metadata for the title layout switcher. */
+    availableListLayouts: _angular_core.Signal<AXPEntityMasterListLayoutOption[]>;
+    /** Active layout option (for title icon and switcher selection state). */
+    currentListLayout: _angular_core.Signal<AXPEntityMasterListLayoutOption | null>;
+    private static readonly LAYOUT_META;
+    /**
+     * Switches to the given layout when it is enabled.
+     * Persists the choice at entity list level (shared across all views).
+     */
+    setListLayout(layout: AXPEntityMasterListLayoutType): void;
+    /**
+     * Cycles to the next enabled layout (table → card → table …).
+     * No-op when only one layout is enabled.
+     */
+    switchListLayout(): AXPEntityMasterListLayoutType;
+    private resolveActiveListLayout;
+    private applyListLayoutFromSettings;
+    private createExpressionScope;
+    private resolveCommandNameExpression;
+    private resolveTitleExpression;
+    /**
+     * Resolves a card header value (title, description, icon) from a property path, expression, or literal.
+     * Supports multiple `{{ ... }}` segments in one string (e.g. `{{context.eval("a")}} - {{context.eval("b")}}`).
+     * Multi-language maps (e.g. `{ "en-US": "...", "fa-IR": "..." }`) are returned as-is for the translate pipe.
+     */
+    resolveCardHeaderValue(value: string | undefined, rowData: unknown): Promise<AXPMultiLanguageString>;
+    /**
+     * Keeps i18n payloads intact for `translate`; coerces only plain scalars to string.
+     */
+    private normalizeCardHeaderDisplayValue;
+    /**
+     * Resolves badge color for a card header field (semantic token or expression per row).
+     */
+    resolveCardBadgeColor(field: AXPEntityListViewCardFieldViewModel, rowData: unknown): Promise<AXStyleColorType>;
+    private resolveCardBadgeColorValue;
+    private resolveTriggerName;
+    setView(viewName?: string | null): Promise<void>;
+    dataSource: AXDataSource<any>;
+    constructor(injector: Injector, config: AXPEntity);
+    private syncShowRowIndexColumnSetting;
+    /**
+     * Applies {@link AXPCommonSettings.EntityListPersistenceMode} for this list instance.
+     * Call once when the list view model is created (before loading list UI state).
+     */
+    initializeListPersistence(): Promise<void>;
+    getListPersistenceMode(): Promise<AXPEntityListPersistenceMode>;
+    shouldLoadPersistedListState(): Promise<boolean>;
+    shouldPersistListState(): Promise<boolean>;
+    private clearEntityListSettings;
+    applySettings(): Promise<void>;
+    ensureListPagingResolved(): Promise<void>;
+    getResolvedListPaging(): AXPEntityListPagingState;
+    applyPagingToDataSourceWithoutLoad(): void;
+    saveListPaging(take: number, skip: number): void;
+    resetListPagingSkip(): void;
+    private loadListPagingFromViewSettings;
+    getExpandedRowIds(): string[];
+    /**
+     * Updates persisted expanded row ids when the user expands or collapses a tree row.
+     */
+    updateExpandedRowId(rowId: string, expanded: boolean): void;
+    handleRowExpandChange(rowData: Record<string, unknown>): void;
+    saveSettings(changesType: 'columnSizes' | 'columnOrders' | 'view' | 'pageSize' | 'listPaging' | 'filters' | 'sorts' | 'expandedRows' | 'listLayout' | 'cardContentExpanded', data?: unknown): Promise<void>;
+    selectedItems: _angular_core.WritableSignal<any[]>;
+    /**
+     * Selected category from the category sidebar (left panel).
+     * Used to set default category when creating new entities via command.
+     * Structure: { id: string; title: string } or null when "All Items" is selected.
+     */
+    selectedCategory: _angular_core.WritableSignal<{
+        id: string;
+        title: string;
+    } | null>;
+    parentKey: _angular_core.Signal<string | undefined>;
+    hasSelectedItems: _angular_core.Signal<boolean>;
+    clearSelection(): void;
+    /**
+     * Sets the selected category from the category sidebar.
+     * Call with null to clear (e.g. when "All Items" is selected).
+     */
+    setSelectedCategory(category: {
+        id: string;
+        title: string;
+    } | null): void;
+    title: _angular_core.Signal<string>;
+    description: _angular_core.Signal<string | null>;
+    inlineFiltersPlaceholders: _angular_core.Signal<string[]>;
+    hasInlineFilters: _angular_core.Signal<boolean>;
+    beardcrumbs: _angular_core.Signal<AXPBreadcrumbItem[]>;
+    private allActions;
+    /** Flattened actions including children for execute lookup */
+    private flattenedActions;
+    getPrimaryActions(): Promise<AXPEntityCommandTriggerViewModel[]>;
+    getSecondaryActions(): Promise<AXPEntityCommandTriggerViewModel[]>;
+    selectedScopeActionsCount: _angular_core.Signal<number>;
+    primaryRowActions: _angular_core.Signal<AXPEntityCommandTriggerViewModel[]>;
+    secondaryRowActions(rowData: any): Promise<AXPEntityCommandTriggerViewModel[]>;
+    /**
+     * Secondary actions for card layout rows, with the built-in Select action last (divider above it).
+     */
+    cardSecondaryRowActions(rowData: unknown): Promise<AXPEntityMasterListCardSecondaryActionItem[]>;
+    filterQueries: _angular_core.WritableSignal<AXPFilterQuery[]>;
+    private static readonly URL_FILTER_OPERATOR_TYPES;
+    get properties(): AXPEntityProperty[];
+    /**
+     * Canonical JSON for the `filters` query param (sorted by field), or null when there are no active value filters.
+     */
+    filtersQueryParamCanonical(queries: AXPFilterQuery[]): string | null;
+    /**
+     * Parse a `filters` query string to the same canonical form used by {@link filtersQueryParamCanonical}.
+     */
+    static parseQueryParamFiltersToCanonical(filtersJson: string | null): string | null;
+    private toUrlFilterPayloadItems;
+    private static coerceFilterOperatorFromUrl;
+    /**
+     * Apply filters from query params
+     */
+    applyFiltersFromQueryParams(filtersJson: string | null): boolean;
+    get filtersDef(): AXPFilterDefinition[];
+    get preloadFiltersDef(): AXPFilterDefinition[];
+    applyViewFilters(): Promise<void>;
+    resetFilters(): void;
+    applyFilterAndSort(): Promise<void>;
+    private allAvailableColumns;
+    visibleColumnCount: () => number;
+    columns: _angular_core.WritableSignal<AXPEntityListViewColumnViewModel[]>;
+    resetColumns(): void;
+    onColumnsChanged(columns: AXPEntityListViewColumnViewModel[]): Promise<void>;
+    applyViewColumns(): void;
+    onColumnsOrderChanged(event: any): void;
+    private mergeDisplayFieldWithColumn;
+    private buildVirtualDisplayProperty;
+    private normalizeRelatedColumnNames;
+    private findRelatedEntityForField;
+    private getRegisteredEntity;
+    private resolveRelatedEntityProperty;
+    private resolveRelatedEntityColumnDataPath;
+    private deriveDataPathFromLookupProperty;
+    private resolveParentDataPathForRelatedField;
+    private resolveDisplayFieldProperty;
+    private resolveCardField;
+    private allAvailableCardFields;
+    cardFields: _angular_core.WritableSignal<AXPEntityListViewCardFieldViewModel[]>;
+    applyCardFields(): void;
+    sortableFields: () => {
+        name: string;
+        title: string;
+        dir: undefined;
+    }[];
+    sortableFieldsCount: () => number;
+    canSort: () => boolean;
+    canAddMoreSort: () => boolean;
+    sortedCount: () => number;
+    sortedFields: _angular_core.WritableSignal<AXPEntityMasterListViewSortPropViewModel[]>;
+    resetSorts(): void;
+    /**
+     * Applies active sorts in the given order (click order, saved settings, or view defaults).
+     */
+    private setActiveSortsFromQueries;
+    applyViewSorts(): void;
+    /**
+     * Active sort direction for a column (synced with toolbar sort UI and dataSource).
+     */
+    getColumnSortDirection(columnName: string): 'asc' | 'desc' | undefined;
+    /**
+     * 1-based priority index when multiple columns are sorted (Ctrl+click order).
+     */
+    getColumnSortIndex(columnName: string): number | undefined;
+    /** True when active sorts still match the current view defaults (not yet customized). */
+    private isViewDefaultSorts;
+    /**
+     * Toggles column sort (asc → desc → none). Without Ctrl, only one column is active.
+     * With Ctrl/Cmd, multiple columns are sorted in click order (first clicked = primary).
+     */
+    toggleColumnSort(columnName: string, multiSort: boolean): Promise<void>;
+    executeCommand(commandName: string, data?: any): Promise<void>;
+    /**
+     * Merges default category from selected category in sidebar when executing create command.
+     * For Entity:Create and create-entity, if entity has category plugin and a category is selected,
+     * pre-fills categoryIds and categories for the create form.
+     */
+    private mergeDefaultCategoryForCreate;
+    /**
+     * Seeds create payloads with fixed list-view conditions (e.g. scope=T on the tenant dashboards view)
+     * so new rows match the view context and downstream queries (such as home dashboard) can find them.
+     */
+    private mergeViewConditionsForCreate;
+    private evaluateExpressions;
+    execute(command: AXPExecuteCommand): Promise<void>;
+    destroy(): void;
+}
+declare class AXPEntityListViewModelFactory {
+    private entityService;
+    private layout;
+    private injector;
+    create(moduleName: string, entityName: string): Promise<AXPEntityMasterListViewModel>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityListViewModelFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityListViewModelFactory>;
+}
+declare const AXPEntityListViewModelResolver: ResolveFn<Promise<AXPEntityMasterListViewModel>>;
+
+declare class AXPEntityMasterSingleViewGroupViewModel {
+    private entity;
+    private section;
+    constructor(entity: AXPEntity, section: AXPEntitySectionView);
+    group: _acorex_platform_common.AXPEntityPropertyGroup;
+    name: _angular_core.WritableSignal<string>;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    title: _angular_core.Signal<string>;
+    description: _angular_core.Signal<string | null | undefined>;
+    layout: _angular_core.Signal<AXPGridLayoutOptions>;
+    props: _angular_core.Signal<AXPEntityMasterSingleElementViewModel[]>;
+    editableProps: _angular_core.Signal<AXPEntityMasterSingleElementViewModel[]>;
+    editable: _angular_core.Signal<boolean>;
+}
+declare class AXPEntityMasterSingleElementViewModel {
+    private entity;
+    private section;
+    private propertyView;
+    constructor(entity: AXPEntity, section: AXPEntityMasterSingleViewGroupViewModel, propertyView: AXPEntityPropertyView);
+    private property;
+    name: _angular_core.WritableSignal<string>;
+    path: _angular_core.WritableSignal<string>;
+    title: _angular_core.WritableSignal<string>;
+    showLabel: _angular_core.WritableSignal<boolean>;
+    description: _angular_core.WritableSignal<string | undefined>;
+    layout: _angular_core.Signal<AXPGridLayoutOptions>;
+    node: _angular_core.Signal<AXPWidgetNode>;
+}
+declare class AXPEntityMasterSingleViewModel {
+    private injector;
+    private config;
+    private entityData;
+    entityDef: AXPEntity;
+    private readonly _viewDef;
+    private readonly session;
+    private readonly formatService;
+    private readonly workflow;
+    private readonly commandService;
+    private readonly destroyed;
+    private translateService;
+    private entityService;
+    private expressionEvaluator;
+    private entityDefinitionRegistryService;
+    private _updateTrigger;
+    readonly updateTrigger: _angular_core.Signal<number>;
+    constructor(injector: Injector, config: AXPEntity, entityData: any);
+    context: _angular_core.WritableSignal<any>;
+    private actions;
+    primaryActions: _angular_core.Signal<AXPEntityCommandTriggerViewModel[]>;
+    secondaryActions: _angular_core.Signal<AXPEntityCommandTriggerViewModel[]>;
+    sections: _angular_core.Signal<AXPEntityMasterSingleViewGroupViewModel[]>;
+    navigateToUp(): void;
+    title: _angular_core.Signal<string>;
+    description: _angular_core.Signal<string | null>;
+    beardcrumbs: _angular_core.Signal<AXPBreadcrumbItem[]>;
+    evaluateExpressions: (options: {
+        [key: string]: string;
+    }, data: any) => Promise<any>;
+    relatedEntities: _angular_core.Signal<Promise<AXPEntityDetailListViewModel[]>>;
+    executeCommand(commandName: string, data?: any): Promise<void>;
+    execute(command: AXPExecuteCommand): Promise<void>;
+    destroy(): void;
+}
+declare class AXPEntityDetailViewModelFactory {
+    private entityService;
+    private layout;
+    private injector;
+    create(moduleName: string, entityName: string, id: string): Promise<AXPEntityMasterSingleViewModel>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityDetailViewModelFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityDetailViewModelFactory>;
+}
+declare const AXPEntityDetailViewModelResolver: ResolveFn<Promise<AXPEntityMasterSingleViewModel>>;
+
+declare class AXPEntityUpdateViewSectionViewModel {
+    private entity;
+    private section;
+    constructor(entity: AXPEntity, section: AXPEntitySectionView);
+    group: _acorex_platform_common.AXPEntityPropertyGroup;
+    name: _angular_core.WritableSignal<string>;
+    title: _angular_core.Signal<string>;
+    description: _angular_core.Signal<string | null | undefined>;
+    layout: _angular_core.Signal<AXPGridLayoutOptions>;
+    elements: _angular_core.Signal<AXPEntityMasterUpdateElementViewModel[]>;
+}
+declare class AXPEntityMasterUpdateElementViewModel {
+    private entity;
+    private property;
+    constructor(entity: AXPEntity, property: AXPEntityProperty);
+    name: _angular_core.WritableSignal<string>;
+    title: _angular_core.WritableSignal<string>;
+    description: _angular_core.WritableSignal<string | undefined>;
+    editable: _angular_core.Signal<boolean>;
+    isVisible: _angular_core.Signal<string | boolean>;
+    isRequired: _angular_core.Signal<boolean>;
+    layout: _angular_core.Signal<AXPEntityPropertyLayoutConfig>;
+    node: _angular_core.Signal<AXPWidgetNode>;
+}
+declare class AXPEntityMasterUpdateViewModel {
+    private injector;
+    private config;
+    private entityData;
+    private props;
+    private entityDef;
+    private workflow;
+    private sessionService;
+    private get moduleName();
+    private get entityName();
+    private get entityId();
+    builder: AXPWidgetCoreService;
+    constructor(injector: Injector, config: AXPEntity, entityData: any, props: string[]);
+    isInProgress: _angular_core.WritableSignal<boolean>;
+    context: _angular_core.WritableSignal<any>;
+    elements: _angular_core.Signal<AXPEntityMasterUpdateElementViewModel[]>;
+    sections: _angular_core.Signal<AXPEntityUpdateViewSectionViewModel[]>;
+    save(): Promise<any>;
+    reset(): void;
+}
+declare class AXPEntityMasterUpdateViewModelFactory {
+    private entityService;
+    private layout;
+    private injector;
+    create(moduleName: string, entityName: string, id: string, props: string[]): Promise<AXPEntityMasterUpdateViewModel>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityMasterUpdateViewModelFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityMasterUpdateViewModelFactory>;
+}
+
+type AXPEntityMasterListCardLayout = NonNullable<NonNullable<AXPEntityMasterListView['layouts']>['card']>;
+interface AXPEntityModifierContext {
+    readonly entity: AXPEntity;
+    plugins: {
+        list(): NonNullable<AXPEntity['plugins']>;
+        add(...items: NonNullable<AXPEntity['plugins']>): AXPEntityModifierContext;
+        remove(predicate: (p: NonNullable<AXPEntity['plugins']>[number]) => boolean): AXPEntityModifierContext;
+        find(name: string): {
+            get(): NonNullable<AXPEntity['plugins']>[number] | undefined;
+            update(updater: (p: NonNullable<AXPEntity['plugins']>[number]) => NonNullable<AXPEntity['plugins']>[number]): AXPEntityModifierContext;
+        };
+    };
+    title: {
+        get(): string;
+        set(newTitle: string): AXPEntityModifierContext;
+    };
+    module: {
+        get(): string;
+        set(newModule: string): AXPEntityModifierContext;
+    };
+    name: {
+        get(): string;
+        set(newName: string): AXPEntityModifierContext;
+    };
+    parentKey: {
+        get(): string | undefined;
+        set(newKey: string | undefined): AXPEntityModifierContext;
+    };
+    category: {
+        get(): AXPCategoryEntity | undefined;
+        update(updater: (cat: AXPCategoryEntity | undefined) => AXPCategoryEntity): AXPEntityModifierContext;
+    };
+    properties: {
+        list(): AXPEntityProperty[];
+        add(...props: AXPEntityProperty[]): AXPEntityModifierContext;
+        remove(predicate: (p: AXPEntityProperty) => boolean): AXPEntityModifierContext;
+        find(name: string): {
+            get(): AXPEntityProperty | undefined;
+            update(updater: (p: AXPEntityProperty) => AXPEntityProperty): AXPEntityModifierContext;
+        };
+    };
+    columns: {
+        list(): AXPEntityTableColumn[] | undefined;
+        add(...cols: AXPEntityTableColumn[]): AXPEntityModifierContext;
+        remove(predicate: (c: AXPEntityTableColumn) => boolean): AXPEntityModifierContext;
+        find(name: string): {
+            get(): AXPEntityTableColumn | undefined;
+            update(updater: (c: AXPEntityTableColumn) => AXPEntityTableColumn): AXPEntityModifierContext;
+        };
+    };
+    formats: {
+        get(): AXPEntity['formats'];
+        update(updater: (formats: AXPEntity['formats']) => AXPEntity['formats']): AXPEntityModifierContext;
+    };
+    relatedEntities: {
+        list(): AXPRelatedEntity[] | undefined;
+        add(...related: AXPRelatedEntity[]): AXPEntityModifierContext;
+        remove(predicate: (r: AXPRelatedEntity) => boolean): AXPEntityModifierContext;
+    };
+    groups: {
+        list(): AXPEntityPropertyGroup[] | undefined;
+        add(...groups: AXPEntityPropertyGroup[]): AXPEntityModifierContext;
+        remove(predicate: (g: AXPEntityPropertyGroup) => boolean): AXPEntityModifierContext;
+    };
+    commands: {
+        get(): AXPEntity['commands'] | undefined;
+        update(updater: (c: AXPEntity['commands'] | undefined) => AXPEntity['commands']): AXPEntityModifierContext;
+    };
+    queries: {
+        get(): AXPEntity['queries'];
+        update(updater: (q: AXPEntity['queries']) => AXPEntity['queries']): AXPEntityModifierContext;
+    };
+    validations: {
+        get(): AXPEntity['validations'] | undefined;
+        update(updater: (v: AXPEntity['validations'] | undefined) => AXPEntity['validations']): AXPEntityModifierContext;
+    };
+    interfaces: {
+        get(): AXPEntity['interfaces'] | undefined;
+        update(updater: (i: AXPEntity['interfaces'] | undefined) => AXPEntity['interfaces']): AXPEntityModifierContext;
+        master: {
+            get(): NonNullable<AXPEntity['interfaces']>['master'] | undefined;
+            update(updater: (m: NonNullable<AXPEntity['interfaces']>['master'] | undefined) => NonNullable<AXPEntity['interfaces']>['master']): AXPEntityModifierContext;
+            create: {
+                get(): AXPEntityMasterCreateLayoutView | undefined;
+                update(updater: (c: AXPEntityMasterCreateLayoutView | undefined) => AXPEntityMasterCreateLayoutView): AXPEntityModifierContext;
+            };
+            modify: {
+                get(): AXPEntityMasterUpdateLayoutView | undefined;
+                update(updater: (c: AXPEntityMasterUpdateLayoutView | undefined) => AXPEntityMasterUpdateLayoutView): AXPEntityModifierContext;
+            };
+            single: {
+                get(): AXPEntityMasterSingleLayoutView | undefined;
+                update(updater: (c: AXPEntityMasterSingleLayoutView | undefined) => AXPEntityMasterSingleLayoutView): AXPEntityModifierContext;
+            };
+            list: {
+                get(): AXPEntityMasterListView | undefined;
+                update(updater: (c: AXPEntityMasterListView | undefined) => AXPEntityMasterListView): AXPEntityModifierContext;
+                card: {
+                    get(): AXPEntityMasterListCardLayout | undefined;
+                    set(layout: AXPEntityMasterListCardLayout): AXPEntityModifierContext;
+                    update(updater: (layout: AXPEntityMasterListCardLayout | undefined) => AXPEntityMasterListCardLayout | undefined): AXPEntityModifierContext;
+                    remove(): AXPEntityModifierContext;
+                };
+            };
+        };
+        detail: {
+            get(): NonNullable<AXPEntity['interfaces']>['detail'] | undefined;
+            update(updater: (d: NonNullable<AXPEntity['interfaces']>['detail'] | undefined) => NonNullable<AXPEntity['interfaces']>['detail']): AXPEntityModifierContext;
+            list: {
+                get(): AXPEntityDetailListView | undefined;
+                update(updater: (l: AXPEntityDetailListView | undefined) => AXPEntityDetailListView): AXPEntityModifierContext;
+            };
+        };
+    };
+    toEntity(): AXPEntity;
+}
+type AXPEntityModifier = (context: AXPEntityModifierContext) => void;
+interface AXPEntityModifierProvider {
+    entityName: string | RegExp;
+    modifier: AXPEntityModifier;
+    order?: number;
+}
+
+declare function ensureListActions(ctx: AXPEntityModifierContext): void;
+declare function actionExists(actions: any[] | undefined, commandName: string, name?: string): boolean;
+interface AXPEntityLayoutSectionLike {
+    id: string;
+}
+interface AXPEntityLayoutPropertyLike {
+    name: string;
+}
+interface AXPEntityLayoutLike<TSection extends AXPEntityLayoutSectionLike = AXPEntityLayoutSectionLike, TProperty extends AXPEntityLayoutPropertyLike = AXPEntityLayoutPropertyLike> {
+    sections: TSection[];
+    properties?: TProperty[];
+}
+/**
+ * Clones `sections` and `properties` arrays to prevent accidental cross-interface mutations.
+ * Many entity definitions reuse the same array instances across create/update/single interfaces.
+ */
+declare function cloneLayoutArrays<TLayout extends AXPEntityLayoutLike>(layout: TLayout): TLayout & {
+    properties: NonNullable<TLayout['properties']>;
+};
+declare function ensureLayoutSection<TLayout extends AXPEntityLayoutLike>(layout: TLayout, section: TLayout['sections'][number]): void;
+declare function ensureLayoutPropertyView<TLayout extends AXPEntityLayoutLike>(layout: TLayout & {
+    properties: NonNullable<TLayout['properties']>;
+}, prop: NonNullable<TLayout['properties']>[number]): void;
+
+interface AXPEntityActionPlugin {
+    name: string;
+    order?: number;
+    apply: (ctx: AXPEntityModifierContext, options?: any) => Promise<void> | void;
+}
+declare const AXP_ENTITY_ACTION_PLUGIN: InjectionToken<AXPEntityActionPlugin[]>;
+
+declare class AXPEntityMiddleware {
+    private exactModifiers;
+    private patternModifiers;
+    protected providedModifiers: AXPEntityModifierProvider[];
+    protected providedActionPlugins: AXPEntityActionPlugin[];
+    protected injector: Injector;
+    constructor();
+    register(entityName: string | RegExp, modifier: AXPEntityModifier, order?: number): void;
+    process(entity: AXPEntity): Promise<AXPEntity>;
+    private createModifierStep;
+    private createPluginStep;
+    private wildcardToRegExp;
+    private normalizeRegExp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityMiddleware, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityMiddleware>;
+}
+
+declare function createModifierContext(entity: AXPEntity): AXPEntityModifierContext;
+
+declare const AXP_ENTITY_MODIFIER: InjectionToken<AXPEntityModifierProvider[]>;
+
+declare class AXPEntityPreloadFiltersViewModel {
+    private injector;
+    private config;
+    readonly entityDef: AXPEntity;
+    private readonly widgetResolver;
+    constructor(injector: Injector, config: AXPEntity);
+    /**
+     * Entity title
+     */
+    title: _angular_core.Signal<string>;
+    /**
+     * Entity description
+     */
+    description: _angular_core.Signal<string | null>;
+    /**
+     * All filter definitions for properties with preload enabled
+     */
+    preloadFiltersDef: _angular_core.Signal<AXPFilterDefinition[]>;
+    /**
+     * Required filter definitions only
+     */
+    requiredFiltersDef: _angular_core.Signal<AXPFilterDefinition[]>;
+    /**
+     * Serialize filter values to plain objects (remove signals, functions, etc.)
+     */
+    serializeFilters(filters: any): AXPFilterQuery[];
+}
+declare const AXPEntityPreloadFiltersViewModelResolver: ResolveFn<Promise<AXPEntityPreloadFiltersViewModel>>;
+
+type AXPCollectEntityQuickSearchPathsResolver = (moduleName: string, entityName: string) => Promise<AXPEntity | null>;
+/**
+ * Lodash-get paths for quick search from a single entity definition: string-like property names
+ * plus lookup `expose[].target` paths (e.g. `brand.title`).
+ */
+declare function collectQuickSearchPathsFromSingleEntityDefinition(entity: AXPEntity | null | undefined): string[];
+/**
+ * Adds dotted paths from master columns (`name` or `options.dataPath`), e.g. `person.fullName`, `jobDefinition.title`.
+ */
+declare function collectNestedFieldPathsFromEntityColumns(entity: AXPEntity | null | undefined): string[];
+/**
+ * Collects lodash-get field paths used for mock/API quick search (`contains` / OR filters):
+ * host properties and lookup expose targets, dotted column paths, and merge-detail related entities
+ * prefixed with the related entity merge `persistence.dataPath` (e.g. `person.firstName`).
+ */
+declare function collectEntityQuickSearchFieldPaths(entity: AXPEntity | null | undefined, resolveRelatedDefinition: AXPCollectEntityQuickSearchPathsResolver): Promise<string[]>;
+
+interface AXPEntityPreloadEntity {
+    module: string;
+    entity: string;
+}
+interface AXPEntityDefinitionPreloader {
+    preload(): AXPEntityPreloadEntity[];
+}
+declare class AXPEntityDefinitionRegistryService {
+    private middleware;
+    private columnEnrichment;
+    private onChanged;
+    get onChanged$(): rxjs.Observable<{
+        name: string;
+    }>;
+    private entities;
+    private entityResolver;
+    /**
+     * Force re-load and re-process entity definitions, then re-register them.
+     * Overloads:
+     *  - refresh(): refresh all registered entities
+     *  - refresh(fullName: string): refresh by fully-qualified name `<module>.<entity>`
+     *  - refresh(moduleName: string, entityName: string): refresh by parts
+     */
+    refresh(): Promise<void>;
+    refresh(fullName: string): Promise<void>;
+    refresh(moduleName: string, entityName: string): Promise<void>;
+    /** Executes the actual refresh for a single entity */
+    private refreshOne;
+    /**
+     * Registers a new entity configuration. Entities are identified uniquely by a combination
+     * of their module and name.
+     *
+     * @param config The configuration object of the entity to be registered.
+     */
+    register(config: AXPEntity): void;
+    /**
+     * Returns an array of all registered entity configurations.
+     *
+     * @returns An array of AXPEntity objects.
+     */
+    getAll(): AXPEntity[];
+    /**
+     * Clear all registered entity configurations.
+     * Should be called when modules are cleared to prevent stale entity data.
+     * @param preserveModules Optional list of module names whose entities should be preserved
+     */
+    clear(preserveModules?: string[]): void;
+    /**
+     * Resolves an entity configuration based on module and entity name. If the configuration
+     * is not already registered, attempts to load it dynamically. Throws an error if the
+     * entity cannot be found or loaded.
+     *
+     * @param moduleName The module name of the entity.
+     * @param entityName The name of the entity.
+     * @returns A promise resolving to the entity configuration.
+     * @throws Error if the entity configuration cannot be resolved.
+     */
+    resolve(moduleName: string, entityName: string): Promise<AXPEntity>;
+    exists(moduleName: string, entityName: string): Promise<boolean>;
+    /**
+     * Creates a unique key for an entity based on its module and name.
+     *
+     * @param moduleName The module name of the entity.
+     * @param entityName The name of the entity.
+     * @returns The unique key for the entity.
+     */
+    private createEntityKey;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityDefinitionRegistryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityDefinitionRegistryService>;
+}
+
+type AXPEntityAggregateReducerType = 'count' | 'sum' | 'min' | 'max' | 'avg';
+interface AXPEntityAggregateMeasure {
+    reducer: AXPEntityAggregateReducerType;
+    /** Required for sum, min, max, and avg. Ignored for count (rows per group). */
+    field?: string;
+    /** Result column name; defaults are derived from the reducer and field. */
+    alias?: string;
+}
+/**
+ * Aggregate stored rows after the same filter/sort pipeline as {@link AXPQueryRequest}.
+ * Group keys use dotted field paths (same as lodash-style getters).
+ */
+interface AXPEntityAggregateRequest extends Pick<AXPQueryRequest, 'filter' | 'sort'> {
+    groupBy: string[];
+    measures: AXPEntityAggregateMeasure[];
+}
+interface AXPEntityAggregateResult {
+    rows: Record<string, unknown>[];
+}
+interface AXPEntityQueryAllOptions {
+    /**
+     * Page size for backends that read page-by-page (HTTP API).
+     * In-memory backends load the filtered set once and ignore this.
+     */
+    pageSize?: number;
+    /** Maximum rows to return or scan (safety cap). */
+    maxRows?: number;
+}
+interface AXPEntityQueryAllResult<T> {
+    items: T[];
+    /** Row count matching filter/sort before applying maxRows. */
+    total: number;
+    /** True when maxRows prevented returning every matching row. */
+    truncated: boolean;
+}
+interface AXPEntityAggregateOptions {
+    /** Maximum rows to load for aggregation when the backend pages remotely (default 50_000). */
+    maxRows?: number;
+    /** Page size for remote paging during aggregate (default 500). */
+    pageSize?: number;
+}
+
+/**
+ * Pure aggregation over already-filtered plain rows (e.g. outputs of {@link filterSortEntityRows}).
+ */
+declare function computeEntityAggregates<T extends Record<string, unknown>>(rows: T[], request: AXPEntityAggregateRequest): Record<string, unknown>[];
+
+interface RunEntityQueryAdapters<T = unknown> {
+    getRawAll(entityName: string): Promise<T[]>;
+    getDirectChildCount(categoryId: string, entityName: string): Promise<number>;
+    getAllChildCategoryIds(categoryId: string, entityName: string): Promise<string[]>;
+}
+/**
+ * Check if the entity is a category entity (ends with 'Category').
+ */
+declare function isCategoryEntity(entityName: string): boolean;
+/**
+ * Check if the filter is a category filter (contains operator on categoryIds field).
+ * Handles both simple filters and compound filters.
+ */
+declare function isCategoryFilter(filter: any): boolean;
+/**
+ * Loads raw rows for an entity and applies the same sorting and filtering as {@link runEntityQuery},
+ * without pagination.
+ */
+declare function filterSortEntityRows<T = unknown>(entityName: string, request: Pick<AXPQueryRequest, 'filter' | 'sort'>, adapters: RunEntityQueryAdapters<T>): Promise<T[]>;
+/**
+ * Shared entity query logic: sort, filter (including recursive category filter), childrenCount, pagination.
+ */
+declare function runEntityQuery<T = unknown>(entityName: string, request: AXPQueryRequest, adapters: RunEntityQueryAdapters<T>): Promise<AXPPagedListResult<T>>;
+
+/**
+ * One audit point in time for a record lifecycle event.
+ *
+ * Used inside {@link AXPRecordAuditInfo} (`created`, `updated`, `deleted`).
+ * Backends and mock middleware typically set `at` and `by`; `reason` and `source`
+ * (for example `api`, `system`, `import`) are optional diagnostic fields.
+ */
+interface AXPAuditEvent {
+    at?: Date;
+    by?: AXPUserReference;
+    /** Optional business or technical reason for the event. */
+    reason?: string;
+    /** Optional origin of the change (for example `api`, `system`, `import`). */
+    source?: string;
+}
+/**
+ * Aggregated audit trail for a persisted row.
+ *
+ * Filled by APIs or connectivity mock middleware when creating, updating, or
+ * soft-deleting records. UI surfaces may show these via the history plugin or
+ * custom columns. Version snapshot pipelines often **omit** this object from
+ * stored snapshots while still applying it to live payloads.
+ *
+ * @remarks Fields are optional today; callers should tolerate partial data.
+ */
+interface AXPRecordAuditInfo {
+    created?: AXPAuditEvent;
+    updated?: AXPAuditEvent;
+    deleted?: AXPAuditEvent;
+}
+/**
+ * Cross-cutting flags that are not part of the domain schema but affect how a
+ * row is shown or edited (visibility, built-in/system rows, immutability).
+ *
+ * Module entity models sometimes expose only this slice (for example
+ * `stateInfo` on business units) when the rest of the row uses a bespoke shape.
+ *
+ * @remarks Entity list/detail flows should honor these flags where applicable.
+ */
+interface AXPRecordStateInfo {
+    isHidden?: boolean;
+    isSystem?: boolean;
+    isImmutable?: boolean;
+    /** @deprecated Prefer explicit domain modeling over this flag. */
+    isDistributed?: boolean;
+}
+/**
+ * Tenancy and actor scope for a row in a multi-tenant application.
+ *
+ * Used to associate a record with a tenant, application instance, or owning
+ * user when the API returns ownership metadata alongside domain fields.
+ */
+interface AXPRecordOwnershipInfo {
+    tenantId?: string;
+    applicationId?: string;
+    userId?: string;
+}
+/**
+ * Workflow linkage for a domain record (set when a run is started or bound).
+ *
+ * Populated by workflow engine, middleware, or integration — not declared as
+ * entity definition properties. Entities with the `workflow` plugin may carry
+ * this object when a {@link WorkflowManagement.WorkflowInstance} drives the row.
+ */
+interface AXPRecordWorkflowInfo {
+    /** Workflow instance id for this record's active or last run. */
+    instanceId?: string | null;
+    /** Logical workflow definition id (same as WorkflowInstance.definitionId). */
+    definitionId?: string | null;
+    /** Correlation id for idempotent start and related-run lookup (same as WorkflowInstance.correlationId). */
+    correlationId?: string | null;
+    /** When set, pins the run to a workflow definition version; omit for current default. */
+    pinnedVersion?: number | null;
+}
+/** Entity query filter field for {@link AXPRecordWorkflowInfo.instanceId}. */
+declare const AXP_RECORD_WORKFLOW_INFO_INSTANCE_ID_FIELD: "workflowInfo.instanceId";
+/** Entity query filter field for {@link AXPRecordWorkflowInfo.correlationId}. */
+declare const AXP_RECORD_WORKFLOW_INFO_CORRELATION_ID_FIELD: "workflowInfo.correlationId";
+/** Entity query filter field for {@link AXPRecordWorkflowInfo.definitionId}. */
+declare const AXP_RECORD_WORKFLOW_INFO_DEFINITION_ID_FIELD: "workflowInfo.definitionId";
+/** Returns a trimmed workflow instance id from a record, if present. */
+declare function getRecordWorkflowInstanceId(record: {
+    workflowInfo?: AXPRecordWorkflowInfo | null;
+} | null | undefined): string | null;
+/** Returns a trimmed workflow correlation id from a record, if present. */
+declare function getRecordWorkflowCorrelationId(record: {
+    workflowInfo?: AXPRecordWorkflowInfo | null;
+} | null | undefined): string | null;
+/** Builds canonical workflow metadata for a domain record (engine / middleware). */
+declare function buildAXPRecordWorkflowInfo(params: {
+    instanceId: string;
+    definitionId?: string | null;
+    correlationId?: string | null;
+    pinnedVersion?: number | null;
+}): AXPRecordWorkflowInfo;
+/**
+ * Base shape for **entity row** TypeScript models across modules: a stable
+ * identifier plus optional platform metadata.
+ *
+ * Module-specific interfaces extend this with domain properties
+ * (`extends AXPEntityModel<string>` / `AXPEntityModel<Id>`) while reusing
+ * `auditInfo`, `stateInfo`, `ownershipInfo`, and `workflowInfo` when the backend sends them.
+ */
+interface AXPEntityModel<Id> {
+    id: Id;
+    auditInfo?: AXPRecordAuditInfo;
+    stateInfo?: AXPRecordStateInfo;
+    ownershipInfo?: AXPRecordOwnershipInfo;
+    workflowInfo?: AXPRecordWorkflowInfo;
+}
+interface AXPEntityCreateDto {
+}
+interface AXPEntityUpdateDto<Id> {
+    id: Id;
+}
+interface AXPEntityOutputDto<Id> {
+    id: Id;
+}
+interface AXPEntityDetailDto<Id> extends AXPEntityOutputDto<Id> {
+}
+interface AXPEntityListItemDto<Id> extends AXPEntityOutputDto<Id> {
+}
+
+declare abstract class AXPEntityStorageService<TKey, TDetailDto extends AXPEntityDetailDto<TKey> = AXPEntityModel<TKey>, TListItemDto extends AXPEntityListItemDto<TKey> = TDetailDto, TCreateDto extends AXPEntityCreateDto = TDetailDto, TUpdateDto extends AXPEntityUpdateDto<TKey> = TDetailDto> {
+    abstract get dbName(): string;
+    abstract initial(entityName: string, collection: TCreateDto[], options?: {
+        mergeType?: 'merge' | 'replace';
+        uniqueKeys?: string[];
+    }): Promise<TCreateDto[]>;
+    abstract getOne(entityName: string, id: TKey): Promise<TDetailDto>;
+    abstract updateOne(entityName: string, id: TKey, keyValues: Omit<Partial<TUpdateDto>, 'id'>): Promise<TDetailDto>;
+    abstract deleteOne(entityName: string, id: TKey): Promise<void>;
+    abstract insertOne(entityName: string, entity: TCreateDto): Promise<TKey>;
+    abstract getAll(entityName: string): Promise<TListItemDto[]>;
+    abstract query(entityName: string, request: AXPQueryRequest): Promise<AXPPagedListResult<TListItemDto>>;
+    abstract count(entityName: string, request: Pick<AXPQueryRequest, 'filter' | 'sort'>): Promise<number>;
+    abstract queryAll(entityName: string, request: Pick<AXPQueryRequest, 'filter' | 'sort'>, options?: AXPEntityQueryAllOptions): Promise<AXPEntityQueryAllResult<TListItemDto>>;
+    abstract getMany(entityName: string, ids: TKey[]): Promise<(TListItemDto | null)[]>;
+    abstract exists(entityName: string, id: TKey): Promise<boolean>;
+    abstract upsertOne(entityName: string, entity: TCreateDto, options?: {
+        merge?: boolean;
+    }): Promise<TKey>;
+    abstract aggregate(entityName: string, request: AXPEntityAggregateRequest, options?: AXPEntityAggregateOptions): Promise<AXPEntityAggregateResult>;
+}
+declare abstract class AXPEntityDataProvider<TKey, TDetailDto extends AXPEntityDetailDto<TKey> = AXPEntityModel<TKey>, TListItemDto extends AXPEntityListItemDto<TKey> = TDetailDto, TCreateDto extends AXPEntityCreateDto = TDetailDto, TUpdateDto extends AXPEntityUpdateDto<TKey> = TDetailDto> {
+    abstract get entityName(): string;
+    abstract initial(collection: TCreateDto[]): Promise<void>;
+    abstract getOne(id: TKey): Promise<TDetailDto>;
+    abstract getAll(): Promise<TListItemDto[]>;
+    abstract updateOne(id: TKey, keyValues: Omit<Partial<TUpdateDto>, 'id'>): Promise<TDetailDto>;
+    abstract deleteOne(id: TKey): Promise<void>;
+    abstract insertOne(entity: TCreateDto): Promise<TKey>;
+    abstract query(request: AXPQueryRequest): Promise<AXPPagedListResult<TListItemDto>>;
+    abstract count(request: Pick<AXPQueryRequest, 'filter' | 'sort'>): Promise<number>;
+    abstract queryAll(request: Pick<AXPQueryRequest, 'filter' | 'sort'>, options?: AXPEntityQueryAllOptions): Promise<AXPEntityQueryAllResult<TListItemDto>>;
+    abstract getMany(ids: TKey[]): Promise<(TListItemDto | null)[]>;
+    abstract exists(id: TKey): Promise<boolean>;
+    abstract upsertOne(entity: TCreateDto, options?: {
+        merge?: boolean;
+    }): Promise<TKey>;
+    abstract aggregate(request: AXPEntityAggregateRequest, options?: AXPEntityAggregateOptions): Promise<AXPEntityAggregateResult>;
+}
+declare class AXPEntityDataProviderImpl<TKey, TDetailDto extends AXPEntityDetailDto<TKey> = AXPEntityModel<TKey>, TListItemDto extends AXPEntityListItemDto<TKey> = TDetailDto, TCreateDto extends AXPEntityCreateDto = TDetailDto, TUpdateDto extends AXPEntityUpdateDto<TKey> = TDetailDto> implements AXPEntityDataProvider<TKey, TDetailDto, TListItemDto, TCreateDto, TUpdateDto> {
+    private storageService;
+    entityName: string;
+    constructor(storageService: AXPEntityStorageService<TKey, TDetailDto, TListItemDto, TCreateDto, TUpdateDto>, entityName: string);
+    initial(collection: TCreateDto[]): Promise<void>;
+    getOne(id: TKey): Promise<TDetailDto>;
+    getAll(): Promise<TListItemDto[]>;
+    query(request: AXPQueryRequest): Promise<AXPPagedListResult<TListItemDto>>;
+    updateOne(id: TKey, keyValues: Omit<Partial<TUpdateDto>, 'id'>): Promise<TDetailDto>;
+    deleteOne(id: TKey): Promise<void>;
+    insertOne(entity: TCreateDto): Promise<TKey>;
+    count(request: Pick<AXPQueryRequest, 'filter' | 'sort'>): Promise<number>;
+    queryAll(request: Pick<AXPQueryRequest, 'filter' | 'sort'>, options?: AXPEntityQueryAllOptions): Promise<AXPEntityQueryAllResult<TListItemDto>>;
+    getMany(ids: TKey[]): Promise<(TListItemDto | null)[]>;
+    exists(id: TKey): Promise<boolean>;
+    upsertOne(entity: TCreateDto, options?: {
+        merge?: boolean;
+    }): Promise<TKey>;
+    aggregate(request: AXPEntityAggregateRequest, options?: AXPEntityAggregateOptions): Promise<AXPEntityAggregateResult>;
+}
+declare abstract class AXMEntityCrudService<TKey, TDetailDto extends AXPEntityDetailDto<TKey> = AXPEntityModel<TKey>, TListItemDto extends AXPEntityListItemDto<TKey> = TDetailDto, TCreateDto extends AXPEntityCreateDto = TDetailDto, TUpdateDto extends AXPEntityUpdateDto<TKey> = TDetailDto> {
+    abstract insertOne(request: TCreateDto): Promise<TKey>;
+    abstract getOne(id: TKey): Promise<TDetailDto>;
+    abstract deleteOne(id: TKey): Promise<void>;
+    abstract updateOne(id: TKey, values: Omit<Partial<TUpdateDto>, 'id'>): Promise<TDetailDto>;
+    abstract query(request: AXPQueryRequest): Promise<AXPPagedListResult<TListItemDto>>;
+}
+declare class AXMEntityCrudServiceImpl<TKey, TDetailDto extends AXPEntityDetailDto<TKey> = AXPEntityModel<TKey>, TListItemDto extends AXPEntityListItemDto<TKey> = TDetailDto, TCreateDto extends AXPEntityCreateDto = Omit<TDetailDto, 'id'>, TUpdateDto extends AXPEntityUpdateDto<TKey> = TDetailDto> {
+    private entityName;
+    private _storageService;
+    private entityRegistery;
+    private _entityDataProvider;
+    private _entityCategoryDataProvider;
+    constructor(entityName: string);
+    insertOne(request: TCreateDto): Promise<TKey>;
+    getOne(id: TKey): Promise<TDetailDto>;
+    deleteOne(id: TKey): Promise<void>;
+    updateOne(id: TKey, values: Omit<Partial<TUpdateDto>, 'id'>): Promise<TDetailDto>;
+    query(request?: AXPQueryRequest): Promise<AXPPagedListResult<TListItemDto>>;
+    findOne(filter: AXDataSourceFilterOption): Promise<TListItemDto>;
+    getRoots(request: {}): Promise<AXPPagedListResult<TListItemDto>>;
+    getChildren(request: {
+        parentId: TKey;
+        parentKey?: string;
+    }): Promise<AXPPagedListResult<TListItemDto>>;
+    getByCategory(request: {
+        categoryId: TKey;
+        categoryKey?: string;
+    }): Promise<AXPPagedListResult<TListItemDto>>;
+    getCategoriesList(request?: AXPQueryRequest): Promise<AXPPagedListResult<AXPCategoryEntity$1<TKey>>>;
+    get storageService(): AXPEntityStorageService<any, any, any, any, any>;
+    count(request: Pick<AXPQueryRequest, 'filter' | 'sort'>): Promise<number>;
+    queryAll(request: Pick<AXPQueryRequest, 'filter' | 'sort'>, options?: AXPEntityQueryAllOptions): Promise<AXPEntityQueryAllResult<TListItemDto>>;
+    getMany(ids: TKey[]): Promise<(TListItemDto | null)[]>;
+    exists(id: TKey): Promise<boolean>;
+    upsertOne(entity: TCreateDto, options?: {
+        merge?: boolean;
+    }): Promise<TKey>;
+    aggregate(request: AXPEntityAggregateRequest, options?: AXPEntityAggregateOptions): Promise<AXPEntityAggregateResult>;
+    custom<Req, Res>(request: Req): Promise<void>;
+}
+
+interface AXPEntityConfigs {
+    viewers: {
+        root: () => Type<any> | Promise<Type<any>>;
+        detail: {
+            list: () => Type<any> | Promise<Type<any>>;
+        };
+        master: {
+            single: () => Type<any> | Promise<Type<any>>;
+            details: () => Type<any> | Promise<Type<any>>;
+            create: () => Type<any> | Promise<Type<any>>;
+            modify: () => Type<any> | Promise<Type<any>>;
+            list: () => Type<any> | Promise<Type<any>>;
+        };
+    };
+}
+declare const AXP_ENTITY_CONFIG_TOKEN: InjectionToken<AXPEntityConfigs>;
+/** Raw input from entity loaders' list(). */
+type AXPEntityListInput = {
+    name: string;
+    module: string;
+};
+/** Output from listAll(); fullName is populated by the resolver. */
+type AXPEntityListEntry = {
+    name: string;
+    module: string;
+    fullName: string;
+};
+interface AXPEntityDefinitionLoader {
+    get(moduleName: string, entityName: string): Promise<AXPEntity | null>;
+    list(): Promise<AXPEntityListInput[]>;
+}
+declare const AXP_ENTITY_DEFINITION_LOADER: InjectionToken<AXPEntityDefinitionLoader>;
+declare class AXPEntityResolver {
+    private providers;
+    /** Aggregates list() from all entity loaders (including lazy). Populates fullName. */
+    listAll(): Promise<AXPEntityListEntry[]>;
+    get(moduleName: string, entityName: string): Promise<AXPEntity | null>;
+    private resolveLoaders;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityResolver, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityResolver>;
+}
+
+declare class AXPAttachmentsPluginModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPAttachmentsPluginModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXPAttachmentsPluginModule, never, never, never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXPAttachmentsPluginModule>;
+}
+
+declare class AXPEntityModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXPEntityModule, never, [typeof i1.RouterModule, typeof AXPAttachmentsPluginModule, typeof i3.AXPWorkflowModule, typeof i4.AXPWidgetCoreModule, typeof i5.LayoutBuilderModule], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXPEntityModule>;
+}
+
+/**
+ * Data accessor for entity operations.
+ * Provides methods to query and execute commands with smart resolution:
+ * 1. Checks entity definition queries/commands first
+ * 2. Falls back to CRUD service if not defined
+ */
+declare class EntityDataAccessor<TKey = any, TDetailDto extends AXPEntityDetailDto<TKey> = AXPEntityModel<TKey>, TListItemDto extends AXPEntityListItemDto<TKey> = TDetailDto, TCreateDto extends AXPEntityCreateDto = Omit<TDetailDto, 'id'>, TUpdateDto extends AXPEntityUpdateDto<TKey> = TDetailDto> {
+    private module;
+    private entity;
+    private entityRegistry;
+    private queryExecutor;
+    private commandService;
+    private crudService;
+    private entityDef;
+    private entityDefPromise;
+    constructor(module: string, entity: string, entityRegistry: AXPEntityDefinitionRegistryService, queryExecutor: AXPQueryExecutor, commandService: AXPCommandService);
+    /**
+     * Resolves the entity definition lazily and caches it.
+     * @returns The resolved entity definition
+     */
+    private resolveEntityDef;
+    /**
+     * Gets a single entity by key.
+     * @param key - The entity key
+     * @returns The entity detail or null if not found
+     */
+    byKey(key: TKey): Promise<TDetailDto | null>;
+    /**
+     * Queries a list of entities.
+     * @param request - The query request (optional)
+     * @returns The paged list result
+     */
+    query(request?: AXPQueryRequest): Promise<AXPPagedListResult<TListItemDto>>;
+    /**
+     * Creates a new entity.
+     * @param data - The entity data to create
+     * @returns The created entity key
+     */
+    create(data: TCreateDto): Promise<TKey>;
+    /**
+     * Updates an existing entity.
+     * @param id - The entity key
+     * @param data - The entity data to update
+     * @returns The updated entity
+     */
+    update(id: TKey, data: Omit<Partial<TUpdateDto>, 'id'>): Promise<TDetailDto>;
+    /**
+     * Deletes an entity.
+     * @param id - The entity key
+     */
+    delete(id: TKey): Promise<void>;
+}
+/**
+ * Builder class for entity operations.
+ * Provides methods to create paths and access entity data.
+ */
+declare class EntityBuilder {
+    private sessionService;
+    private entityRegistry;
+    private queryExecutor;
+    private commandService;
+    readonly module: string;
+    readonly entity: string;
+    constructor(module: string, entity: string, sessionService: AXPSessionService, entityRegistry: AXPEntityDefinitionRegistryService, queryExecutor: AXPQueryExecutor, commandService: AXPCommandService);
+    /**
+     * Creates a path for the entity.
+     * @param path - The path segment (defaults to 'list')
+     * @returns The full path string
+     */
+    createPath(path?: string): string;
+    /**
+     * Gets the data accessor for the entity with generic type support.
+     * Entity definition is resolved lazily on first method call.
+     * @returns An EntityDataAccessor instance
+     */
+    data<TKey = any, TDetailDto extends AXPEntityDetailDto<TKey> = AXPEntityModel<TKey>, TListItemDto extends AXPEntityListItemDto<TKey> = TDetailDto, TCreateDto extends AXPEntityCreateDto = Omit<TDetailDto, 'id'>, TUpdateDto extends AXPEntityUpdateDto<TKey> = TDetailDto>(): EntityDataAccessor<TKey, TDetailDto, TListItemDto, TCreateDto, TUpdateDto>;
+}
+declare class AXPEntityService {
+    private sessionService;
+    private entityRegistry;
+    private queryExecutor;
+    private commandService;
+    /**
+     * @deprecated Use `withEntity(module, entity).createPath(path)` instead.
+     * This method will be removed in a future version.
+     */
+    createPath(module: string, entity: string, path?: string): string;
+    /**
+     * Creates a builder for entity operations.
+     * Entity definition is resolved lazily when data accessor methods are called.
+     * @param module - The module name
+     * @param entity - The entity name
+     * @returns An EntityBuilder instance
+     */
+    withEntity(module: string, entity: string): EntityBuilder;
+    /**
+     * Creates a builder for entity operations using dot notation.
+     * Entity definition is resolved lazily when data accessor methods are called.
+     * @param entityKey - The entity key in format "module.entity"
+     * @returns An EntityBuilder instance
+     * @throws Error if the entity key format is invalid
+     */
+    withEntity(entityKey: string): EntityBuilder;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityService>;
+}
+
+/** How to show attachments in entity single/create/update: as a section (default) or as a separate page. */
+type AttachmentsDisplayMode = 'section' | 'page';
+/** Component key used when display is 'page'. Register a page component with this key via AXP_PAGE_COMPONENT_PROVIDER. */
+declare const ATTACHMENTS_PAGE_COMPONENT_KEY = "entity-attachments-page";
+type AttachmentLocalizedText = string | Record<string, string>;
+type AttachmentSectionOptions = {
+    order?: number;
+    title?: AttachmentLocalizedText;
+};
+type AttachmentsEditDialogOptions = {
+    mode?: 'manual' | 'auto';
+    fields?: {
+        name?: boolean;
+        title?: boolean;
+        description?: boolean;
+    };
+};
+type AttachmentsPluginOptions = {
+    field?: string;
+    title?: AttachmentLocalizedText;
+    display?: AttachmentsDisplayMode;
+    accept?: string;
+    multiple?: boolean;
+    fileEditable?: boolean;
+    /** When true, attachments field and list action run in read-only mode (widget option `readonly`). */
+    'readonly'?: boolean;
+    /** When true (default), registers a list column for the attachments field. Set false to hide the column. */
+    showListColumn?: boolean;
+    /** When true (default), registers the list upload action. Set false to omit the action. */
+    showListAction?: boolean;
+    /** Section options when display is 'section'. */
+    section?: AttachmentSectionOptions;
+    /** File edit dialog options. */
+    editDialog?: AttachmentsEditDialogOptions;
+    plugins?: {
+        name: string;
+        options?: unknown;
+    }[];
+    /** Widget option `showBorder`. Default false for attachments (section and page). */
+    showBorder?: boolean;
+    /** Widget option `showAddItemButton`. Default false when display is `page`, true for section. */
+    showAddItemButton?: boolean;
+};
+/**
+ * Attachments plugin.
+ * - Always ensures an attachments group and property; when display is 'section' (default), adds a section to single/create/update layouts.
+ * - When display is 'page', adds a page to entity.pages with ATTACHMENTS_PAGE_COMPONENT_KEY; register a page component with that key via AXP_PAGE_COMPONENT_PROVIDER.
+ * - List column and list upload action can be turned off with `showListColumn` / `showListAction` (both default true).
+ * - Uses provided accept/multiple/fileEditable; others are fixed.
+ */
+declare const attachmentsPlugin: AXPEntityActionPlugin;
+
+interface AXPEntityStorageContext<TKey = any, TDetailDto extends AXPEntityDetailDto<TKey> = any, TListItemDto extends AXPEntityListItemDto<TKey> = any, TCreateDto extends AXPEntityCreateDto = any, TUpdateDto extends AXPEntityUpdateDto<TKey> = any> {
+    op: AXPEntityOp;
+    entityName: string;
+    id?: TKey;
+    data?: TCreateDto | Omit<Partial<TUpdateDto>, 'id'>;
+    request?: AXPQueryRequest;
+    previous?: TDetailDto;
+    result?: any;
+    locals: Map<string, unknown>;
+    backend: {
+        getOne: (entityName: string, id: TKey) => Promise<TDetailDto>;
+        insertOne: (entityName: string, entity: TCreateDto) => Promise<TKey>;
+        query: (entityName: string, request: AXPQueryRequest) => Promise<AXPPagedListResult<TListItemDto>>;
+        updateOne: (entityName: string, id: TKey, data: Partial<TUpdateDto>) => Promise<TDetailDto>;
+        deleteOne: (entityName: string, id: TKey) => Promise<void>;
+        count: (entityName: string, request: Pick<AXPQueryRequest, 'filter' | 'sort'>) => Promise<number>;
+        queryAll: (entityName: string, request: Pick<AXPQueryRequest, 'filter' | 'sort'>, options?: AXPEntityQueryAllOptions) => Promise<AXPEntityQueryAllResult<TListItemDto>>;
+        getMany: (entityName: string, ids: TKey[]) => Promise<(TListItemDto | null)[]>;
+        exists: (entityName: string, id: TKey) => Promise<boolean>;
+        upsertOne: (entityName: string, entity: TCreateDto, options?: {
+            merge?: boolean;
+        }) => Promise<TKey>;
+        aggregate: (entityName: string, request: AXPEntityAggregateRequest, options?: AXPEntityAggregateOptions) => Promise<AXPEntityAggregateResult>;
+    };
+}
+interface AXPEntityStorageMiddleware<TKey = any, TDetailDto extends AXPEntityDetailDto<TKey> = any, TListItemDto extends AXPEntityListItemDto<TKey> = any, TCreateDto extends AXPEntityCreateDto = any, TUpdateDto extends AXPEntityUpdateDto<TKey> = any> {
+    target?: {
+        ops?: AXPEntityOp[];
+        entity?: string | RegExp;
+        predicate?: (ctx: AXPEntityStorageContext<TKey, TDetailDto, TListItemDto, TCreateDto, TUpdateDto>) => boolean;
+        order?: number;
+    };
+    execute: (ctx: AXPEntityStorageContext<TKey, TDetailDto, TListItemDto, TCreateDto, TUpdateDto>, next: () => Promise<void>) => Promise<void>;
+}
+/**
+ * Error type that can be thrown by middlewares to abort the chain with a structured payload.
+ */
+declare class AXPMiddlewareAbortError extends Error {
+    readonly message: string;
+    readonly options: {
+        code?: string;
+        status?: number;
+        details?: any;
+    };
+    constructor(message: string, options?: {
+        code?: string;
+        status?: number;
+        details?: any;
+    });
+    toResponse(): AXPMiddlewareErrorResponse;
+}
+/** Type guard for AXPMiddlewareAbortError */
+declare function isAXPMiddlewareAbortError(error: unknown): error is AXPMiddlewareAbortError;
+
+declare const eventDispatchMiddleware: AXPEntityStorageMiddleware;
+
+/**
+ * Entity modifier that applies column widths using the column width service
+ * Uses the generic column width resolution system from core library
+ * Note: inject() works here because modifiers are executed via runInInjectionContext()
+ */
+declare const columnWidthMiddleware: AXPEntityModifier;
+/**
+ * Default provider that applies column width middleware to all entities
+ */
+declare const columnWidthMiddlewareProvider: AXPEntityModifierProvider;
+
+/**
+ * Default order for common list view columns.
+ * Lower numbers appear first. Columns not in this map get order 500 (middle).
+ * Use high numbers (990+) for columns that should appear at the end.
+ */
+declare const DEFAULT_COLUMN_ORDER: Record<string, number>;
+/**
+ * Entity modifier that sorts list view columns by default order.
+ * Similar to layout-ordering for sections/properties, but for list columns.
+ */
+declare const columnOrderingMiddleware: AXPEntityModifier;
+/**
+ * Factory to create a column ordering middleware with custom order config
+ */
+declare const createColumnOrderingMiddlewareProvider: (columnOrder?: Record<string, number>, entityName?: string | RegExp) => AXPEntityModifierProvider;
+/**
+ * Default provider that applies column ordering to all entities
+ */
+declare const columnOrderingMiddlewareProvider: AXPEntityModifierProvider;
+
+/**
+ * Default colSpans for two properties in one section (`md` / `lg`).
+ * Missing `positions[*].colSpan` are filled only; entities keep full control.
+ */
+interface PairSpanRule {
+    first: string;
+    second: string;
+    /** Col span applied to {@link first} */
+    firstSpan: number;
+    /** Col span applied to {@link second} */
+    secondSpan: number;
+    breakpoints?: readonly ('sm' | 'md' | 'lg')[];
+}
+interface SectionOrderConfig {
+    sections: Record<string, number>;
+    properties: Record<string, number>;
+    /**
+     * Defaults for pairing two columns (e.g. code + title). Replace or extend defaults.
+     * - `undefined`: use {@link DEFAULT_PAIR_SPAN_RULES}
+     * - `false`: do not apply any pair spans
+     * - `[...]` + spread `DEFAULT_PAIR_SPAN_RULES` when you want to append custom pairs
+     */
+    pairSpanRules?: PairSpanRule[] | false;
+}
+/**
+ * Default shipped rules: narrow identifier + wider title on `md` / `lg`.
+ */
+declare const DEFAULT_PAIR_SPAN_RULES: readonly PairSpanRule[];
+declare const DEFAULT_SECTION_ORDER: Record<string, number>;
+declare const DEFAULT_PROPERTY_ORDER: Record<string, number>;
+declare const layoutOrderingMiddlewareFactory: (config: SectionOrderConfig) => AXPEntityModifier;
+declare const createLayoutOrderingMiddlewareProvider: (config?: Partial<SectionOrderConfig>, entityName?: string | RegExp) => AXPEntityModifierProvider;
+declare const layoutOrderingMiddlewareProvider: AXPEntityModifierProvider;
+
+/**
+ * Provides synchronous access to the ApplyLayoutOrdering setting.
+ * Used by layout ordering middleware to avoid async in the modifier and prevent startup deadlocks.
+ * Value is updated on onLoaded/onChanged; first read can trigger a one-time background get (no await).
+ */
+declare class AXPLayoutOrderingConfigService {
+    private readonly settingsService;
+    private readonly _applyOrdering;
+    private syncScheduled;
+    constructor();
+    getApplyOrdering(): boolean;
+    private syncFromSettings;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLayoutOrderingConfigService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPLayoutOrderingConfigService>;
+}
+
+/**
+ * Ensures all entities have a searchResult.description.
+ * Uses @{i18nScope}:module.title when missing (guaranteed to exist in i18n).
+ */
+declare const searchResultDescriptionMiddleware: AXPEntityModifier;
+declare const searchResultDescriptionMiddlewareProvider: AXPEntityModifierProvider;
+
+/**
+ * When enabled in regional settings ({@link AXPRegionalSetting.MultiLanguageSupport}), walks each
+ * property's `schema.interface` widget tree and sets `options.multiLanguage` on matching text-like
+ * editors (including nested GridLayout leaves such as `pre.content` / `post.summaryContent`), unless
+ * the node already specifies `multiLanguage` (including explicit false to opt out).
+ */
+declare const defaultMultiLanguageMiddleware: AXPEntityModifier;
+declare const defaultMultiLanguageMiddlewareProvider: AXPEntityModifierProvider;
+
+/**
+ * When an entity has no `interfaces.master.list.layouts.card`, creates a sensible default
+ * from list columns and property names (title, description, remaining columns as card fields).
+ */
+declare const defaultCardLayoutMiddleware: AXPEntityModifier;
+declare const defaultCardLayoutMiddlewareProvider: AXPEntityModifierProvider;
+
+/**
+ * Registers entity CRUD commands and queries for the given entity keys.
+ * Use in app/module providers; consumes AXPEntityService from this package.
+ */
+declare function provideEntity(entityKeys: string[]): EnvironmentProviders;
+
+interface AXPGetEntityDetailsQueryInput {
+    entity: string;
+    id: string;
+}
+interface AXPGetEntityDetailsQueryResult {
+    success: boolean;
+    entityDefinition?: AXPEntity;
+    entityData?: any;
+    error?: string;
+}
+/**
+ * Generic query to get entity details including entity definition and entity data
+ * Can be used by any entity to retrieve its definition and data by ID
+ */
+declare class AXPGetEntityDetailsQuery implements AXPQuery<AXPGetEntityDetailsQueryInput, AXPGetEntityDetailsQueryResult> {
+    private readonly entityDefinitionRegistry;
+    private readonly injector;
+    /**
+     * Execute the query to fetch entity definition and data
+     * @param input - Query input containing entity and ID information
+     */
+    fetch(input: AXPGetEntityDetailsQueryInput): Promise<AXPGetEntityDetailsQueryResult>;
+    /**
+     * Get entity data using the entity's CRUD service
+     * @param entity - Full entity path (ModuleName.EntityName)
+     * @param id - Entity ID
+     * @returns Promise resolving to entity data
+     */
+    private getEntityData;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPGetEntityDetailsQuery, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPGetEntityDetailsQuery>;
+}
+
+/**
+ * i18n key for the synthetic root node ("all categories"). Resolve in templates with the translate pipe.
+ */
+declare const AXP_CATEGORY_TREE_ROOT_TITLE_I18N_KEY = "@general:terms.interface.selection.all-items";
+interface CategoryQueryEvent {
+    skip: number;
+    take: number;
+    sort?: AXDataSourceSortOption[];
+    filter?: {
+        field?: string;
+        value?: unknown;
+        operator?: {
+            type: string;
+        };
+        filters?: unknown[];
+        logic?: string;
+    };
+}
+interface CategoryQueryResult {
+    items: Record<string, unknown>[];
+    total?: number;
+    totalCount?: number;
+}
+type CategoryQueryFunction = (event: CategoryQueryEvent) => Promise<CategoryQueryResult>;
+interface CategoryTreeConfig {
+    entityKey: string;
+    textField?: string;
+    valueField?: string;
+    parentKey?: string;
+}
+interface CategoryTreeNodeData {
+    categoryEntityDef: AXPEntity | null;
+    categoryEntityQueryFunc: CategoryQueryFunction | null;
+    basicQueryEvent: CategoryQueryEvent;
+}
+declare class AXPCategoryTreeService {
+    protected readonly entityResolver: AXPEntityDefinitionRegistryService;
+    private readonly translation;
+    /** Sort field for list queries (backend); matches configured category display field. */
+    private getAlphabeticalSortOptions;
+    /**
+     * Sort tree nodes by resolved display title (locale-aware).
+     * Ensures correct order for multi-language titles when storage order differs from UI order.
+     */
+    private sortTreeNodesByDisplayTitle;
+    /**
+     * Initialize category tree data source
+     */
+    initializeCategoryTree(config: CategoryTreeConfig): Promise<CategoryTreeNodeData | null>;
+    /**
+     * Create root node with children from items
+     */
+    createRootNode(items: Record<string, unknown>[], config: CategoryTreeConfig): Promise<AXTreeViewNode>;
+    /**
+     * Convert entity item to AXTreeViewNode format
+     */
+    convertToTreeNode(item: Record<string, unknown>, config: CategoryTreeConfig): AXTreeViewNode;
+    /**
+     * Load root categories
+     */
+    loadRootCategories(treeData: CategoryTreeNodeData, config: CategoryTreeConfig): Promise<Record<string, unknown>[] | null>;
+    /**
+     * Fetches a single category item by ID. Uses byKey when available (full item with parent),
+     * otherwise falls back to list query with filter so ancestor chains can be built.
+     */
+    fetchItemById(id: string, treeData: CategoryTreeNodeData, config: CategoryTreeConfig): Promise<Record<string, unknown> | null>;
+    /**
+     * Load children for a given node
+     */
+    loadChildren(node: AXTreeViewNode, treeData: CategoryTreeNodeData, config: CategoryTreeConfig): Promise<AXTreeViewNode[]>;
+    /**
+     * Search categories recursively (all levels)
+     */
+    searchCategories(searchValue: string, treeData: CategoryTreeNodeData, config: CategoryTreeConfig): Promise<Record<string, unknown>[] | null>;
+    /**
+     * Update children at a specific node in the tree
+     */
+    updateChildrenAtPath(nodes: AXTreeViewNode[], targetId: string, childNodes: AXTreeViewNode[]): AXTreeViewNode[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPCategoryTreeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPCategoryTreeService>;
+}
+
+declare class AXPRelatedColumnEnrichmentService {
+    private readonly metadataResolver;
+    /**
+     * Enriches entity columns with:
+     * 1. dataPath for FK columns (e.g. fromPersonId) derived from lookup property schema
+     * 2. title and showAs from related entity properties for dotted paths (e.g. person.firstName)
+     */
+    enrich(entity: AXPEntity): Promise<AXPEntity>;
+    /**
+     * Derives dataPath for FK columns from lookup property schema.
+     * Uses expose.target where source matches textField (default 'title').
+     */
+    private deriveDataPathForFkColumn;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPRelatedColumnEnrichmentService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPRelatedColumnEnrichmentService>;
+}
+
+interface AXPRelatedColumnMetadata {
+    title?: string;
+    showAs?: AXPEntityTableColumn['showAs'];
+}
+declare class AXPRelatedColumnMetadataResolver {
+    private readonly entityLoader;
+    /**
+     * Resolves title and showAs for a column that references a related entity property via dotted path.
+     * Uses relatedEntities when available; falls back to lookup expose when not.
+     */
+    resolve(entity: AXPEntity, columnName: string): Promise<AXPRelatedColumnMetadata | null>;
+    /**
+     * Finds a lookup property whose expose target matches the dotted path.
+     * Returns the lookup's entity string (e.g. 'PersonCore.Person') or null.
+     */
+    private findLookupEntityByExposeTarget;
+    /**
+     * Derives showAs from source property schema.
+     * Passes through the full interface (type, options, children) for column display.
+     */
+    private deriveShowAs;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPRelatedColumnMetadataResolver, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPRelatedColumnMetadataResolver>;
+}
+
+interface IEntitySelectorStage {
+    /** Select target entity using "module.entity" format */
+    entity(fullName: string): IInterfaceSelectorStage;
+}
+interface IInterfaceSelectorStage {
+    /** Use master.create interface */
+    create(initialData?: any): IPropertyFilterStage;
+    /** Use master.update interface. Accepts id (string) or full record data (object). */
+    update(data: string | Record<string, any>): IPropertyFilterStage;
+    /** Use master.single interface (read-only view). Accepts id (string) or full record data (object). */
+    single(data: string | Record<string, any>): IPropertyFilterStage;
+}
+interface IPropertyFilterStage {
+    /** Only include provided property names (by AXPEntityProperty.name). Mutually exclusive with exclude(). */
+    include(...propertyNames: string[]): IPropertyFilterStage;
+    /** Exclude provided property names (by AXPEntityProperty.name). Ignored if include() was already set. */
+    exclude(...propertyNames: string[]): IPropertyFilterStage;
+    /** Mark provided property names as readonly. Overrides property schema for display. */
+    readonlyProperties(...propertyNames: string[]): IPropertyFilterStage;
+    /** Optionally override dialog title */
+    title(text: string): IPropertyFilterStage;
+    /** Provide initial dialog context/model data */
+    context(context: any): IPropertyFilterStage;
+    /** Override dialog size (e.g., 'sm' | 'md' | 'lg' | 'xl' | 'full') */
+    size(size: AXPopupSizeType): IPropertyFilterStage;
+    /** Configure footer actions (cancel/submit/custom). If not called, defaults to cancel+submit. */
+    actions(delegate: (a: IActionBuilder) => void): IPropertyFilterStage;
+    /**
+     * Handler invoked when user clicks an action. Receives AXPDialogRef.
+     * If handler throws, dialog stays open for retry.
+     * If handler returns, dialog closes and show() resolves with the return value.
+     */
+    onAction<T = any>(handler: (dialogRef: AXPDialogRef) => T | Promise<T>): IPropertyFilterStage & {
+        show(): Promise<T>;
+    };
+    /** Add an extra field into a specific group, using the original field builder API */
+    field(groupId: string, path: string, delegate?: (field: CompatFormFieldBuilder) => void): IPropertyFilterStage;
+    /** Build and return the widget node without showing dialog */
+    build(): Promise<AXPWidgetNode>;
+    /** Show dialog */
+    show(): Promise<AXPDialogRef>;
+    mode(mode: 'edit' | 'view'): IPropertyFilterStage;
+}
+declare class AXPEntityFormBuilderService implements IEntitySelectorStage {
+    private readonly entityRegistry;
+    private readonly layoutBuilder;
+    private readonly deviceService;
+    private readonly expressionEvaluator;
+    entity(fullName: string): IInterfaceSelectorStage;
+    /**
+     * Fetches a record by ID for the specified entity.
+     * @param fullName - Entity full name in "module.entity" format
+     * @param id - Record ID to fetch
+     * @returns Promise resolving to the record data, or empty object if not found
+     */
+    getRecordById(fullName: string, id: string): Promise<Record<string, any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityFormBuilderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityFormBuilderService>;
+}
+type CompatFormFieldBuilder = {
+    path(path: string): any;
+    layout(config: any): any;
+    visible(condition: boolean | string): any;
+    readonly(condition: boolean | string): any;
+    customWidget(type: string, options?: any): any;
+} & Partial<IFormFieldBuilder>;
+
+declare const AXP_ENTITY_STORAGE_BACKEND: InjectionToken<AXPEntityStorageService<any, any, any, any, any>>;
+declare const AXP_ENTITY_STORAGE_MIDDLEWARE: InjectionToken<AXPEntityStorageMiddleware<any, any, any, any, any>[]>;
+
+declare class AXPMiddlewareEntityStorageService<TKey = any, TDetailDto extends AXPEntityDetailDto<TKey> = any, TListItemDto extends AXPEntityListItemDto<TKey> = any, TCreateDto extends AXPEntityCreateDto = any, TUpdateDto extends AXPEntityUpdateDto<TKey> = any> extends AXPEntityStorageService<TKey, TDetailDto, TListItemDto, TCreateDto, TUpdateDto> {
+    private readonly backend;
+    private readonly allMiddlewares;
+    private readonly injector;
+    /** In-flight read requests - identical parallel requests share one execution */
+    private readonly inFlight;
+    get dbName(): string;
+    private filterMiddlewares;
+    private compose;
+    private run;
+    private createCtx;
+    initial(entityName: string, collection: TCreateDto[], options?: {
+        mergeType?: 'merge' | 'replace';
+        uniqueKeys?: string[];
+    }): Promise<TCreateDto[]>;
+    getOne(entityName: string, id: TKey): Promise<TDetailDto>;
+    updateOne(entityName: string, id: TKey, keyValues: Omit<Partial<TUpdateDto>, 'id'>): Promise<TDetailDto>;
+    deleteOne(entityName: string, id: TKey): Promise<void>;
+    insertOne(entityName: string, entity: TCreateDto): Promise<TKey>;
+    getAll(entityName: string): Promise<TListItemDto[]>;
+    query(entityName: string, request: AXPQueryRequest): Promise<AXPPagedListResult<TListItemDto>>;
+    count(entityName: string, request: Pick<AXPQueryRequest, 'filter' | 'sort'>): Promise<number>;
+    queryAll(entityName: string, request: Pick<AXPQueryRequest, 'filter' | 'sort'>, options?: AXPEntityQueryAllOptions): Promise<AXPEntityQueryAllResult<TListItemDto>>;
+    getMany(entityName: string, ids: TKey[]): Promise<(TListItemDto | null)[]>;
+    exists(entityName: string, id: TKey): Promise<boolean>;
+    upsertOne(entityName: string, entity: TCreateDto, options?: {
+        merge?: boolean;
+    }): Promise<TKey>;
+    aggregate(entityName: string, request: AXPEntityAggregateRequest, options?: AXPEntityAggregateOptions): Promise<AXPEntityAggregateResult>;
+    private runWithDedup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMiddlewareEntityStorageService<any, any, any, any, any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPMiddlewareEntityStorageService<any, any, any, any, any>>;
+}
+
+declare function entityMasterCreateAction(): AXPEntityAction;
+declare function entityMasterEditAction(): AXPEntityAction;
+declare function entityMasterBulkDeleteAction(): AXPEntityAction;
+declare function entityMasterViewAction(): AXPEntityAction;
+declare function entityMasterDeleteAction(): AXPEntityAction;
+declare function entityMasterCrudActions(options?: {
+    create?: boolean;
+    delete?: boolean;
+    view?: boolean;
+    edit?: boolean;
+}): AXPEntityAction[];
+declare function entityMasterRecordActions(): AXPEntityAction[];
+declare function entityDetailsCreateActions(parentId: string): AXPEntityAction;
+/**
+ * Type-level Create with empty `process.data`; the FK is supplied from `relatedEntity.persistence.foreignKeyField`
+ * when the related list is built (see `mergeForeignKeyFieldIntoCreateActions`).
+ */
+declare function entityDetailsCreateActionsDeferredParent(): AXPEntityAction;
+/**
+ * Ensures each type-level `Entity:Create` action includes `process.data[foreignKeyField]` bound to the parent row id.
+ */
+declare function mergeForeignKeyFieldIntoCreateActions(foreignKeyField: string | undefined, actions: AXPEntityAction[] | undefined): AXPEntityAction[];
+/** Property names hidden on nested Create from a related list (`excludeProperties` plus `foreignKeyField` when set). */
+declare function collectNestedCreateHiddenProperties(relatedEntity: AXPRelatedEntity): string[] | undefined;
+declare function entityDetailsSimpleCondition(fk: string): AXPQueryFilter;
+declare function entityDetailsReferenceCondition(type: string): AXPQueryFilter[];
+declare function entityDetailsEditAction(): AXPEntityAction;
+declare function entityDetailsNewEditAction(): AXPEntityAction;
+declare function entityOverrideDetailsViewAction(): AXPEntityAction;
+declare function entityDetailsCrudActions(parentId?: string, options?: {
+    create?: boolean;
+    delete?: boolean;
+    view?: boolean;
+    edit?: boolean;
+}): AXPEntityAction[];
+declare function entityDetailsReferenceCreateActions(type: string): AXPEntityAction[];
+type AXPEntityChangeSet = {
+    [key: string]: {
+        oldValue: any;
+        newValue: any;
+        added?: any[];
+        removed?: any[];
+    };
+};
+/**
+ * Computes a diff between two plain objects with array-aware semantics.
+ * - For arrays of objects with an id field, computes added/removed by id.
+ * - For arrays of primitives or objects without id, uses deep equality.
+ * - For scalars/objects, reports oldValue/newValue when changed.
+ */
+declare function detectEntityChanges(oldObj: any, newObj: any): AXPEntityChangeSet;
+
+declare class AXPEntityCategoryTreeSelectorComponent extends AXBasePageComponent implements OnInit {
+    protected readonly categoryTreeService: AXPCategoryTreeService;
+    /** i18n key for the synthetic "all items" root row; resolved in the template with the translate pipe. */
+    protected readonly categoryTreeRootTitleI18nKey = "@general:terms.interface.selection.all-items";
+    private readonly translationService;
+    protected readonly highlightService: AXHighlightService;
+    private readonly changeDetectorRef;
+    entityKey: _angular_core.WritableSignal<string>;
+    textField: _angular_core.WritableSignal<string>;
+    valueField: _angular_core.WritableSignal<string>;
+    allowMultiple: _angular_core.WritableSignal<boolean>;
+    selectedValues: _angular_core.WritableSignal<string[]>;
+    /** Optional input for when popup passes selected values via inputs instead of data */
+    selectedValuesInput: _angular_core.WritableSignal<string[]>;
+    searchPlaceholder: _angular_core.WritableSignal<string>;
+    excludedNodeId: _angular_core.WritableSignal<string | undefined>;
+    searchWithChildren: _angular_core.WritableSignal<boolean>;
+    protected tree: _angular_core.Signal<AXTreeViewComponent | undefined>;
+    protected loading: _angular_core.WritableSignal<boolean>;
+    protected selectedNodeIds: _angular_core.WritableSignal<string[]>;
+    protected searchValue: _angular_core.WritableSignal<string>;
+    protected searchResultCount: _angular_core.WritableSignal<number>;
+    protected isSearching: _angular_core.WritableSignal<boolean>;
+    protected resultsFoundText: _angular_core.WritableSignal<string>;
+    protected noRecordsTitle: _angular_core.WritableSignal<string>;
+    private currentSearchTerm;
+    private isRefreshing;
+    private isUpdatingSelection;
+    /**
+     * Computed property to check if we should show the "no search results" empty state.
+     * Returns true when search is active, not searching, and no results found.
+     */
+    protected readonly showNoSearchResults: _angular_core.Signal<boolean>;
+    protected treeData: CategoryTreeNodeData | null;
+    private treeConfig;
+    private nodeDataCache;
+    private matchingNodeIds;
+    private relevantNodeIds;
+    private expandedNodesBeforeSearch;
+    private nodesExpandedDuringSearch;
+    private initialExpandSyncDone;
+    constructor();
+    ngOnInit(): void;
+    private initializeTree;
+    /**
+     * Called when popup data arrives after ngOnInit: load data, set selection, expand and sync.
+     */
+    private runInitialExpandAndSync;
+    /**
+     * Runs expand path + sync selection once the tree viewChild is available.
+     * Uses retry loop so we don't run before the view has rendered the tree.
+     */
+    private runExpandAndSyncWhenTreeReady;
+    /**
+     * Handles search input value changes - Uses server-side search for efficiency and reliability
+     */
+    handleSearchChange(event: AXValueChangedEvent<string>): Promise<void>;
+    /**
+     * Collects all parent IDs for the given search results
+     * Handles both nested 'parent' object and 'parentId' field in search results
+     * Recursively fetches parent nodes to build the full parent chain
+     */
+    private collectParentIds;
+    /**
+     * Collects children IDs for matching search results recursively
+     * Adds all descendants (children, grandchildren, etc.) to relevantNodeIds so they appear in the filtered tree
+     */
+    private collectChildrenIds;
+    /**
+     * Recursively collects all descendant IDs for a given node
+     */
+    private collectChildrenRecursively;
+    /**
+     * Fetches a single item by ID. Uses category tree service so byKey is used when available
+     * (returns full item with parent/parentId for building ancestor chains).
+     */
+    private fetchItemById;
+    /**
+     * Sorts parent IDs by their depth (root first, leaves last)
+     * Optimized to use cached data and batch fetch missing items
+     */
+    private sortParentsByDepth;
+    /**
+     * Updates translated messages for search results
+     */
+    private updateTranslatedMessages;
+    /**
+     * Resets search state and restores tree to original expanded state
+     */
+    private resetSearch;
+    /**
+     * Restores selection state after tree reload.
+     * Expands ancestor nodes and selects the previously selected leaf nodes.
+     */
+    private restoreSelectionAfterReload;
+    protected onNodeSelect(event: AXTreeViewNodeSelectEvent): Promise<void>;
+    /** Datasource callback for tree-view component. */
+    protected datasource: (id?: string) => Promise<AXTreeViewNode[]>;
+    protected onConfirm(): Promise<void>;
+    protected onCancel(): Promise<void>;
+    /**
+     * Clears all selected items
+     */
+    protected onClearAll(): void;
+    /**
+     * Checks if a node matches the current search term
+     */
+    protected isMatchingNode(nodeId: string): boolean;
+    /**
+     * Checks if a node is currently selected
+     */
+    protected isNodeSelected(nodeId: string | number | undefined): boolean;
+    /**
+     * Expands parent nodes, collects all LEAF descendants, and selects them visually.
+     * If the parent itself is a leaf (no children), it will be added.
+     * When prefetchedChildren is provided, avoids an extra datasource(parentId) call.
+     */
+    private selectAllLeafDescendants;
+    /**
+     * Removes all LEAF descendants from selectedNodeIds.
+     * For 'all' node: clears everything and uses tree's deselectAll().
+     * For other nodes: tree handles visual state via user click.
+     */
+    private deselectAllLeafDescendants;
+    /**
+     * Recursively expands parent nodes and collects LEAF node IDs.
+     * When treeComponent is provided, expands each parent node before loading children.
+     * When prefetchedChildren is provided, uses it instead of calling datasource(parentId) (one less API call).
+     * Fetches each node's children at most once by passing grandchildren when recursing.
+     */
+    private collectLeafNodes;
+    /**
+     * Checks if a node has children
+     */
+    private nodeHasChildren;
+    /**
+     * Checks if a node is a leaf (has no children)
+     */
+    private isLeafNodeCheck;
+    /**
+     * Caches node data from a tree node
+     */
+    private cacheNodeFromTreeNode;
+    /**
+     * Builds complete ancestor chains for all selected node IDs.
+     * Returns a Map where key is the selected node ID and value is array of ancestor IDs from root to parent.
+     * Batch-fetches missing node and ancestor data in parallel to minimize API calls.
+     */
+    private buildAncestorChains;
+    /**
+     * Expands ancestor nodes in order from root to leaf.
+     * This ensures parent nodes are loaded into the tree before selecting children.
+     */
+    private expandAncestorNodesInOrder;
+    /** Waits until the node is expanded (tree has loaded children). Polls so deep paths load. */
+    private waitForNodeExpanded;
+    /**
+     * Syncs selection state with the tree component.
+     * Selects leaf nodes and manually updates parent states (indeterminate/selected).
+     */
+    private syncSelectionWithTree;
+    /**
+     * Updates parent node states (selected/indeterminate) based on children selection.
+     * Called after leaf nodes are selected to properly show parent states.
+     * Works bottom-up from deepest parents to root, tracking states in a Map.
+     */
+    private updateParentStatesAfterSelection;
+    /**
+     * Loads node data for IDs that are selected but not yet in the cache.
+     * This is critical for pre-selected values in collapsed branches.
+     * Fetches all missing IDs in parallel to minimize API calls and latency.
+     */
+    private loadMissingNodeData;
+    /**
+     * For each selected id, if cached item has no parent (e.g. batch query returned minimal fields),
+     * re-fetch by id so we have parent/parentId for building ancestor chains.
+     * Fetches all needing refresh in parallel.
+     */
+    private ensureParentDataInCache;
+    /**
+     * Resolves parent ID from node data: supports nested `parent` object or flat parentId/parentKey.
+     */
+    private getParentIdFromNodeData;
+    /**
+     * Marks nodes as selected in the tree structure based on selectedNodeIds.
+     * This ensures pre-selected nodes appear selected when the tree is rendered.
+     */
+    private markNodesAsSelected;
+    /**
+     * Marks a single node as selected if it's in the selectedNodeIds list.
+     */
+    private markNodeAsSelectedIfNeeded;
+    /**
+     * Marks a node and its children as disabled if the node ID matches the excluded ID.
+     */
+    private markNodeAsDisabled;
+    /**
+     * Processes root node: marks excluded as disabled, marks selected, and syncs selection with tree component
+     */
+    private processRootNode;
+    /**
+     * Processes child nodes: marks excluded as disabled
+     * Selection marking is handled in datasource callback ONLY during initial load
+     */
+    private processChildNodes;
+    /**
+     * Caches node data from items array
+     */
+    private cacheNodeData;
+    /**
+     * Caches node data from tree nodes
+     */
+    private cacheNodeDataFromNodes;
+    /**
+     * Calculate the full path from root to the selected node.
+     * Returns an array of strings like ["Operations", "IT Operations"] for node "IT Operations" under parent "Operations".
+     * Uses tree-view's getNodePath() API when available, otherwise falls back to manual calculation.
+     */
+    private calculateNodePath;
+    /**
+     * Manual path calculation fallback
+     */
+    private calculateNodePathManually;
+    /**
+     * Get the display title for a node.
+     */
+    private getNodeTitle;
+    private getSelectedItems;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityCategoryTreeSelectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPEntityCategoryTreeSelectorComponent, "axp-entity-category-tree-selector", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPEntityCategoryWidgetColumnComponent extends AXPColumnWidgetComponent<any> {
+    protected readonly entityDetailPopoverService: AXPEntityDetailPopoverService;
+    protected readonly formatService: AXFormatService;
+    protected readonly entityResolver: AXPEntityDefinitionRegistryService;
+    private readonly categoryBatchResolver;
+    private readonly rawValueSignal;
+    set rawValueInput(value: any);
+    protected entity: _angular_core.Signal<string>;
+    protected valueField: _angular_core.Signal<string>;
+    protected textField: _angular_core.Signal<string>;
+    protected columnName: _angular_core.Signal<string>;
+    protected defaultTextField: _angular_core.Signal<string>;
+    protected displayField: _angular_core.Signal<string>;
+    protected host: ElementRef<any>;
+    private entityDef;
+    protected displayItems: _angular_core.WritableSignal<any[]>;
+    protected selectedItemIndex: _angular_core.WritableSignal<number>;
+    private efEntity;
+    private efDisplay;
+    protected visibleItems: _angular_core.Signal<any[]>;
+    protected columnItems: _angular_core.Signal<AXPColumnItemListItem[]>;
+    protected showItemDetail(item: any, index: number): Promise<void>;
+    protected handleItemClick(listItem: AXPColumnItemListItem): void;
+    protected getItemPath(item: any): string[];
+    protected hasParent(item: any): boolean;
+    protected getItemText(item: any): string;
+    protected joinPath(path: string[]): string;
+    protected getItemId(item: any): string;
+    protected getBreadcrumbPath(item: any): string;
+    private resolveItemsWithPaths;
+    /**
+     * Build path from categories array when record has full chain (id, parentId, title).
+     * Used when middleware enriches categories on create/update.
+     */
+    private buildItemWithPathFromChain;
+    private extractItemWithPath;
+    /**
+     * Calculate the full path from root to the item.
+     * Returns an array of strings like ["C", "B"] for item B under parent C.
+     */
+    private calculateItemPath;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityCategoryWidgetColumnComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPEntityCategoryWidgetColumnComponent, "axp-entity-category-widget-column", never, { "rawValue": { "alias": "rawValue"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; "rawValueInput": { "alias": "rawValue"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface AXPEntityCategoryWidgetOptions {
+    disabled?: boolean | AXPExpression;
+    readonly?: boolean | AXPExpression;
+    placeholder?: string;
+    entity?: string;
+    multiple?: boolean;
+    textField?: string;
+    valueField?: string;
+    parentKey?: string;
+    expose?: Array<{
+        source: string;
+        target: string;
+    }>;
+    allowClear?: boolean;
+    look?: 'select' | 'lookup';
+    maxVisible?: number;
+    characterLimit?: number | 'auto';
+    sectionLimit?: number | 'auto';
+}
+
+declare class AXPEntityCategoryWidgetEditComponent extends AXPValueWidgetComponent<any, AXPEntityCategoryWidgetOptions> {
+    #private;
+    protected readonly entityResolver: AXPEntityDefinitionRegistryService;
+    protected readonly popupService: AXPopupService;
+    private readonly translateService;
+    protected readonly cdr: ChangeDetectorRef;
+    protected entity: _angular_core.Signal<string>;
+    protected multiple: _angular_core.Signal<boolean>;
+    protected disabled: _angular_core.Signal<boolean>;
+    protected textField: _angular_core.Signal<string>;
+    protected valueField: _angular_core.Signal<string>;
+    protected expose: _angular_core.Signal<{
+        source: string;
+        target: string;
+    }[] | undefined>;
+    protected allowClear: _angular_core.Signal<boolean>;
+    protected characterLimit: _angular_core.Signal<number | "auto">;
+    protected sectionLimit: _angular_core.Signal<number | "auto">;
+    protected defaultTextField: _angular_core.Signal<string>;
+    protected displayField: _angular_core.Signal<string>;
+    protected searchPlaceholderText: _angular_core.WritableSignal<string>;
+    protected selectedItems: _angular_core.WritableSignal<any[]>;
+    protected isLoading: _angular_core.WritableSignal<boolean>;
+    protected isOpen: _angular_core.WritableSignal<boolean>;
+    protected tagBox: _angular_core.Signal<AXTagBoxComponent | undefined>;
+    protected searchTerm: _angular_core.WritableSignal<string | null>;
+    private entityDef;
+    /**
+     * Flag to prevent the value effect from running during internal updates.
+     * This prevents circular dependency when setItems() calls setValue().
+     */
+    private isInternalUpdate;
+    protected handleAddClick(e: AXClickEvent): void;
+    protected handleValueChange(e: AXValueChangedEvent): void;
+    protected handleOnBlur(e: AXFocusEvent): void;
+    protected handleKeyUp(e: AXHtmlEvent): Promise<void>;
+    protected handleClearClick(): void;
+    protected handleRemoveItem(event: Event, index: number): Promise<void>;
+    clearInput(): void;
+    private showTreeSelector;
+    clear(): void;
+    private findByValue;
+    private setItems;
+    private singleOrMultiple;
+    protected getItemLabel(item: any): string;
+    /**
+     * Get item path as array for breadcrumb component (raw MLS or string per segment).
+     */
+    protected getItemPath(item: any): AXPMultiLanguageString[];
+    /**
+     * Join path array with separator.
+     * Override this method to customize the separator (e.g., " > ", " -> ", " / ")
+     */
+    protected joinPath(path: unknown[]): string;
+    protected getItemId(item: any): string;
+    /**
+     * Calculate the full path from root to the item.
+     * Returns an array of strings like ["C", "B"] for item B under parent C.
+     */
+    private calculateItemPath;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityCategoryWidgetEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPEntityCategoryWidgetEditComponent, "axp-entity-category-widget-edit", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPEntityCategoryWidgetViewComponent extends AXPValueWidgetComponent<any> {
+    protected readonly entityResolver: AXPEntityDefinitionRegistryService;
+    protected entity: _angular_core.Signal<string>;
+    protected multiple: _angular_core.Signal<boolean>;
+    protected valueField: _angular_core.Signal<string>;
+    protected textField: _angular_core.Signal<string>;
+    protected badgeClass: _angular_core.Signal<string>;
+    protected displayField: _angular_core.Signal<string>;
+    protected loading: _angular_core.WritableSignal<boolean>;
+    private entityDef;
+    protected displayItems: _angular_core.WritableSignal<{
+        id: string;
+        titleRaw: AXPMultiLanguageString | null | undefined;
+    }[]>;
+    private efEntity;
+    private efDisplay;
+    private extractItem;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityCategoryWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPEntityCategoryWidgetViewComponent, "axp-entity-category-widget-view", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPEntityCategoryWidget: AXPWidgetConfig;
+
+declare class AXPTruncatedBreadcrumbComponent implements OnDestroy {
+    private readonly mlsResolver;
+    /** Plain string or locale map per segment; truncation uses resolved text (see {@link resolvedSectionTexts}). */
+    sections: _angular_core.InputSignal<readonly (_acorex_core_translation.AXMultiLanguageString | null | undefined)[]>;
+    characterLimit: _angular_core.InputSignal<number | "auto">;
+    sectionLimit: _angular_core.InputSignal<number | "auto">;
+    separatorIcon: _angular_core.InputSignal<string>;
+    ellipsisIcon: _angular_core.InputSignal<string>;
+    eyeIcon: _angular_core.InputSignal<string>;
+    protected container: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    protected isExpanded: _angular_core.WritableSignal<boolean>;
+    private containerWidth;
+    private resizeObserver;
+    /** Resolved display strings for length / ellipsis (same rules as the pipe). */
+    protected resolvedSectionTexts: _angular_core.Signal<string[]>;
+    protected effectiveCharacterLimit: _angular_core.Signal<number>;
+    protected effectiveSectionLimit: _angular_core.Signal<number>;
+    protected hasTruncatedText: _angular_core.Signal<boolean>;
+    protected hasHiddenSections: _angular_core.Signal<boolean>;
+    /**
+     * canToggle: If this is false, NO Eye Icon and NO Click events will exist.
+     */
+    protected canToggle: _angular_core.Signal<boolean>;
+    protected allSectionsTruncated: _angular_core.Signal<{
+        text: string;
+        original: string;
+    }[]>;
+    protected displayedSections: _angular_core.Signal<{
+        text: string;
+        original: string;
+    }[]>;
+    protected lastSection: _angular_core.Signal<{
+        text: string;
+        original: string;
+    }>;
+    protected fullPath: _angular_core.Signal<string>;
+    constructor();
+    ngOnDestroy(): void;
+    protected handleSeparatorClick(event: Event): void;
+    protected handleEllipsisClick(event: Event): void;
+    protected handleCollapseClick(event: Event): void;
+    private initializeResizeObserver;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTruncatedBreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPTruncatedBreadcrumbComponent, "axp-truncated-breadcrumb", never, { "sections": { "alias": "sections"; "required": false; "isSignal": true; }; "characterLimit": { "alias": "characterLimit"; "required": false; "isSignal": true; }; "sectionLimit": { "alias": "sectionLimit"; "required": false; "isSignal": true; }; "separatorIcon": { "alias": "separatorIcon"; "required": false; "isSignal": true; }; "ellipsisIcon": { "alias": "ellipsisIcon"; "required": false; "isSignal": true; }; "eyeIcon": { "alias": "eyeIcon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const AXPEntityDefinitionProviderWidget: AXPWidgetConfig;
+declare module '@acorex/platform/layout/widget-core' {
+    interface AXPWidgetTypesMap {
+        entityDefinitionProvider: 'entity-definition-provider-editor';
+    }
+}
+
+declare class AXPEntityDefinitionProviderWidgetEditComponent extends AXPProviderSelectWidgetEditBase {
+    private readonly entityRegistry;
+    /**
+     * Last applied module filter (from context) to avoid redundant reloads.
+     */
+    private readonly lastModuleFilterKey;
+    /**
+     * Reloads entity options when `filterModuleField` changes in form context (not only via `widget.refresh()`).
+     */
+    private readonly reloadWhenModuleContextChanges;
+    /**
+     * Options:
+     * - `filterModuleField`: sibling context field name (e.g. `entityListModule`); when set, only entities in that module are listed.
+     * - `valueFormat`: `fullKey` (`module.name`, default) or `entityName` (short name only, for menus that store `entityListRef.entity`).
+     */
+    protected loadDataSourceRows(): Promise<Array<{
+        value: string;
+        title: string;
+    }>>;
+    refresh(): void;
+    /**
+     * Reads sibling field from context store data (same shape as `lodash/get` paths).
+     */
+    private readModuleFromContext;
+    /**
+     * Resolves a sibling field path relative to the current widget's parent path.
+     */
+    private resolveSiblingContextPath;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityDefinitionProviderWidgetEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPEntityDefinitionProviderWidgetEditComponent, "axp-entity-definition-provider-widget-edit", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPEntityListTableService {
+    private readonly workflow;
+    private readonly commandService;
+    private readonly expressionEvaluator;
+    private readonly settings;
+    /**
+     * Convert Entity to List Widget Options
+     */
+    convertEntityToListOptions(entity: AXPEntity, options: any, allActions: AXPEntityCommandTriggerViewModel[]): Promise<AXPDataListWidgetComponentOptions>;
+    /**
+     * Create DataSource for Entity
+     */
+    private createDataSource;
+    /**
+     * Convert Properties to Columns
+     */
+    private createColumnsFromProperties;
+    /**
+     * Map EntityTableColumn to ListWidgetColumn
+     */
+    private mapEntityColumnToWidgetColumn;
+    /**
+     * Convert Entity Actions to Row Commands
+     */
+    private createRowCommands;
+    /**
+     * Wraps string values with AXP_ROW_EXPR_PREFIX so widget-renderer does not
+     * evaluate them (it only treats {{ ... }} as expressions). Data-list will
+     * unwrap and evaluate per row with row data. Only used for secondary commands.
+     */
+    private wrapRowExpr;
+    /**
+     * Check if entity has Selected Scope Actions
+     */
+    private hasSelectedScopeActions;
+    private evaluateExpressions;
+    /**
+     * Handle execution of a row command (shared by double-click and command handlers)
+     */
+    private handleRowCommand;
+    /**
+     * When a related entity list declares `excludeProperties`, row commands bypass the details page
+     * `execute()` merge — apply the same exclusions for embedded create/update commands.
+     */
+    private mergeRelatedListFormOptions;
+    /**
+     * Create default events
+     */
+    private createDefaultEvents;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityListTableService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityListTableService>;
+}
+
+interface AXPEntityListToolbarConvertOptions {
+    excludeColumns?: string[];
+    includeColumns?: string[];
+    /** Related list: evaluated `AXPEntityTableColumn[]` from `AXPRelatedEntity.columns` */
+    relatedTableColumns?: AXPEntityTableColumn[];
+    customFilterDefinitions?: Partial<AXPFilterDefinition>[];
+}
+declare class AXPEntityListToolbarService {
+    private readonly widgetResolver;
+    /**
+     * Convert Entity to Toolbar Options
+     */
+    convertEntityToolbarOptions(entity: AXPEntity, options: AXPEntityListToolbarConvertOptions | undefined): Promise<{
+        filterDefinitions: AXPFilterDefinition[];
+        columnDefinitions: AXPColumnQuery[];
+        sortDefinitions: AXPSortDefinition[];
+    }>;
+    /**
+     * Merges custom filter definitions into the entity-derived list by `field`.
+     * Matching fields: custom properties are applied on top of the base definition.
+     * Non-matching custom entries are appended.
+     */
+    private mergeFilterDefinitions;
+    private filterFieldKey;
+    private mergeFilterDefinition;
+    /**
+     * Create Filter Definitions for Toolbar
+     */
+    private createFilterDefinitions;
+    /**
+     * Create Column Definitions for Toolbar.
+     * Includes both entity.properties and enriched columns (e.g. person.firstName with showAs).
+     */
+    private createColumnDefinitions;
+    /**
+     * Create Sort Definitions for Toolbar.
+     * Includes entity.properties with sort enabled, plus enriched columns (dotted paths).
+     */
+    private createSortDefinitions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityListToolbarService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityListToolbarService>;
+}
+
+declare class AXPEntityListWidgetViewComponent extends AXPValueWidgetComponent {
+    #private;
+    protected entityService: AXPEntityDefinitionRegistryService;
+    protected workflow: AXPWorkflowService;
+    protected entityListTableService: AXPEntityListTableService;
+    protected entityListToolbarService: AXPEntityListToolbarService;
+    protected deviceService: AXPDeviceService;
+    protected commandService: AXPCommandService;
+    protected eventService: AXPBroadcastEventService;
+    private readonly expressionEvaluator;
+    private readonly route;
+    protected isMounted: _angular_core.WritableSignal<boolean>;
+    readonly entity: _angular_core.WritableSignal<AXPEntity | null>;
+    protected listNode: _angular_core.WritableSignal<AXPWidgetNode | null>;
+    protected list: _angular_core.Signal<AXPWidgetRendererDirective | undefined>;
+    protected allWidgets: _angular_core.Signal<readonly AXPWidgetRendererDirective[]>;
+    protected listWidget: _angular_core.WritableSignal<AXPWidgetRendererDirective | undefined>;
+    protected toolbarWidget: _angular_core.Signal<AXPWidgetRendererDirective | undefined>;
+    protected selectedItems: _angular_core.WritableSignal<any[]>;
+    protected toolbarNode: _angular_core.WritableSignal<AXPWidgetNode | null>;
+    protected destroyed: Subject<void>;
+    protected entitySource: _angular_core.Signal<any>;
+    protected excludeColumns: _angular_core.Signal<string[]>;
+    protected includeColumns: _angular_core.Signal<string[]>;
+    protected relatedTableColumns: _angular_core.Signal<AXPEntityTableColumn[] | undefined>;
+    protected customFilterDefinitions: _angular_core.Signal<Partial<AXPFilterDefinition>[] | undefined>;
+    protected externalActions: _angular_core.Signal<AXPEntityAction[]>;
+    protected maxHeight: _angular_core.Signal<string>;
+    protected showEntityActions: _angular_core.Signal<any>;
+    protected showToolbar: _angular_core.Signal<any>;
+    protected allActions: _angular_core.Signal<AXPEntityCommandTriggerViewModel[]>;
+    protected primaryActions: _angular_core.Signal<AXPActionMenuItem[]>;
+    protected handleUnselectAll(): void;
+    protected secondaryActions: _angular_core.Signal<AXPActionMenuItem[]>;
+    protected handleActionClick(item: AXPActionMenuItem): void;
+    protected handleSecondaryActionClick(item: AXPActionMenuItem): void;
+    protected execute(commandName: string, _data: unknown): Promise<void>;
+    /**
+     * Resolves toolbar commands including nested dropdown (`items`) actions.
+     */
+    private findToolbarAction;
+    private evaluateToolbarExpressions;
+    /**
+     * Parses the `filters` query param (same shape as standalone entity list routes).
+     */
+    private parseFiltersFromRoute;
+    /**
+     * Route `filters` apply only when the active details `page` matches this list's entity
+     * (e.g. WorkOrder filters must not affect FailureRegister on the same asset layout).
+     */
+    private shouldApplyRouteFilters;
+    /**
+     * Merges route filters into related-entity toolbar filters (route wins per field).
+     */
+    private mergeToolbarFilters;
+    private getMergedToolbarFilters;
+    /**
+     * Applies merged route + parent-scope filters to the widget value and data source.
+     */
+    private applyMergedRouteFiltersToList;
+    /**
+     * Re-evaluates related-entity list filters from the live dialog form context (e.g. after create saves the main row id).
+     */
+    private applyRelatedFiltersFromContext;
+    /**
+     * Pushes current toolbar filters to the embedded list data source when both exist.
+     * Returns false while data-list is still mounting (see deferred listNode.set in ngOnInit).
+     */
+    private pushToolbarFiltersToDataSource;
+    /**
+     * Writes toolbar filters from specs and pushes them onto the data source so refresh/reload keeps the parent scope.
+     */
+    private applyRelatedFiltersFromContextAndDatasource;
+    /**
+     * Refreshes the embedded data list (toolbar / workflow). In wizard mode, `refresh` is patched to re-apply scoped filters first.
+     */
+    private refreshGridWithParentScopedFilters;
+    protected queries: undefined;
+    /**
+     * Validates that all required dependencies are available
+     */
+    private hasRequiredDependencies;
+    /**
+     * Handles all query-related changes (filters, sorts, columns)
+     */
+    private handleQueryChanges;
+    /**
+     * Analyzes what has changed between current and previous queries
+     */
+    private analyzeChanges;
+    /**
+     * Applies filter and sort changes to the data source
+     */
+    private applyDataSourceChanges;
+    /**
+     * Handles list refresh logic based on changes and mount status
+     */
+    private handleListRefresh;
+    /**
+     * Handles column-related changes
+     * TODO: Implement column change logic
+     */
+    private handleColumnChanges;
+    protected context: {};
+    protected previousQueries: any;
+    ngOnInit(): Promise<void>;
+    ngAfterViewInit(): Promise<void>;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityListWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPEntityListWidgetViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPEntityListWidget: AXPWidgetConfig;
+
+declare class AXPEditFileUploaderCommand implements AXPCommand<{
+    file: AXPFileListItem;
+    plugins?: {
+        name: string;
+        options?: unknown;
+    }[];
+    excludePlugins?: string[];
+    enableTitleDescription?: boolean;
+    isNewFile?: boolean;
+}, AXPFileListItem> {
+    private readonly layoutBuilder;
+    private readonly translationService;
+    private readonly hooks;
+    execute(input: {
+        file: AXPFileListItem;
+        plugins?: {
+            name: string;
+            options?: unknown;
+        }[];
+        excludePlugins?: string[];
+        enableTitleDescription?: boolean;
+        isNewFile?: boolean;
+    }): Promise<AXPExecuteCommandResult<AXPFileListItem>>;
+    private showEditDialog;
+    /**
+     * Build form fields from hook items (old format parameters)
+     */
+    private buildFormFields;
+    /**
+     * Build groups/containers from hook groups (old format groups)
+     */
+    private buildGroups;
+    /**
+     * Apply widget configuration to field based on widget type
+     */
+    private applyWidget;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEditFileUploaderCommand, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEditFileUploaderCommand>;
+}
+
+declare class AXPFileListComponent implements OnInit, OnDestroy {
+    private fileTypeService;
+    private fileStorageService;
+    private commandExecutor;
+    private hooks;
+    isLoading: _angular_core.WritableSignal<boolean>;
+    private fileTypes;
+    onRemove: _angular_core.OutputEmitterRef<AXPFileListItem>;
+    onRevert: _angular_core.OutputEmitterRef<AXPFileListItem>;
+    onRename: _angular_core.OutputEmitterRef<AXPFileListItem>;
+    readonly: _angular_core.InputSignal<boolean>;
+    fileEditable: _angular_core.InputSignal<boolean>;
+    /** When true, edit dialog shows name, title and description fields. Default false. */
+    enableTitleDescription: _angular_core.InputSignal<boolean>;
+    multiple: _angular_core.InputSignal<boolean>;
+    files: _angular_core.InputSignal<AXPFileListItem[]>;
+    plugins: _angular_core.InputSignal<{
+        name: string;
+        options?: unknown;
+    }[] | undefined>;
+    excludePlugins: _angular_core.InputSignal<string[] | undefined>;
+    capabilities: _angular_core.InputSignal<AXCFileUploaderCapabilities | undefined>;
+    /**
+     * All files should be displayed, even those with `deleted` status.
+     * The template will handle the visual differences based on the status.
+     */
+    displayFiles: _angular_core.Signal<AXPFileListItem[]>;
+    private fileIdToActions;
+    private globalActions;
+    private filesChangeEffect;
+    private getDefaultActions;
+    /** True when the widget is readonly or this file row is locked (`readOnly`). */
+    isItemInteractionLocked(file: AXPFileListItem): boolean;
+    actionsFor(file: AXPFileListItem, index: number): any[];
+    private loadActionsFor;
+    ngOnInit(): Promise<void>;
+    private loadGlobalActions;
+    protected getFileInfo(fileName: string): {
+        icon: string;
+        type: string;
+    };
+    handleFileDownload(event: AXClickEvent, file: AXPFileListItem): Promise<void>;
+    handleFileRemove(event: AXClickEvent, file: AXPFileListItem): Promise<void>;
+    /**
+     * Handle revert action – emit the file so parent components can update the status.
+     */
+    handleFileRevert(event: AXClickEvent, file: AXPFileListItem): void;
+    /**
+     * Handle file edit action – open rename popup
+     */
+    handleFileEdit(event: any, file: AXPFileListItem): Promise<void>;
+    ngOnDestroy(): void;
+    runAction(action: any): Promise<void>;
+    protected getActionColor(action: any): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPFileListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPFileListComponent, "axp-file-list", never, { "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "fileEditable": { "alias": "fileEditable"; "required": false; "isSignal": true; }; "enableTitleDescription": { "alias": "enableTitleDescription"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "files": { "alias": "files"; "required": false; "isSignal": true; }; "plugins": { "alias": "plugins"; "required": false; "isSignal": true; }; "excludePlugins": { "alias": "excludePlugins"; "required": false; "isSignal": true; }; "capabilities": { "alias": "capabilities"; "required": false; "isSignal": true; }; }, { "onRemove": "onRemove"; "onRevert": "onRevert"; "onRename": "onRename"; }, never, never, true, never>;
+}
+
+/** Stable fingerprint for one file row; ignores Blob binary content. */
+declare function fingerprintAttachmentItem(item: unknown): string;
+/** Order-independent fingerprint for attachment lists. */
+declare function fingerprintAttachments(value: unknown): string;
+/** True when lists represent the same attachments regardless of blob vs fileId shape. */
+declare function attachmentsSemanticallyEqual(a: unknown, b: unknown): boolean;
+/** Attachment rows that remain after a successful save (drops soft-deleted rows). */
+declare function committedAttachments(value: unknown): AXPFileListItem[];
+/**
+ * Post-save attachment list: drops soft-deleted rows and promotes pending `attached` rows to `uploaded`
+ * so deferred-save pages get the same delete/revert behavior as after a full reload.
+ */
+declare function persistedAttachments(value: unknown): AXPFileListItem[];
+
+interface AXPFileUploaderEntityFilesScope {
+    name: string;
+    id: string;
+    field: string;
+}
+declare function isFileListItem(value: unknown): value is AXPFileListItem;
+/** Whether a list-row value represents one attachment (file item, id reference, or fileId source). */
+declare function isAttachmentListEntry(value: unknown): boolean;
+declare function attachmentFieldCount(fieldValue: unknown): number;
+declare function normalizeEntityFieldToFileList(fieldValue: unknown): AXPFileListItem[];
+declare function resolveFileUploaderEntityScope(options: Record<string, unknown>, rowData: Record<string, unknown> | undefined, fieldFallback?: string): AXPFileUploaderEntityFilesScope | undefined;
+
+interface AXPFileUploaderLoadFilesInput extends AXPFileUploaderEntityFilesScope {
+}
+interface AXPFileUploaderLoadFilesResult {
+    files: AXPFileListItem[];
+    /** Count including file-id references, not only hydrated AXPFileListItem rows. */
+    count: number;
+}
+declare class AXPFileUploaderLoadFilesQuery implements AXPQuery<AXPFileUploaderLoadFilesInput, AXPFileUploaderLoadFilesResult> {
+    private readonly injector;
+    fetch(input: AXPFileUploaderLoadFilesInput): Promise<AXPFileUploaderLoadFilesResult>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPFileUploaderLoadFilesQuery, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPFileUploaderLoadFilesQuery>;
+}
+
+interface AXPFileUploaderSaveFilesInput extends AXPFileUploaderEntityFilesScope {
+    files: AXPFileListItem[];
+}
+interface AXPFileUploaderSaveFilesResult {
+    entityData: Record<string, unknown>;
+}
+declare class AXPFileUploaderSaveFilesCommand implements AXPCommand<AXPFileUploaderSaveFilesInput, AXPFileUploaderSaveFilesResult> {
+    private readonly injector;
+    execute(input: AXPFileUploaderSaveFilesInput): Promise<AXPExecuteCommandResult<AXPFileUploaderSaveFilesResult>>;
+}
+
+/** Serializable upload action exposed via widget `api().getUploadActions()`. */
+interface AXPFileUploaderUploadActionDescriptor {
+    plugin: string;
+    text?: string;
+    textKey?: string;
+    icon?: string;
+}
+type AXPFileUploaderEditDialogMode = 'manual' | 'auto';
+interface AXPFileUploaderEditDialogFieldOptions {
+    name?: boolean;
+    title?: boolean;
+    description?: boolean;
+}
+interface AXPFileUploaderEditDialogOptions {
+    mode?: AXPFileUploaderEditDialogMode;
+    fields?: AXPFileUploaderEditDialogFieldOptions;
+}
+declare function resolveFileUploaderEditDialog(options?: Record<string, unknown>): AXPFileUploaderEditDialogOptions | undefined;
+declare function isFileUploaderEditDialogAuto(editDialog?: AXPFileUploaderEditDialogOptions): boolean;
+declare function hasFileUploaderTitleOrDescriptionFields(editDialog?: AXPFileUploaderEditDialogOptions): boolean;
+
+declare class AXPFileUploaderWidgetColumnComponent extends AXPColumnWidgetComponent<AXPFileListItem[]> {
+    protected fileCount: _angular_core.WritableSignal<number>;
+    private loadRequestId;
+    private fileService;
+    private queryExecutor;
+    constructor();
+    openFileList(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPFileUploaderWidgetColumnComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPFileUploaderWidgetColumnComponent, "axp-file-uploader-widget-column", never, { "rawValue": { "alias": "rawValue"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AXPFileUploaderWidgetEditComponent extends AXPValueWidgetComponent<AXPFileListItem[] | undefined> {
+    protected readonly fileService: AXFileService;
+    private readonly hooks;
+    private readonly fileActionsService;
+    private readonly commandExecutor;
+    private readonly dirtyChangeSubject;
+    private readonly uploadActionsChangeSubject;
+    private readonly savedSnapshot;
+    private readonly baselineFingerprint;
+    private readonly baselinePendingReconcile;
+    private readonly isDirtySignal;
+    private skipDirtyEvaluation;
+    /** Status before soft-delete; used for restore when baseline was not synced (section layout). */
+    private readonly statusBeforeDelete;
+    private readonly autoBaselineSynced;
+    /** Sync baseline from context when not wired by a deferred-save page (section layout). */
+    private readonly baselineInitEffect;
+    protected multiple: _angular_core.Signal<boolean>;
+    private readonly acceptOverride;
+    protected accept: _angular_core.Signal<string>;
+    protected plugins: _angular_core.Signal<{
+        name: string;
+        options?: unknown;
+    }[]>;
+    protected pluginNames: _angular_core.Signal<string[]>;
+    protected excludePlugins: _angular_core.Signal<string[]>;
+    protected fileEditable: _angular_core.Signal<boolean>;
+    protected editDialog: _angular_core.Signal<_acorex_platform_layout_entity.AXPFileUploaderEditDialogOptions | undefined>;
+    protected enableTitleDescription: _angular_core.Signal<boolean>;
+    /** When mode is `auto`, show the edit dialog after each file select. */
+    protected showEditDialogAfterSelect: _angular_core.Signal<boolean>;
+    protected readonly: _angular_core.Signal<boolean>;
+    protected showBorder: _angular_core.Signal<boolean>;
+    protected showAddItemButton: _angular_core.Signal<boolean>;
+    protected maxFileSize: _angular_core.Signal<number>;
+    protected isDragOver: _angular_core.WritableSignal<boolean>;
+    private readonly innerActions;
+    protected readonly fileActions: _angular_core.Signal<AXCFileUploaderAction[]>;
+    ngOnInit(): void;
+    setValue(value: AXPFileListItem[] | null | undefined): void;
+    /** Align dirty baseline with persisted attachments (call when record loads or after discard remount). */
+    syncBaseline(saved: AXPFileListItem[] | undefined): void;
+    /** Mark current list as saved; clears dirty and drops soft-deleted rows from the UI. */
+    markSaved(): void;
+    /** Revert widget value to last saved baseline. */
+    discardToBaseline(): void;
+    api(): AXPWidgetCoreElementAPI;
+    /** Current upload actions for host pages (always read via api; list may change after plugins load). */
+    getUploadActionDescriptors(): AXPFileUploaderUploadActionDescriptor[];
+    runUploadActionByPlugin(plugin: string): Promise<void>;
+    private notifyUploadActionsChanged;
+    private evaluateDirty;
+    private setDirty;
+    private loadActions;
+    private configureFromHooks;
+    /**
+     * Process files from various sources (file picker, drag-drop, etc.)
+     * When showEditDialogAfterSelect is true, the edit dialog (with plugin hooks) is shown per file before adding; otherwise files are added and user can edit via Edit button.
+     */
+    private processFiles;
+    /**
+     * Show edit dialog per file and add only those submitted. Used when showEditDialogAfterSelect is true (both from zone and from dropdown actions).
+     */
+    private addFilesWithEditDialogAsync;
+    protected files: _angular_core.Signal<AXPFileListItem[]>;
+    handleFileRemove(file: AXPFileListItem): void;
+    removeFile(file: AXPFileListItem): void;
+    /**
+     * Revert a deleted file back to its pre-delete status.
+     */
+    handleFileRevert(file: AXPFileListItem): void;
+    private resolveRestoredStatus;
+    /**
+     * Handle file rename action. Persists name/title/description to file storage immediately when edited
+     * so they are saved even if the entity payload does not carry these fields.
+     */
+    handleFileRename(file: AXPFileListItem): void;
+    clear(): void;
+    protected readonly capabilities: AXCFileUploaderCapabilities;
+    onFileChange(event: {
+        event: Event;
+        files: File[];
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPFileUploaderWidgetEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPFileUploaderWidgetEditComponent, "axp-file-uploader-widget-edit", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPFileUploaderWidgetViewComponent extends AXPValueWidgetComponent<AXPFileListItem[]> {
+    protected files: _angular_core.Signal<AXPFileListItem[]>;
+    private get __class();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPFileUploaderWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPFileUploaderWidgetViewComponent, "axp-file-uploader-widget-view", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPFileUploaderWidget: AXPWidgetConfig;
+interface AXPFileUploaderWidgetDesignerOptions {
+    multiple?: boolean;
+    accept?: string;
+    plugins?: {
+        name: string;
+        options?: unknown;
+    }[];
+    excludePlugins?: string[];
+    readonly?: boolean;
+    fileEditable?: boolean;
+    maxFileSize?: number;
+    enableTitleDescription?: boolean;
+    showEditDialogAfterSelect?: boolean;
+    showBorder?: boolean;
+    showAddItemButton?: boolean;
+}
+interface AXPFileUploaderWidgetViewOptions {
+}
+interface AXPFileUploaderWidgetEditOptions {
+    multiple?: boolean;
+    accept?: string;
+    plugins?: {
+        name: string;
+        options?: unknown;
+    }[];
+    excludePlugins?: string[];
+    readonly?: boolean;
+    fileEditable?: boolean;
+    maxFileSize?: number;
+    enableTitleDescription?: boolean;
+    showEditDialogAfterSelect?: boolean;
+    showBorder?: boolean;
+    showAddItemButton?: boolean;
+}
+interface AXPFileUploaderWidgetColumnOptions {
+}
+interface AXPFileUploaderWidgetPrintOptions {
+}
+interface AXPFileUploaderWidgetOptions {
+    designer: AXPFileUploaderWidgetDesignerOptions;
+    view: AXPFileUploaderWidgetViewOptions;
+    edit: AXPFileUploaderWidgetEditOptions;
+    print: AXPFileUploaderWidgetPrintOptions;
+    column: AXPFileUploaderWidgetColumnOptions;
+}
+declare module '@acorex/platform/layout/widget-core' {
+    interface AXPWidgetTypesMap {
+        attachments: 'attachments';
+    }
+}
+
+interface AXPFileUploaderShowFileListEntityContext extends AXPFileUploaderEntityFilesScope {
+}
+interface AXPFileUploaderShowFileListOptions {
+    /** When set, files are loaded and saved via FileUploader:LoadFiles / FileUploader:SaveFiles. */
+    entity?: AXPFileUploaderShowFileListEntityContext;
+    /** Direct files (e.g. grid column preview); skips load/save commands. */
+    files?: AXPFileListItem[];
+    readonly?: boolean;
+    multiple?: boolean;
+    accept?: string;
+    fileEditable?: boolean;
+    maxFileSize?: number;
+    showAddItemButton?: boolean;
+    plugins?: {
+        name: string;
+        options?: unknown;
+    }[];
+    editDialog?: AXPFileUploaderEditDialogOptions;
+}
+declare class AXPFileUploaderWidgetService {
+    private popupService;
+    private translate;
+    private commandExecutor;
+    private queryExecutor;
+    showFileList(options?: AXPFileUploaderShowFileListOptions): Promise<AXPFileListItem[] | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPFileUploaderWidgetService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPFileUploaderWidgetService>;
+}
+
+type AXPLookupWidgetLookType = 'select' | 'lookup';
+/**
+ * How the lookup column resolves related items for display in entity lists.
+ * - `hydrated`: titles (and optional ids) are already on the row; inline preview + overflow popover use row data only.
+ * - `idsWithCount`: ids and optional count live on the row; the cell shows a count summary and loads titles via entity `byKey` when the popover opens.
+ * - `countOnly`: only a count is on the row; the popover loads ids/titles via a registered `AXPQuery` when opened.
+ */
+type AXPLookupColumnResolveStrategy = 'hydrated' | 'idsWithCount' | 'countOnly';
+/**
+ * Column list only: controls how the lookup column loads and displays related items in grids.
+ * Omitted or empty strategy defaults to `hydrated` at runtime.
+ */
+interface AXPLookupColumnResolveOptions {
+    /** Default `hydrated` when omitted. */
+    strategy?: AXPLookupColumnResolveStrategy;
+    /** Lodash-style path on `rowData` for the displayed count (e.g. `rolesCount`). */
+    countFieldPath?: string;
+    /** Lodash-style path on `rowData` for the related id list (`idsWithCount`). If omitted, the column `rawValue` is used. */
+    idsPath?: string;
+    /** Registered query key for `AXPQueryExecutor.fetch` when using `countOnly`. */
+    queryKey?: string;
+    /**
+     * Maps query input property names to lodash-style paths on `rowData` (e.g. `{ "userId": "id" }`).
+     * May be a JSON string when set from the layout designer text field.
+     */
+    queryParams?: Record<string, string> | string;
+    /**
+     * Dot path into the named query result for the items array. Defaults to `items` when the result is an object.
+     * If the query returns an array directly, leave unset and handle at runtime.
+     */
+    queryResultItemsPath?: string;
+}
+interface AXPLookupDisplayOptions {
+    displayFormat?: string;
+    textField?: string;
+    isMultiLanguage?: (value: unknown) => boolean;
+}
+/** Column list: entity detail popover when clicking a lookup value. */
+interface AXPLookupPopoverOptions {
+    /** When `false`, lookup values are not clickable and the detail popover does not open. Default `true`. */
+    enabled?: boolean;
+}
+/** Row actions to show in the lookup data selector popup (subset of entity list actions). */
+interface AXPLookupSelectorRowActionsConfig {
+    /** Primary icon buttons (e.g. preview). Match full command name or suffix such as `:Preview`. */
+    primary?: string[];
+    /** Secondary actions in the row dropdown menu. */
+    secondary?: string[];
+}
+interface AXPLookupWidgetOptions {
+    disabled?: boolean | AXPExpression;
+    readonly?: boolean | AXPExpression;
+    placeholder?: string;
+    expose?: string | string[];
+    look?: AXPLookupWidgetLookType;
+    allowClear?: boolean;
+    displayFormat?: string;
+    /** Column list: entity detail popover behavior. */
+    popover?: AXPLookupPopoverOptions;
+    /** Column list: lazy resolve and summary behavior. */
+    columnResolve?: AXPLookupColumnResolveOptions;
+    /** Lookup selector popup: entity row actions to display. */
+    selectorRowActions?: AXPLookupSelectorRowActionsConfig;
+}
+
+/**
+ * Normalizes lookup/search display templates for row-based formatting.
+ * Converts `context.eval('path')` expressions to `{{ path }}` and single braces to mustache form.
+ */
+declare function normalizeLookupDisplayTemplate(template: string): string;
+/**
+ * Resolves the display template for a lookup item.
+ * Priority: explicit `displayFormat` → entity `formats.lookup` (template) → entity `formats.searchResult.title`.
+ * Returns undefined when `textField` is set or no template applies (use {@link resolveLookupDisplayField} instead).
+ */
+declare function resolveLookupDisplayTemplate(entity: AXPEntity | null | undefined, options: AXPLookupDisplayOptions): string | undefined;
+/**
+ * Resolves the property path used for lookup display when no template applies.
+ * Priority: explicit `textField` → entity `formats.lookup` (simple path) → common property names.
+ */
+declare function resolveLookupDisplayField(entity: AXPEntity | null | undefined, options: AXPLookupDisplayOptions): string;
+/**
+ * Formats a lookup row for display using template and/or field resolution.
+ */
+declare function formatLookupItemDisplay(item: unknown, entity: AXPEntity | null | undefined, options: AXPLookupDisplayOptions, formatService: AXFormatService, resolveMultiLanguage?: (value: AXPMultiLanguageString) => string): string | AXPMultiLanguageString;
+/** True when a formatted label still contains unresolved template markers. */
+declare function isUnresolvedLookupDisplayTemplate(value: string): boolean;
+
+declare class AXPLookupWidgetViewComponent extends AXPValueWidgetComponent<any> {
+    protected readonly formatService: AXFormatService;
+    protected readonly translation: AXTranslationService;
+    protected readonly entityResolver: AXPEntityDefinitionRegistryService;
+    protected entity: _angular_core.Signal<string>;
+    protected multiple: _angular_core.Signal<boolean>;
+    protected valueField: _angular_core.Signal<string>;
+    protected textField: _angular_core.Signal<string>;
+    protected badgeClass: _angular_core.Signal<string>;
+    protected displayFormat: _angular_core.Signal<string | undefined>;
+    protected displayField: _angular_core.Signal<string>;
+    protected loading: _angular_core.WritableSignal<boolean>;
+    private entityDef;
+    protected displayItems: _angular_core.WritableSignal<any[]>;
+    private efEntity;
+    private efDisplay;
+    private extractItem;
+    private getDisplayRaw;
+    private get __class();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLookupWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPLookupWidgetViewComponent, "axp-lookup-widget-view", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Selects which entity list row actions appear in the data selector.
+ * Match by full command name, action `name`, trigger name, or command suffix (e.g. `:Preview`).
+ */
+interface AXPEntityDataSelectorRowActionsConfig {
+    primary?: string[];
+    secondary?: string[];
+}
+declare class AXPEntityDataSelectorRowActionsService {
+    private readonly expressionEvaluator;
+    private readonly workflow;
+    private readonly commandService;
+    /**
+     * Build a row-actions handler for {@link AXPDataSelectorComponent} from entity list actions.
+     */
+    createHandler(entity: AXPEntity, config: AXPEntityDataSelectorRowActionsConfig): AXPDataSelectorRowActionsHandler | undefined;
+    private buildIndividualActions;
+    private filterActions;
+    private matchesActionFilter;
+    private getCommandNameFromTrigger;
+    private flattenActions;
+    private toRowCommandItems;
+    private evaluateActionsForRow;
+    private createExpressionScope;
+    private resolveTriggerName;
+    private resolveCommandNameExpression;
+    private resolveTitleExpression;
+    private executeCommand;
+    private evaluateActionOptions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityDataSelectorRowActionsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityDataSelectorRowActionsService>;
+}
+
+interface AXPEntityDataSelectorSelectionOptions {
+    multiple?: boolean;
+    selectedItemIds?: string[] | number[];
+    /** Allow confirming with no selection (clears the lookup value). Default: true. */
+    allowUnselect?: boolean;
+}
+interface AXPEntityDataSelectorGridOptions {
+    columns?: string[];
+    pageSize?: number;
+}
+interface AXPEntityDataSelectorFilterOptions {
+    value?: AXDataSourceFilterOption | null;
+    parent?: AXDataSourceFilterOption | null;
+}
+interface AXPEntityDataSelectorSearchOptions {
+    fields?: string[];
+    initial?: string;
+}
+interface AXPEntityDataSelectorSortOptions {
+    fields?: {
+        name: string;
+        dir: 'asc' | 'desc';
+    }[];
+}
+interface AXPEntityDataSelectorCategoryFilterOptions {
+    field: string;
+    operator?: 'equal' | 'contains' | 'in';
+}
+interface AXPEntityDataSelectorCategoryOptions {
+    /** When false, category sidebar is hidden. Default: true (auto-detect from entity plugin). */
+    enabled?: boolean;
+    title?: string;
+    width?: string;
+    filter?: AXPEntityDataSelectorCategoryFilterOptions;
+    dataSource?: AXPCategoryTreeDataSource;
+}
+interface AXPEntityDataSelectorCreateOptions {
+    mode?: AXPDataSelectorAllowCreate;
+}
+/** Nested options for {@link AXPEntityDataSelectorService.open}. */
+interface AXPEntityDataSelectorOpenOptions {
+    entity: AXPEntity;
+    title: string;
+    selection?: AXPEntityDataSelectorSelectionOptions;
+    grid?: AXPEntityDataSelectorGridOptions;
+    filter?: AXPEntityDataSelectorFilterOptions;
+    search?: AXPEntityDataSelectorSearchOptions;
+    sort?: AXPEntityDataSelectorSortOptions;
+    category?: AXPEntityDataSelectorCategoryOptions;
+    create?: AXPEntityDataSelectorCreateOptions;
+    /** Entity list row actions to expose in the selector grid (matched by command name). */
+    rowActions?: AXPEntityDataSelectorRowActionsConfig;
+}
+/**
+ * @deprecated Use {@link AXPEntityDataSelectorOpenOptions}. Will be removed in a future release.
+ */
+interface AXPEntityDataSelectorOptions {
+    entity: AXPEntity;
+    title: string;
+    allowMultiple?: boolean;
+    /** Allow confirming with no selection (clears the lookup value). Default: true. */
+    allowUnselect?: boolean;
+    filters?: AXDataSourceFilterOption | null;
+    parentFilters?: AXDataSourceFilterOption | null;
+    columns?: string[];
+    sortedFields?: {
+        name: string;
+        dir: 'asc' | 'desc';
+    }[];
+    allowCreate?: AXPDataSelectorAllowCreate;
+    searchFields?: string[];
+    initialSearchTerm?: string;
+    selectedItemIds?: string[] | number[];
+    categoryFilter?: {
+        title: string;
+        dataSource: AXPCategoryTreeDataSource;
+        filterField: string;
+        filterOperator?: 'equal' | 'contains' | 'in';
+        width?: string;
+    };
+    showCategoryFilter?: boolean;
+    rowActions?: AXPEntityDataSelectorRowActionsConfig;
+}
+type AXPEntityDataSelectorOpenInput = AXPEntityDataSelectorOpenOptions | AXPEntityDataSelectorOptions;
+interface AXPEntityDataSelectorResult {
+    items: any[];
+}
+/**
+ * Returns true when flat (legacy) option fields are present on the input object.
+ */
+declare function isLegacyEntityDataSelectorOptions(options: AXPEntityDataSelectorOpenInput): options is AXPEntityDataSelectorOptions;
+/**
+ * Maps deprecated flat options to {@link AXPEntityDataSelectorOpenOptions}.
+ */
+declare function mapLegacyEntityDataSelectorOptions(legacy: AXPEntityDataSelectorOptions): AXPEntityDataSelectorOpenOptions;
+/**
+ * Normalizes legacy flat or nested options to {@link AXPEntityDataSelectorOpenOptions}.
+ * When both shapes are mixed, nested groups take precedence over mapped legacy values.
+ */
+declare function normalizeEntityDataSelectorOptions(options: AXPEntityDataSelectorOpenInput): AXPEntityDataSelectorOpenOptions;
+declare class AXPEntityDataSelectorService {
+    private readonly dataSelectorService;
+    private readonly filterOperatorMiddleware;
+    private readonly widgetResolver;
+    private readonly entityResolver;
+    private readonly commandService;
+    private readonly categoryTreeService;
+    private readonly translationService;
+    private readonly rowActionsService;
+    /**
+     * Open entity data selector popup.
+     * Accepts nested {@link AXPEntityDataSelectorOpenOptions} or deprecated flat {@link AXPEntityDataSelectorOptions}.
+     */
+    open(options: AXPEntityDataSelectorOpenInput): Promise<AXPEntityDataSelectorResult | null>;
+    /**
+     * Execute Entity:Create and return created item.
+     * Used by lookup widget and data selector for inline create.
+     */
+    executeEntityCreate(entity: AXPEntity, mode: 'full' | 'quick'): Promise<any | null>;
+    /**
+     * Normalize item's phones/emails for expose/display.
+     * Call this when receiving items from any source (create, API, selector).
+     */
+    normalizeItemContactArrays(item: any): any;
+    /**
+     * Apply category sidebar config from normalized options or entity plugin auto-detection.
+     */
+    private applyCategoryFilter;
+    /**
+     * Create data selector configuration from entity options
+     */
+    private createDataSelectorConfig;
+    /**
+     * Create data source from entity definition
+     */
+    private createDataSource;
+    /**
+     * Create columns configuration from entity definition
+     */
+    private createColumns;
+    /**
+     * Get searchable fields from entity properties
+     */
+    private getSearchFields;
+    /**
+     * Get allowCreate mode from entity
+     */
+    private getAllowCreate;
+    /**
+     * Execute Entity:Create and return created item
+     */
+    private executeCreate;
+    /**
+     * Normalize phones/emails from repeater form to plain arrays of { value: string }.
+     * Repeater/ContactBox can return nested structure: { value: { label: "", value: "101010" } }
+     * Contact widget expects: { value: "101010", label?: string }
+     */
+    private normalizeContactArrays;
+    /**
+     * Create category tree data source from category entity key.
+     * Uses the same {@link AXPCategoryTreeService} as the entity master list category sidebar.
+     */
+    private createCategoryTreeDataSource;
+    /**
+     * Build category tree data source callbacks backed by shared category tree service.
+     */
+    private buildCategoryTreeDataSource;
+    /**
+     * Map a category entity row to {@link AXPCategoryEntity} for the reusable category tree component.
+     */
+    private mapCategoryItemToEntity;
+    /**
+     * Map a lazy-loaded tree node to {@link AXPCategoryEntity}.
+     */
+    private mapCategoryTreeNodeToEntity;
+    /**
+     * Resolve category display text, including multi-language titles.
+     */
+    private resolveCategoryText;
+    /**
+     * Merge custom and parent filters into data source query
+     */
+    private mergeFilters;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityDataSelectorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityDataSelectorService>;
+}
+
+/**
+ * Base interface for lookup widget look components
+ * All look components should implement this interface to ensure consistency
+ */
+declare abstract class LookupWidgetLookBase {
+    abstract refresh(): void;
+    abstract focus(): void;
+    abstract clear(): void;
+}
+
+declare class AXPLookupWidgetEditComponent extends AXPValueWidgetComponent<any> {
+    #private;
+    protected readonly injector: Injector;
+    protected readonly entityResolver: AXPEntityDefinitionRegistryService;
+    protected readonly entityService: AXPEntityService;
+    protected readonly entityDataSelectorService: AXPEntityDataSelectorService;
+    private readonly mlsResolver;
+    protected componentLook: _angular_core.Signal<LookupWidgetLookBase | undefined>;
+    protected expose: _angular_core.Signal<string | any[] | undefined>;
+    protected entity: _angular_core.Signal<string>;
+    protected disabled: _angular_core.Signal<string | boolean>;
+    protected columns: _angular_core.Signal<string[]>;
+    protected textField: _angular_core.Signal<string>;
+    /**
+     * Template for select look (`ax-select-box`). Uses `textTemplate` when set, otherwise
+     * falls back to `displayFormat` (same as tagbox). Single braces are expanded to `{{ }}`
+     * for the select box template engine (see `AXPDataListWidgetComponent.textTemplate`).
+     */
+    protected textTemplate: _angular_core.Signal<string | null>;
+    protected hasClearButton: _angular_core.Signal<boolean>;
+    protected showItemTooltip: _angular_core.Signal<boolean>;
+    protected isItemTruncated: _angular_core.Signal<boolean>;
+    protected customFilter: _angular_core.Signal<AXDataSourceFilterOption>;
+    protected placeholder: _angular_core.Signal<string>;
+    protected filterMode: _angular_core.Signal<boolean>;
+    protected multiple: _angular_core.Signal<boolean>;
+    protected allowUnselect: _angular_core.Signal<boolean>;
+    protected look: _angular_core.Signal<AXPLookupWidgetLookType>;
+    protected displayField: _angular_core.Signal<string>;
+    protected allowCreate: _angular_core.Signal<"none" | "full" | "quick">;
+    protected selectorRowActions: _angular_core.Signal<AXPLookupSelectorRowActionsConfig | undefined>;
+    protected valueField: _angular_core.Signal<string>;
+    protected displayFormat: _angular_core.Signal<string | undefined>;
+    protected conditions?: AXPQueryFilter[];
+    protected filter: AXDataSourceFilterOption | null;
+    protected entityDef: _angular_core.WritableSignal<AXPEntity | null>;
+    protected selectedItems: _angular_core.WritableSignal<any[]>;
+    protected initialItems: _angular_core.WritableSignal<boolean>;
+    protected initialized: _angular_core.WritableSignal<boolean>;
+    protected previousValue: _angular_core.WritableSignal<any>;
+    protected isLoading: _angular_core.WritableSignal<boolean>;
+    private hasValue;
+    private findByValue;
+    protected handleComponentValueChanged(items: any[] | null): void;
+    protected handleCreateClick(_e: AXClickEvent): Promise<void>;
+    private executeCreate;
+    protected setLoading: (loading: boolean) => void;
+    protected setItems: (items: any[]) => void;
+    /**
+     * Writes expose targets into context using per-path updates.
+     * Avoids `contextService.patch()` with nested objects: patch shallow-merges top-level keys only,
+     * so e.g. `{ person: { educationLevel: { id, title } } }` would replace the entire `person`
+     * object and drop sibling fields like `person.educationLevelId`, causing a value/effect loop.
+     */
+    private expoesItems;
+    outputs(): (string | {
+        [name: string]: unknown;
+    })[];
+    private singleOrMultiple;
+    refresh(): void;
+    clear(): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLookupWidgetEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPLookupWidgetEditComponent, "axp-lookup-widget-edit", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPLookupWidgetColumnComponent extends AXPColumnWidgetComponent<any> {
+    private readonly entityDetailPopoverService;
+    private readonly translation;
+    private readonly formatService;
+    private readonly entityService;
+    private readonly entityResolver;
+    private readonly queryExecutor;
+    protected moreButton: _angular_core.Signal<ElementRef<any> | undefined>;
+    protected lazyTrigger: _angular_core.Signal<ElementRef<any> | undefined>;
+    protected morePopover: _angular_core.Signal<AXPopoverComponent | undefined>;
+    protected host: ElementRef<any>;
+    protected valueField: string;
+    protected entity: string;
+    protected columnName: string;
+    protected maxVisible: number;
+    protected lookupDisplayOptions: _angular_core.Signal<{
+        displayFormat: string | undefined;
+        textField: string | undefined;
+        isMultiLanguage: (value: unknown) => value is _acorex_core_translation.AXMultiLanguageMap;
+    }>;
+    protected displayFormat: _angular_core.Signal<string | undefined>;
+    protected displayField: _angular_core.Signal<string>;
+    protected columnResolve: _angular_core.Signal<AXPLookupColumnResolveOptions | undefined>;
+    protected resolveStrategy: _angular_core.Signal<AXPLookupColumnResolveStrategy>;
+    protected isHydratedStrategy: _angular_core.Signal<boolean>;
+    protected detailPopoverEnabled: _angular_core.Signal<boolean>;
+    protected isMorePopoverOpen: _angular_core.WritableSignal<boolean>;
+    protected selectedItemIndex: _angular_core.WritableSignal<number>;
+    protected resolvedPopoverItems: _angular_core.WritableSignal<any[]>;
+    protected resolveStatus: _angular_core.WritableSignal<"error" | "idle" | "loading" | "ready">;
+    protected resolveError: _angular_core.WritableSignal<string | null>;
+    protected summaryLabel: _angular_core.WritableSignal<string>;
+    protected popoverHeader: _angular_core.WritableSignal<string>;
+    private entityDef;
+    private hydratedDisplayItems;
+    private hydrateRequestId;
+    protected displayItems: _angular_core.Signal<any[]>;
+    protected allItems: _angular_core.Signal<any[]>;
+    protected visibleItems: _angular_core.Signal<any[]>;
+    protected hasMoreItems: _angular_core.Signal<boolean>;
+    protected idsFromRow: _angular_core.Signal<any[]>;
+    protected displayCount: _angular_core.Signal<number>;
+    protected popoverListItems: _angular_core.Signal<any[]>;
+    /** Avoid resetting lazy cache on every CD when `rowData` is a new object reference for the same row. */
+    private previousLazyRowId;
+    constructor();
+    protected showMoreItems(): void;
+    protected openLazyPopover(): void;
+    protected onPopoverOpenChange(event: unknown): void;
+    protected showItemDetail(item: any, index: number): Promise<void>;
+    protected handleItemClick(index: number): void;
+    protected handleResolvedItemClick(index: number): void;
+    protected handlePopoverItemClick(index: number): void;
+    /**
+     * True when the cell can render without fetching row data via byKey.
+     * Uses textField / expose targets on the row — not merely whether column dataPath differs from columnName.
+     */
+    protected hasPreresolvedDisplay(): boolean;
+    protected getDisplayRaw(item: any): string;
+    private refreshSummaryLabel;
+    private refreshPopoverHeader;
+    private resetLazyState;
+    private openPopoverFromRef;
+    private closeMorePopover;
+    private ensureLazyItemsLoaded;
+    /**
+     * ax-popover may emit a boolean, CustomEvent with detail, or a DOM Event depending on version.
+     */
+    private coercePopoverOpenEvent;
+    private loadByIds;
+    private loadByNamedQuery;
+    private buildNamedQueryInput;
+    private parseQueryParamsMap;
+    private extractItemsFromQueryResult;
+    private extractItem;
+    private hydrateScalarIds;
+    private isMultiValueLookup;
+    /** Row display text resolved via widget textField and expose targets (not column dataPath alone). */
+    private getRowDisplayTextFromTextField;
+    private getExposeTargets;
+    private hasDisplayTextOnLookupValue;
+    private renderLookupLabel;
+    private formatDisplayValue;
+    /** True when a scalar cell value is a stored entity key (uuid/numeric), not pre-resolved display text. */
+    private isLikelyEntityId;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPLookupWidgetColumnComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPLookupWidgetColumnComponent, "ng-component", never, { "rawValue": { "alias": "rawValue"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const AXPLookupWidget: AXPWidgetConfig;
+
+/**
+ * Unified reference format for all sources
+ */
+interface AXPMultiSourceRef {
+    /** Source identifier (e.g., 'site-location', 'inline-address', 'employee-user') */
+    sourceKey: string;
+    /** Entity ID if entity source (optional for inline sources) */
+    refId?: string;
+    /** Always present - used for display */
+    displayName: string;
+    /** Full data (for inline sources or denormalized entity data) */
+    data?: any;
+    /** Additional metadata */
+    meta?: Record<string, unknown>;
+}
+/**
+ * Stored value type
+ * - Single: AXPMultiSourceRef
+ * - Multiple: AXPMultiSourceRef[]
+ */
+type AXPMultiSourceValue = AXPMultiSourceRef | AXPMultiSourceRef[];
+/**
+ * Source type
+ */
+declare enum AXPMultiSourceType {
+    Entity = "entity",
+    Inline = "inline"
+}
+/**
+ * Single source item definition
+ */
+interface AXPMultiSourceItem {
+    /** Unique identifier for this source */
+    key: string;
+    /** Display information */
+    title: string;
+    icon?: string;
+    badge?: string;
+    description?: string;
+    /** Source type */
+    type: AXPMultiSourceType;
+    /** For entity sources: entity name (e.g., 'LocationManagement.Location') */
+    entity?: string;
+    /** For inline sources: command key to execute for inline creation (e.g., 'Module.Entity:CreateInline') */
+    inlineCreateCommand?: string;
+    /** Optional: Filter/constraints for this source */
+    filters?: AXDataSourceFilterOption;
+    /** Optional: Custom search fields */
+    searchFields?: string[];
+    /** Display format template for results */
+    displayFormat?: string;
+    /** Value transformation (how to store this source) */
+    valueTransform?: (item: any) => AXPMultiSourceRef;
+}
+/**
+ * Complete source configuration (from provider)
+ */
+interface AXPMultiSourceDefinition {
+    /** Provider name */
+    name: string;
+    /** Display title */
+    title: string;
+    /** Sources array */
+    sources: AXPMultiSourceItem[];
+    /** Default search strategy */
+    searchStrategy: 'unified' | 'tabs' | 'grouped';
+    /** Default display format */
+    defaultDisplayFormat?: string;
+    /** Default multiple selection */
+    defaultMultiple?: boolean;
+}
+/**
+ * Widget options
+ */
+interface AXPMultiSourceSelectorWidgetOptions {
+    /** Provider name (required) */
+    providerName: string;
+    /** Override multiple selection (optional, uses provider default if not specified) */
+    multiple?: boolean;
+    /** Override display format (optional, uses provider default if not specified) */
+    displayFormat?: string;
+    /** Additional filters to apply to all sources */
+    filters?: AXDataSourceFilterOption;
+    /** Custom placeholder */
+    placeholder?: string;
+    /** Allow clear */
+    allowClear?: boolean;
+}
+
+/**
+ * Injection token for multi-source definition providers
+ */
+declare const AXP_MULTI_SOURCE_DEFINITION_PROVIDER: InjectionToken<AXPMultiSourceDefinitionProvider[]>;
+/**
+ * Provider context for building definitions
+ */
+declare class AXPMultiSourceDefinitionProviderContext {
+    private definitions;
+    addDefinition(definition: AXPMultiSourceDefinition): void;
+    getDefinitions(): AXPMultiSourceDefinition[];
+    findDefinition(name: string): AXPMultiSourceDefinition | undefined;
+}
+/**
+ * Provider interface
+ */
+interface AXPMultiSourceDefinitionProvider {
+    provide(context: AXPMultiSourceDefinitionProviderContext): Promise<void> | void;
+}
+/**
+ * Service for managing multi-source definitions
+ */
+declare class AXPMultiSourceDefinitionProviderService {
+    private readonly providers;
+    private cache;
+    private load;
+    /**
+     * Get definition by name
+     */
+    getDefinition(name: string): Promise<AXPMultiSourceDefinition>;
+    /**
+     * Reload definitions (clear cache)
+     */
+    reload(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMultiSourceDefinitionProviderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPMultiSourceDefinitionProviderService>;
+}
+
+declare const AXPMultiSourceSelectorWidget: AXPWidgetConfig;
+
+/**
+ * Search result item with source information
+ */
+interface AXPMultiSourceSearchResultItem {
+    source: AXPMultiSourceItem;
+    item: any;
+}
+/**
+ * Search result
+ */
+interface AXPMultiSourceSearchResult {
+    items: AXPMultiSourceSearchResultItem[];
+    total: number;
+}
+declare class AXPMultiSourceFederatedSearchService {
+    private readonly entityResolver;
+    /**
+     * Search across all enabled sources
+     */
+    search(definition: AXPMultiSourceDefinition, searchTerm: string, filters?: AXDataSourceFilterOption): Promise<AXPMultiSourceSearchResult>;
+    /**
+     * Search single source
+     */
+    searchSource(source: AXPMultiSourceItem, searchTerm: string, filters?: AXDataSourceFilterOption): Promise<{
+        items: any[];
+        total: number;
+    }>;
+    /**
+     * Resolve entity from entity name string (e.g., 'LocationManagement.Location')
+     */
+    private resolveEntity;
+    /**
+     * Search entity using entity queries
+     */
+    private searchEntity;
+    /**
+     * Build search filters from search term
+     */
+    private buildSearchFilters;
+    /**
+     * Get default searchable fields from entity
+     */
+    private getDefaultSearchFields;
+    /**
+     * Merge multiple filters
+     */
+    private mergeFilters;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMultiSourceFederatedSearchService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPMultiSourceFederatedSearchService>;
+}
+
+/**
+ * Selector open configuration
+ */
+interface AXPMultiSourceSelectorOpenConfig {
+    definition: AXPMultiSourceDefinition;
+    multiple: boolean;
+    selectedValues?: AXPMultiSourceValue;
+    filters?: AXDataSourceFilterOption;
+    title?: string;
+}
+/**
+ * Selector result
+ */
+interface AXPMultiSourceSelectorResult {
+    items: AXPMultiSourceRef[];
+}
+declare class AXPMultiSourceSelectorService {
+    private readonly popupService;
+    private readonly definitionService;
+    /**
+     * Open selector popup by provider name
+     */
+    openByProviderName(providerName: string, config: {
+        multiple: boolean;
+        selectedValues?: AXPMultiSourceValue;
+        filters?: AXDataSourceFilterOption;
+        title?: string;
+    }): Promise<AXPMultiSourceSelectorResult | null>;
+    /**
+     * Open selector popup
+     */
+    open(config: AXPMultiSourceSelectorOpenConfig): Promise<AXPMultiSourceSelectorResult | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMultiSourceSelectorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPMultiSourceSelectorService>;
+}
+
+/**
+ * Multi-source selector popup component
+ */
+declare class AXPMultiSourceSelectorComponent extends AXBasePageComponent {
+    private readonly entityDataSelectorService;
+    private readonly entityResolver;
+    private readonly translationService;
+    protected config: _angular_core.WritableSignal<AXPMultiSourceSelectorOpenConfig>;
+    protected definition: _angular_core.Signal<AXPMultiSourceDefinition>;
+    protected activeTabKey: _angular_core.WritableSignal<string | null>;
+    protected activeSource: _angular_core.Signal<AXPMultiSourceItem | null>;
+    protected selectedItems: _angular_core.WritableSignal<AXPMultiSourceRef[]>;
+    protected readonly AXPMultiSourceType: typeof AXPMultiSourceType;
+    protected ngOnInit(): void;
+    protected handleTabClick(source: AXPMultiSourceItem): void;
+    protected handleSelectFromSource(source: AXPMultiSourceItem): Promise<void>;
+    protected handleCancel(): void;
+    protected handleConfirm(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMultiSourceSelectorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPMultiSourceSelectorComponent, "axp-multi-source-selector", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPMultiSourceSelectorWidgetEditComponent extends AXPValueWidgetComponent<any> {
+    protected readonly popupService: AXPopupService;
+    protected readonly definitionService: AXPMultiSourceDefinitionProviderService;
+    protected readonly selectorService: AXPMultiSourceSelectorService;
+    protected tagBox: _angular_core.Signal<AXTagBoxComponent | undefined>;
+    protected providerName: _angular_core.Signal<string>;
+    protected disabled: _angular_core.Signal<boolean>;
+    protected multiple: _angular_core.Signal<boolean>;
+    protected allowClear: _angular_core.Signal<boolean>;
+    protected placeholderText: _angular_core.Signal<string>;
+    protected searchTerm: _angular_core.WritableSignal<string | null>;
+    protected selectedItems: _angular_core.WritableSignal<AXPMultiSourceRef[]>;
+    protected isLoading: _angular_core.WritableSignal<boolean>;
+    protected isOpen: _angular_core.WritableSignal<boolean>;
+    protected definition: _angular_core.WritableSignal<AXPMultiSourceDefinition | null>;
+    private efProvider;
+    private efValue;
+    protected handleOnClick(e: AXClickEvent): void;
+    protected handleValueChange(e: AXValueChangedEvent): void;
+    protected handleSearchInputChange(e: AXValueChangedEvent): void;
+    protected handleOnBlur(e: AXFocusEvent): void;
+    protected handleKeyUp(e: AXHtmlEvent): Promise<void>;
+    protected handleClearClick(): void;
+    private findByValue;
+    private normalizeToRef;
+    private showSelector;
+    private setItems;
+    refresh(): void;
+    clear(): void;
+    private clearInput;
+    protected getTagLabel(item: AXPMultiSourceRef): string;
+    private singleOrMultiple;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMultiSourceSelectorWidgetEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPMultiSourceSelectorWidgetEditComponent, "axp-multi-source-selector-widget-edit", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPMultiSourceSelectorWidgetViewComponent extends AXPValueWidgetComponent<any> {
+    protected readonly formatService: AXFormatService;
+    protected readonly definitionService: AXPMultiSourceDefinitionProviderService;
+    protected providerName: _angular_core.Signal<string>;
+    protected multiple: _angular_core.Signal<boolean>;
+    protected badgeClass: _angular_core.Signal<string>;
+    protected displayFormat: _angular_core.Signal<string | undefined>;
+    protected loading: _angular_core.WritableSignal<boolean>;
+    private definition;
+    protected displayItems: _angular_core.WritableSignal<{
+        id: string;
+        text: string;
+    }[]>;
+    private efProvider;
+    private efDisplay;
+    private extractDisplayItem;
+    private getDisplayText;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMultiSourceSelectorWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPMultiSourceSelectorWidgetViewComponent, "axp-multi-source-selector-widget-view", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPMultiSourceSelectorWidgetColumnComponent extends AXPColumnWidgetComponent<any> {
+    private readonly formatService;
+    private readonly definitionService;
+    protected providerName: string;
+    protected columnName: string;
+    protected maxVisible: number;
+    protected displayFormat: _angular_core.Signal<string | undefined>;
+    private definition;
+    constructor();
+    protected displayItems: _angular_core.Signal<{
+        id: string;
+        text: string;
+    }[]>;
+    protected allItems: _angular_core.Signal<{
+        id: string;
+        text: string;
+    }[]>;
+    protected visibleItems: _angular_core.Signal<{
+        id: string;
+        text: string;
+    }[]>;
+    protected hasMoreItems: _angular_core.Signal<boolean>;
+    protected remainingItemsCount: _angular_core.Signal<number>;
+    private loadDefinition;
+    private extractDisplayItem;
+    private getDisplayText;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPMultiSourceSelectorWidgetColumnComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPMultiSourceSelectorWidgetColumnComponent, "axp-multi-source-selector-widget-column", never, { "rawValue": { "alias": "rawValue"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class AXPSelectorStructureWidgetColumnComponent extends AXPValueWidgetComponent {
+    protected identityField: _angular_core.Signal<string>;
+    protected textField: _angular_core.Signal<string>;
+    protected valueField: _angular_core.Signal<string>;
+    protected previewIcon: _angular_core.Signal<string>;
+    protected cellText: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPSelectorStructureWidgetColumnComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPSelectorStructureWidgetColumnComponent, "axp-selector-structure-widget-column", never, {}, {}, never, never, true, never>;
+}
+
+type AXPSelectorStructureSelectorMode = 'select' | 'lookup';
+type AXPSelectorStructureStructureMode = 'schema' | 'freeform';
+type AXPSelectorStructureIdentityDisplay = 'readonly' | 'hidden';
+/** UI layout: standard = global multi-select + collapse rows; compactPanel = per-row select (address-style). */
+type AXPSelectorStructurePresentationMode = 'standard' | 'compactPanel';
+interface AXPSelectorStructureFieldDef {
+    name: string;
+    title: string;
+    widgetType: string;
+    options?: Record<string, unknown>;
+}
+declare const AXPSelectorStructureWidget: AXPWidgetConfig;
+interface AXPSelectorStructureWidgetDesignerOptions {
+    selectorMode?: AXPSelectorStructureSelectorMode;
+    structureMode?: AXPSelectorStructureStructureMode;
+    presentation?: AXPSelectorStructurePresentationMode;
+    previewIcon?: string;
+    placeholder?: string;
+    contextSiblingPath?: string;
+    identityField?: string;
+    identityDisplay?: AXPSelectorStructureIdentityDisplay;
+    valueField?: string;
+    textField?: string;
+    dataSource?: unknown;
+    multiple?: boolean;
+    lookup?: {
+        entity?: string;
+        look?: 'select' | 'lookup';
+        filter?: unknown;
+        hasClearButton?: boolean;
+    };
+    structureFields?: AXPSelectorStructureFieldDef[];
+    freeformPath?: string;
+}
+interface AXPSelectorStructureWidgetViewOptions extends AXPSelectorStructureWidgetDesignerOptions {
+}
+interface AXPSelectorStructureWidgetEditOptions extends AXPSelectorStructureWidgetDesignerOptions {
+}
+interface AXPSelectorStructureWidgetColumnOptions {
+    identityField?: string;
+    textField?: string;
+    previewIcon?: string;
+}
+interface AXPSelectorStructureWidgetPrintOptions {
+}
+interface AXPSelectorStructureWidgetOptions {
+    designer: AXPSelectorStructureWidgetDesignerOptions;
+    view: AXPSelectorStructureWidgetViewOptions;
+    edit: AXPSelectorStructureWidgetEditOptions;
+    print: AXPSelectorStructureWidgetPrintOptions;
+    column: AXPSelectorStructureWidgetColumnOptions;
+}
+
+declare class AXPSelectorStructureWidgetEditComponent extends AXPValueWidgetComponent {
+    #private;
+    private readonly entityRegistry;
+    protected selectorMode: _angular_core.Signal<"select" | "lookup">;
+    protected structureMode: _angular_core.Signal<"schema" | "freeform">;
+    protected contextSiblingPath: _angular_core.Signal<string>;
+    protected identityField: _angular_core.Signal<string>;
+    protected identityDisplay: _angular_core.Signal<"readonly" | "hidden">;
+    protected valueField: _angular_core.Signal<string>;
+    protected textField: _angular_core.Signal<string>;
+    protected multiple: _angular_core.Signal<boolean>;
+    protected freeformPath: _angular_core.Signal<string>;
+    protected lookupEntityKey: _angular_core.Signal<string | undefined>;
+    protected lookupHasClearButton: _angular_core.Signal<boolean>;
+    protected lookupCustomFilter: _angular_core.Signal<AXDataSourceFilterOption | undefined>;
+    protected disabled: _angular_core.Signal<boolean>;
+    protected presentationMode: _angular_core.Signal<"standard" | "compactPanel">;
+    /** Compact panel (address-style) applies only to sibling select mode; lookup falls back to standard layout. */
+    protected useCompactLayout: _angular_core.Signal<boolean>;
+    protected previewIcon: _angular_core.Signal<string>;
+    protected placeholder: _angular_core.Signal<string>;
+    protected compactSelectPlaceholder: _angular_core.Signal<string>;
+    protected addCompactItemLabel: _angular_core.Signal<string>;
+    protected clearRowTitle: _angular_core.Signal<string>;
+    protected removeRowTitle: _angular_core.Signal<string>;
+    protected resolvedSiblingPath(): string;
+    /**
+     * Items shown in the selector: sibling context array when path is set, otherwise optional static `dataSource` array.
+     */
+    protected contextItems: _angular_core.Signal<unknown[]>;
+    protected contextSelectDataSource: _angular_core.Signal<AXDataSource<unknown>>;
+    protected selectedSourceItems: _angular_core.WritableSignal<unknown[]>;
+    protected compactRowDataSources: _angular_core.Signal<AXDataSource<unknown>[]>;
+    protected compactRowSelectedItems: _angular_core.Signal<unknown[][]>;
+    protected lookupEntityDef: _angular_core.WritableSignal<AXPEntity | null>;
+    protected defaultLookupSorts: _angular_core.Signal<AXDataSourceSortOption[]>;
+    protected lookupDataSource: _angular_core.Signal<AXDataSource<unknown> | null>;
+    protected lookupTextField: _angular_core.Signal<string>;
+    protected lookupSelectedItems: _angular_core.WritableSignal<unknown[]>;
+    protected rows: _angular_core.Signal<Record<string, unknown>[]>;
+    protected structureFields: _angular_core.Signal<AXPSelectorStructureFieldDef[]>;
+    protected structureFieldNodes: _angular_core.Signal<{
+        name: string;
+        title: string;
+        node: AXPWidgetNode;
+    }[]>;
+    protected identityLabel: _angular_core.Signal<string>;
+    protected identityNode: _angular_core.Signal<AXPWidgetNode | null>;
+    protected freeformHeading: _angular_core.Signal<string>;
+    protected keyPlaceholder: _angular_core.Signal<string>;
+    protected valuePlaceholder: _angular_core.Signal<string>;
+    protected addPairLabel: _angular_core.Signal<string>;
+    protected removePairTitle: _angular_core.Signal<string>;
+    protected disabledHint: _angular_core.Signal<string>;
+    protected trackRow(row: Record<string, unknown>): unknown;
+    protected rowCaption(row: Record<string, unknown>): string;
+    protected isDraftRow(row: Record<string, unknown>): boolean;
+    protected isRowSelectLocked(row: Record<string, unknown>): boolean;
+    /**
+     * Items available for row `index`: all source items minus keys already chosen on other committed rows;
+     * always includes the current row's selected item so the select can display it.
+     */
+    protected exclusiveItemsForRow(index: number): unknown[];
+    private newRowUid;
+    protected handleCompactSelectChange(index: number, e: AXValueChangedEvent): void;
+    protected applyCompactRowFromItem(index: number, rawItem: unknown | undefined): void;
+    protected clearCompactRow(index: number): void;
+    protected removeCompactRow(index: number): void;
+    protected addCompactRow(): void;
+    protected handleSelectValueChange(e: AXValueChangedEvent): void;
+    protected handleLookupValueChange(e: AXValueChangedEvent): void;
+    protected applyRowsFromSourceItems(items: unknown[]): void;
+    protected handleSchemaContextChange(rowKey: unknown, e: AXPContextChangeEvent): void;
+    protected freeformEntries(row: Record<string, unknown>): {
+        key: string;
+        value: string;
+        index: number;
+    }[];
+    private serializeFreeformValue;
+    protected onFreeformKeyInput(row: Record<string, unknown>, entry: {
+        key: string;
+        value: string;
+        index: number;
+    }, nextKey: string): void;
+    protected patchFreeformValue(row: Record<string, unknown>, key: string, raw: string): void;
+    protected removeFreeformKey(row: Record<string, unknown>, key: string): void;
+    protected addFreeformPair(row: Record<string, unknown>): void;
+    private renameFreeformKey;
+    private patchFreeformMap;
+    private tryParseFreeformString;
+    private mergeListFilter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPSelectorStructureWidgetEditComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPSelectorStructureWidgetEditComponent, "axp-selector-structure-widget-edit", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPSelectorStructureWidgetViewComponent extends AXPValueWidgetComponent {
+    protected identityField: _angular_core.Signal<string>;
+    protected textField: _angular_core.Signal<string>;
+    protected valueField: _angular_core.Signal<string>;
+    protected previewIcon: _angular_core.Signal<string>;
+    protected summaries: _angular_core.Signal<string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPSelectorStructureWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPSelectorStructureWidgetViewComponent, "axp-selector-structure-widget-view", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPEntityCreateEvent: {
+    (payload: {
+        entity: string;
+        meta?: any;
+    }): {
+        type: string;
+        payload: {
+            entity: string;
+            meta?: any;
+        };
+    };
+    type: string;
+};
+declare class AXPEntityCreatePopupAction extends AXPWorkflowAction {
+    private entityRegistery;
+    private popupService;
+    private platform;
+    private factory;
+    private config;
+    private translateService;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityCreatePopupAction, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityCreatePopupAction>;
+}
+declare class AXPEntityCreateSubmittedAction extends AXPWorkflowAction {
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityCreateSubmittedAction, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityCreateSubmittedAction>;
+}
+declare const AXPCreateEntityWorkflow: AXPWorkflow;
+
+declare const AXPEntityDeletedEvent: {
+    (payload: {
+        entity: string;
+        ids: string[];
+        meta?: any;
+    }): {
+        type: string;
+        payload: {
+            entity: string;
+            ids: string[];
+            meta?: any;
+        };
+    };
+    type: string;
+};
+interface AXPEntityDeleteOptions {
+    source: string;
+    ids: string[];
+}
+declare class AXPEntityPerformDeleteAction extends AXPWorkflowAction {
+    private entityRegistery;
+    private dialogService;
+    private loadingDialog;
+    private translationService;
+    private settingsService;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityPerformDeleteAction, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityPerformDeleteAction>;
+}
+declare const AXPDeleteEntityWorkflow: AXPWorkflow;
+
+declare class AXPQuickEntityModifyPopupAction extends AXPWorkflowAction {
+    private popupService;
+    private platform;
+    private translateService;
+    private entityRegistery;
+    private config;
+    private factory;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPQuickEntityModifyPopupAction, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPQuickEntityModifyPopupAction>;
+}
+declare const AXPQuickModifyEntityWorkflow: AXPWorkflow;
+declare class AXPEntityApplyUpdatesAction extends AXPWorkflowAction {
+    private entityRegistery;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityApplyUpdatesAction, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityApplyUpdatesAction>;
+}
+
+declare const AXPEntityModifyEvent: {
+    (payload: {
+        entity: string;
+        values: any;
+    }): {
+        type: string;
+        payload: {
+            entity: string;
+            values: any;
+        };
+    };
+    type: string;
+};
+declare class AXPEntityModifySectionPopupAction extends AXPWorkflowAction {
+    private popupService;
+    private platform;
+    private translateService;
+    private entityRegistery;
+    private config;
+    private factory;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityModifySectionPopupAction, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityModifySectionPopupAction>;
+}
+declare class AXPEntityModifyConfirmedAction extends AXPWorkflowAction {
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPEntityModifyConfirmedAction, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPEntityModifyConfirmedAction>;
+}
+declare const AXPModifyEntitySectionWorkflow: AXPWorkflow;
+
+declare class AXPShowDetailViewAction extends AXPWorkflowAction {
+    private navigation;
+    private sessionService;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPShowDetailViewAction, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPShowDetailViewAction>;
+}
+declare const AXPShowDetailsViewWorkflow: AXPWorkflow;
+
+/** Optional list filters passed into `show-list-view` (e.g. from `Entity:List` with `conditions`). */
+interface AXPShowListViewCondition {
+    name?: string;
+    field?: string;
+    operator?: {
+        type: string;
+    };
+    value?: unknown;
+}
+declare class AXPShowListViewAction extends AXPWorkflowAction {
+    private navigation;
+    private sessionService;
+    execute(context: AXPWorkflowContext): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPShowListViewAction, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPShowListViewAction>;
+}
+declare const AXPShowListViewWorkflow: AXPWorkflow;
+
+export { ATTACHMENTS_PAGE_COMPONENT_KEY, AXMEntityCrudService, AXMEntityCrudServiceImpl, AXPCategoryTreeService, AXPCreateEntityCommand, AXPCreateEntityWorkflow, AXPDataSeederService, AXPDeleteEntityWorkflow, AXPEditFileUploaderCommand, AXPEntitiesListDataSourceDefinition, AXPEntityApplyUpdatesAction, AXPEntityCategoryTreeSelectorComponent, AXPEntityCategoryWidget, AXPEntityCategoryWidgetColumnComponent, AXPEntityCategoryWidgetEditComponent, AXPEntityCategoryWidgetViewComponent, AXPEntityCommandTriggerViewModel, AXPEntityCreateEvent, AXPEntityCreatePopupAction, AXPEntityCreateSubmittedAction, AXPEntityCreateViewElementViewModel, AXPEntityCreateViewModelFactory, AXPEntityCreateViewSectionViewModel, AXPEntityDataProvider, AXPEntityDataProviderImpl, AXPEntityDataSelectorRowActionsService, AXPEntityDataSelectorService, AXPEntityDefinitionProviderWidget, AXPEntityDefinitionProviderWidgetEditComponent, AXPEntityDefinitionRegistryService, AXPEntityDeletedEvent, AXPEntityDetailListViewModel, AXPEntityDetailPopoverComponent, AXPEntityDetailPopoverService, AXPEntityDetailViewModelFactory, AXPEntityDetailViewModelResolver, AXPEntityEventDispatcherService, AXPEntityEventsKeys, AXPEntityFormBuilderService, AXPEntityListPersistenceModeDefault, AXPEntityListTableService, AXPEntityListToolbarService, AXPEntityListViewCardFieldViewModel, AXPEntityListViewColumnViewModel, AXPEntityListViewModelFactory, AXPEntityListViewModelResolver, AXPEntityListWidget, AXPEntityListWidgetViewComponent, AXPEntityMasterCreateViewModel, AXPEntityMasterListCardSelectActionName, AXPEntityMasterListViewModel, AXPEntityMasterListViewQueryViewModel, AXPEntityMasterSingleElementViewModel, AXPEntityMasterSingleViewGroupViewModel, AXPEntityMasterSingleViewModel, AXPEntityMasterUpdateElementViewModel, AXPEntityMasterUpdateViewModel, AXPEntityMasterUpdateViewModelFactory, AXPEntityMiddleware, AXPEntityModifyConfirmedAction, AXPEntityModifyEvent, AXPEntityModifySectionPopupAction, AXPEntityModule, AXPEntityPerformDeleteAction, AXPEntityPreloadFiltersContainerComponent, AXPEntityPreloadFiltersViewModel, AXPEntityPreloadFiltersViewModelResolver, AXPEntityResolver, AXPEntityService, AXPEntityStorageService, AXPEntityUpdateViewSectionViewModel, AXPFileListComponent, AXPFileUploaderLoadFilesQuery, AXPFileUploaderSaveFilesCommand, AXPFileUploaderWidget, AXPFileUploaderWidgetColumnComponent, AXPFileUploaderWidgetEditComponent, AXPFileUploaderWidgetService, AXPFileUploaderWidgetViewComponent, AXPGetEntityDetailsQuery, AXPLayoutOrderingConfigService, AXPLookupWidget, AXPLookupWidgetColumnComponent, AXPLookupWidgetEditComponent, AXPLookupWidgetViewComponent, AXPMiddlewareAbortError, AXPMiddlewareEntityStorageService, AXPModifyEntitySectionWorkflow, AXPMultiSourceDefinitionProviderContext, AXPMultiSourceDefinitionProviderService, AXPMultiSourceFederatedSearchService, AXPMultiSourceSelectorComponent, AXPMultiSourceSelectorService, AXPMultiSourceSelectorWidget, AXPMultiSourceSelectorWidgetColumnComponent, AXPMultiSourceSelectorWidgetEditComponent, AXPMultiSourceSelectorWidgetViewComponent, AXPMultiSourceType, AXPOpenEntityDetailsCommand, AXPQuickEntityModifyPopupAction, AXPQuickModifyEntityWorkflow, AXPRelatedColumnEnrichmentService, AXPRelatedColumnMetadataResolver, AXPSelectorStructureWidget, AXPSelectorStructureWidgetColumnComponent, AXPSelectorStructureWidgetEditComponent, AXPSelectorStructureWidgetViewComponent, AXPShowDetailViewAction, AXPShowDetailsViewWorkflow, AXPShowListViewAction, AXPShowListViewWorkflow, AXPTruncatedBreadcrumbComponent, AXPUpdateEntityCommand, AXPViewEntityDetailsCommand, AXP_CATEGORY_TREE_ROOT_TITLE_I18N_KEY, AXP_DATA_SEEDER_TOKEN, AXP_ENTITY_ACTION_PLUGIN, AXP_ENTITY_CONFIG_TOKEN, AXP_ENTITY_DEFINITION_LOADER, AXP_ENTITY_MODIFIER, AXP_ENTITY_STORAGE_BACKEND, AXP_ENTITY_STORAGE_MIDDLEWARE, AXP_MULTI_SOURCE_DEFINITION_PROVIDER, AXP_RECORD_WORKFLOW_INFO_CORRELATION_ID_FIELD, AXP_RECORD_WORKFLOW_INFO_DEFINITION_ID_FIELD, AXP_RECORD_WORKFLOW_INFO_INSTANCE_ID_FIELD, DEFAULT_COLUMN_ORDER, DEFAULT_PAIR_SPAN_RULES, DEFAULT_PROPERTY_ORDER, DEFAULT_SECTION_ORDER, ENTITY_LIST_ROUTE_CONTEXT_SESSION_KEY, EntityBuilder, EntityDataAccessor, actionExists, applyDataSourcePagingWithoutLoad, attachmentFieldCount, attachmentsPlugin, attachmentsSemanticallyEqual, axpCreateEntityAiToolInputDefaults, axpCreateEntityCommandDefinition, buildAXPRecordWorkflowInfo, canPersistEntityListState, cloneLayoutArrays, collectEntityQuickSearchFieldPaths, collectNestedCreateHiddenProperties, collectNestedFieldPathsFromEntityColumns, collectQuickSearchPathsFromSingleEntityDefinition, columnOrderingMiddleware, columnOrderingMiddlewareProvider, columnWidthMiddleware, columnWidthMiddlewareProvider, committedAttachments, computeEntityAggregates, createColumnOrderingMiddlewareProvider, createLayoutOrderingMiddlewareProvider, createModifierContext, defaultCardLayoutMiddleware, defaultCardLayoutMiddlewareProvider, defaultMultiLanguageMiddleware, defaultMultiLanguageMiddlewareProvider, detectEntityChanges, ensureLayoutPropertyView, ensureLayoutSection, ensureListActions, entityDetailsCreateActions, entityDetailsCreateActionsDeferredParent, entityDetailsCrudActions, entityDetailsEditAction, entityDetailsNewEditAction, entityDetailsReferenceCondition, entityDetailsReferenceCreateActions, entityDetailsSimpleCondition, entityMasterBulkDeleteAction, entityMasterCreateAction, entityMasterCrudActions, entityMasterDeleteAction, entityMasterEditAction, entityMasterRecordActions, entityMasterViewAction, entityOverrideDetailsViewAction, eventDispatchMiddleware, filterSortEntityRows, findEntityListRowDataInTree, fingerprintAttachmentItem, fingerprintAttachments, formatLookupItemDisplay, getDataSourcePageIndex, getEntityListRowId, getMasterInterfacePropertySortKey, getRecordWorkflowCorrelationId, getRecordWorkflowInstanceId, hasFileUploaderTitleOrDescriptionFields, isAXPMiddlewareAbortError, isAttachmentListEntry, isCategoryEntity, isCategoryFilter, isFileListItem, isFileUploaderEditDialogAuto, isLegacyEntityDataSelectorOptions, isUnresolvedLookupDisplayTemplate, layoutOrderingMiddlewareFactory, layoutOrderingMiddlewareProvider, mapLegacyEntityDataSelectorOptions, mergeForeignKeyFieldIntoCreateActions, normalizeEntityDataSelectorOptions, normalizeEntityFieldToFileList, normalizeEntityListPersistenceMode, normalizeListPaging, normalizeLookupDisplayTemplate, persistedAttachments, provideEntity, resolveEntityPluginDetailPageOrder, resolveFileUploaderEditDialog, resolveFileUploaderEntityScope, resolveLookupDisplayField, resolveLookupDisplayTemplate, restoreEntityListExpandedRows, runEntityQuery, searchResultDescriptionMiddleware, searchResultDescriptionMiddlewareProvider, shouldLoadEntityListStateFromStorage, shouldResetEntityListStateOnRouteEntry };
+export type { AXPAuditEvent, AXPCollectEntityQuickSearchPathsResolver, AXPDataSeeder, AXPEntityActionPlugin, AXPEntityAggregateMeasure, AXPEntityAggregateOptions, AXPEntityAggregateReducerType, AXPEntityAggregateRequest, AXPEntityAggregateResult, AXPEntityCategoryWidgetOptions, AXPEntityChangeSet, AXPEntityConfigs, AXPEntityCreateDto, AXPEntityDataSelectorCategoryFilterOptions, AXPEntityDataSelectorCategoryOptions, AXPEntityDataSelectorCreateOptions, AXPEntityDataSelectorFilterOptions, AXPEntityDataSelectorGridOptions, AXPEntityDataSelectorOpenInput, AXPEntityDataSelectorOpenOptions, AXPEntityDataSelectorOptions, AXPEntityDataSelectorResult, AXPEntityDataSelectorRowActionsConfig, AXPEntityDataSelectorSearchOptions, AXPEntityDataSelectorSelectionOptions, AXPEntityDataSelectorSortOptions, AXPEntityDefinitionLoader, AXPEntityDefinitionPreloader, AXPEntityDeleteOptions, AXPEntityDetailDto, AXPEntityDetailPopoverOptions, AXPEntityLayoutLike, AXPEntityLayoutPropertyLike, AXPEntityLayoutSectionLike, AXPEntityListEntry, AXPEntityListExpandRowRef, AXPEntityListInput, AXPEntityListItemDto, AXPEntityListPagingState, AXPEntityListPersistenceMode, AXPEntityListToolbarConvertOptions, AXPEntityMasterListCardLayout, AXPEntityMasterListCardSecondaryActionItem, AXPEntityMasterListViewSortPropViewModel, AXPEntityModel, AXPEntityModifier, AXPEntityModifierContext, AXPEntityModifierProvider, AXPEntityOutputDto, AXPEntityPreloadEntity, AXPEntityQueryAllOptions, AXPEntityQueryAllResult, AXPEntityStorageContext, AXPEntityStorageMiddleware, AXPEntityUpdateDto, AXPFileUploaderEditDialogFieldOptions, AXPFileUploaderEditDialogMode, AXPFileUploaderEditDialogOptions, AXPFileUploaderEntityFilesScope, AXPFileUploaderLoadFilesInput, AXPFileUploaderLoadFilesResult, AXPFileUploaderSaveFilesInput, AXPFileUploaderSaveFilesResult, AXPFileUploaderShowFileListEntityContext, AXPFileUploaderShowFileListOptions, AXPFileUploaderUploadActionDescriptor, AXPFileUploaderWidgetColumnOptions, AXPFileUploaderWidgetDesignerOptions, AXPFileUploaderWidgetEditOptions, AXPFileUploaderWidgetOptions, AXPFileUploaderWidgetPrintOptions, AXPFileUploaderWidgetViewOptions, AXPGetEntityDetailsQueryInput, AXPGetEntityDetailsQueryResult, AXPLookupColumnResolveOptions, AXPLookupColumnResolveStrategy, AXPLookupDisplayOptions, AXPLookupPopoverOptions, AXPLookupSelectorRowActionsConfig, AXPLookupWidgetLookType, AXPLookupWidgetOptions, AXPMultiSourceDefinition, AXPMultiSourceDefinitionProvider, AXPMultiSourceItem, AXPMultiSourceRef, AXPMultiSourceSearchResult, AXPMultiSourceSearchResultItem, AXPMultiSourceSelectorOpenConfig, AXPMultiSourceSelectorResult, AXPMultiSourceSelectorWidgetOptions, AXPMultiSourceValue, AXPOpenEntityDetailsCommandInput, AXPRecordAuditInfo, AXPRecordOwnershipInfo, AXPRecordStateInfo, AXPRecordWorkflowInfo, AXPRelatedColumnMetadata, AXPSelectorStructureFieldDef, AXPSelectorStructureIdentityDisplay, AXPSelectorStructurePresentationMode, AXPSelectorStructureSelectorMode, AXPSelectorStructureStructureMode, AXPSelectorStructureWidgetColumnOptions, AXPSelectorStructureWidgetDesignerOptions, AXPSelectorStructureWidgetEditOptions, AXPSelectorStructureWidgetOptions, AXPSelectorStructureWidgetPrintOptions, AXPSelectorStructureWidgetViewOptions, AXPShowListViewCondition, AttachmentsDisplayMode, AttachmentsPluginOptions, CategoryQueryEvent, CategoryQueryFunction, CategoryQueryResult, CategoryTreeConfig, CategoryTreeNodeData, EntityDetailPluginPageSlot, PairSpanRule, ResolveEntityPluginDetailPageOrderOptions, RunEntityQueryAdapters, SectionOrderConfig, SkipEntityComponentPageRef };