@acorex/platform 21.0.0-next.8 → 21.0.0-next.85

package/{core/index.d.ts → types/acorex-platform-core.d.ts}

@@ -1,10 +1,18 @@
 import * as i0 from '@angular/core';
-import { Type, InjectionToken, OnInit, ElementRef, EventEmitter, OnChanges, Renderer2, SimpleChanges, ViewContainerRef, OnDestroy, Injector, PipeTransform, Provider } from '@angular/core';
-import { AXStyleColorType, AXDataSource, AXDataSourceSortOption, AXDataSourceFilterOption, AXDataSourceQuery, AXDataSourceCallbackResult } from '@acorex/cdk/common';
+import { Type, InjectionToken, OnInit, ViewContainerRef, ModuleWithProviders, ElementRef, EventEmitter, OnChanges, Renderer2, SimpleChanges, OnDestroy, DestroyRef, Injector, PipeTransform, Provider } from '@angular/core';
+import { AXStyleColorType, AXDataSource, AXDataSourceSortOption, AXDataSourceFilterOption, AXStyleLookType, AXDataSourceQuery, AXDataSourceCallbackResult } from '@acorex/cdk/common';
+import { AXMultiLanguageString } from '@acorex/core/translation';
 import * as _ngrx_signals from '@ngrx/signals';
+import * as _acorex_platform_core from '@acorex/platform/core';
 import { Observable } from 'rxjs';
 import { NavigationExtras } from '@angular/router';
 
+/** Platform core datasource registry names. */
+declare const AXPPlatformCoreDataSourceKeys: {
+    readonly ModuleManifests: "platform-module-manifests";
+    readonly CatalogScopes: "platform-catalog-scopes";
+};
+
 /**
  * Additional suggested generic actions for future consideration:
  *
@@ -899,7 +907,7 @@ declare function getActionButton(actionType: string): {
 interface AXPColumnQuery {
     name: string;
     title: string;
-    visible: boolean;
+    visible: boolean | string;
 }
 
 type AXPPartialNested<T> = {
@@ -907,6 +915,28 @@ type AXPPartialNested<T> = {
 };
 declare function getNestedKeys(obj: any, prefix?: string): string[];
 type AXPExpression = string;
+/**
+ * Plain or rich text that may be localized: a single string or a map of locale code to string.
+ * Use when multi-language editing stores `Record<locale, string>` instead of one string.
+ *
+ * @example Single value (one locale or shared text)
+ * `"<p>Pick one</p>"`
+ *
+ * @example Per-locale map (e.g. after multi-language editor save)
+ * `{ "en-US": "<p>Pick one</p>", "fa-IR": "<p>یکی را انتخاب کنید</p>" }`
+ */
+type AXPMultiLanguageString = AXMultiLanguageString;
+/**
+ * Shared category descriptor for widgets, query catalog tooling, and other definition groupings.
+ */
+interface AXPDefinitionCategory {
+    name: string;
+    title: AXPMultiLanguageString;
+    order: number;
+    icon?: string;
+}
+/** Normalizes definition categories to an array for iteration and serialization. */
+declare function normalizeDefinitionCategories(categories?: AXPDefinitionCategory | AXPDefinitionCategory[]): AXPDefinitionCategory[];
 type AXPMetaData = Record<string, any>;
 type AXPOptionsData<T extends Record<string, unknown> = Record<string, any>> = T;
 interface AXPValueUnit {
@@ -943,8 +973,10 @@ interface AXPContent {
     content: string;
     contentType: AXPContentType;
 }
+type AXPMaybePromise<T = unknown> = T | Promise<T>;
 
 type AXPDataSource = string | AXDataSource | any[];
+type AXPDataType = 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array' | 'blob';
 interface AXPPagedListResult<T = any> {
     items: T[];
     total: number;
@@ -958,31 +990,142 @@ interface AXPQueryRequest {
         [key: string]: string;
     };
 }
-type AXPDataType = 'string' | 'number' | 'object' | 'boolean' | 'array';
+/**
+ * Category Entity - Base interface for hierarchical category structures
+ *
+ * This interface provides a standardized data model for category entities across the platform.
+ * All category entities (e.g., ReportCategory, ActivityCategory, WorkflowCategory) extend this interface
+ * to ensure consistency in data structure and field names.
+ *
+ * @template TKey - The type of the identifier key (default: string)
+ *
+ * @example
+ * ```typescript
+ * const category: AXPCategoryEntity = {
+ *   id: 'cat-001',
+ *   title: 'Electronics',
+ *   description: 'Electronic products',
+ *   parentId: undefined, // Root category
+ *   childrenCount: 2,    // Has 2 direct child categories
+ *   itemsCount: 5,      // Has 5 items directly in this category
+ *   totalChildrenCount: 6,  // Total of 6 nested categories (including grandchildren)
+ *   totalItemsCount: 23     // Total of 23 items in entire category tree
+ * };
+ * ```
+ */
 interface AXPCategoryEntity<TKey = string> {
+    /** Unique identifier for the category */
     id: TKey;
-    title: string;
-    description?: string;
+    /** Display name of the category (required) */
+    title: AXPMultiLanguageString;
+    /** Optional description of the category */
+    description?: AXPMultiLanguageString;
+    /** Parent category ID (undefined for root categories) */
     parentId?: TKey;
+    /**
+     * Count of direct child categories only (not recursive)
+     *
+     * Used by UI components to determine if a category has children and should show an expand icon.
+     * This enables efficient lazy loading - components can check this property without querying the API.
+     *
+     * @example
+     * - Category with 2 direct children: `childrenCount: 2`
+     * - Leaf category (no children): `childrenCount: 0`
+     *
+     * @remarks
+     * - Always set to `0` for leaf categories
+     * - Does not include grandchildren or nested descendants
+     * - Automatically maintained by middleware for category entities
+     */
     childrenCount: number;
+    /**
+     * Count of items directly assigned to this category (not recursive)
+     *
+     * Represents the number of items (e.g., reports, activities, workflows) that are directly
+     * assigned to this category. Does not include items from child categories.
+     *
+     * Useful for:
+     * - Displaying item counts per category in UI (e.g., "5 reports" badge)
+     * - Optimizing queries (skip API call if itemsCount === 0)
+     * - Showing category statistics
+     *
+     * @example
+     * - Category with 5 reports directly assigned: `itemsCount: 5`
+     * - Category with no direct items: `itemsCount: 0` or `undefined`
+     *
+     * @remarks
+     * - Does not include items from child categories
+     * - Can be calculated dynamically or stored
+     * - Optional - may be undefined if not needed
+     */
     itemsCount?: number;
-    totalChildren?: number;
-    totalItems?: number;
+    /**
+     * Recursive count of all nested child categories (includes all descendants)
+     *
+     * Represents the total number of categories in the entire subtree starting from this category.
+     * Includes children, grandchildren, and all nested descendants.
+     *
+     * Useful for:
+     * - Analytics and summary displays
+     * - Showing complete category tree scope
+     * - Performance metrics
+     *
+     * @example
+     * Root category with:
+     * - 2 direct children
+     * - Each child has 2 children (4 grandchildren)
+     * Result: `totalChildrenCount: 6` (2 + 4)
+     *
+     * @remarks
+     * - Optional - typically used for analytics
+     * - Includes all nested levels (recursive)
+     * - Can be expensive to calculate for large trees
+     */
+    totalChildrenCount?: number;
+    /**
+     * Recursive count of all items in this category and all descendants
+     *
+     * Represents the total number of items (e.g., reports, activities, workflows) in the entire
+     * category tree, including items from this category and all nested child categories.
+     *
+     * Useful for:
+     * - Analytics and summary displays
+     * - Showing complete scope of a category branch
+     * - Dashboard statistics
+     *
+     * @example
+     * Category with:
+     * - 5 items directly assigned
+     * - 1 child category with 3 items
+     * Result: `totalItemsCount: 8` (5 + 3)
+     *
+     * @remarks
+     * - Optional - typically used for analytics
+     * - Includes items from all nested categories (recursive)
+     * - Can be expensive to calculate for large trees
+     */
+    totalItemsCount?: number;
 }
 interface AXPCategoryEntityWithItems<T> extends AXPCategoryEntity {
     items: T[];
     children?: AXPCategoryEntityWithItems<T>[];
 }
+/**
+ * Denormalized category row on entities and DTOs (id + localized display title).
+ * Use for `categories` arrays expanded from {@link AXPCategoryEntity} assignments.
+ */
+interface AXPCategoryListItem<TKey extends string = string> {
+    id: TKey;
+    title: AXPMultiLanguageString;
+}
 interface AXPCategorizedEntity {
     categoryIds: string[];
 }
 interface AXPCategorizedEntityDto {
     categoryIds: string[];
-    categories: {
-        id: string;
-        title: string;
-    }[];
+    categories: AXPCategoryListItem[];
 }
+type AXPEntityOp = 'initial' | 'create' | 'update' | 'delete' | 'getOne' | 'getAll' | 'query' | 'count' | 'queryAll' | 'getMany' | 'exists' | 'upsertOne' | 'aggregate';
 
 type AXPWidgetTrigger = {
     event: string;
@@ -1002,8 +1145,25 @@ interface AXPFileListItem {
     size?: number;
     status: AXPFileStatus;
     source?: AXPFileSource;
+    meta?: AXPMetaData;
+    /**
+     * When true, the item cannot be renamed, removed, or reverted from the UI.
+     * Independent of widget `options.readonly` (widget-level disables all edits); use this for per-row locks from the server.
+     */
+    readOnly?: boolean;
+    title?: string;
+    description?: string;
 }
 
+/**
+ * Filter toolbar trigger entries (same shape as entity `schema.interface.triggers`).
+ * Declared on `AXPFilterDefinition` and populated when building list filter definitions.
+ */
+interface AXPFilterTriggerDefinition {
+    event: string;
+    action: string;
+    disabled?: boolean;
+}
 interface AXPFilterClause extends AXDataSourceFilterOption {
     id?: string;
     order?: number;
@@ -1020,33 +1180,131 @@ interface AXPFilterDefinition extends AXPFilterClause {
     filterType: {
         advance: boolean;
         inline: boolean;
+        preload?: {
+            enabled?: boolean;
+            required?: boolean;
+        };
     };
     hidden?: boolean;
+    /**
+     * When true, the filter is not selectable. When a string, it is evaluated as an expression (e.g. `{{ ... }}`)
+     * using the current filters context.
+     */
+    disabled?: boolean | string;
+    /** Expression-driven triggers (events/actions); same semantics as entity `schema.interface.triggers`. */
+    triggers?: AXPFilterTriggerDefinition[];
 }
 interface AXPFilterQuery extends Pick<AXPFilterDefinition, 'field' | 'value' | 'operator' | 'logic' | 'hidden'> {
     filters?: AXPFilterQuery[];
     displayText?: string;
 }
 
+/**
+ * Normalized keyboard chord (e.g. `ctrl+f`, `arrowleft`, `f1`).
+ * Modifiers and key are joined with `+`.
+ */
+type AXPKeyboardShortcutChord = string;
+/** Priority tier — higher values win when multiple bindings match. */
+declare enum AXPKeyboardShortcutPriority {
+    Global = 0,
+    Page = 10,
+    Panel = 20,
+    Modal = 100
+}
+/**
+ * How horizontal directional keys behave in RTL locale profiles (`activeProfile().i18nMeta?.rtl`).
+ * - `physical`: arrow left always means left (grid navigation, etc.).
+ * - `semantic`: arrows and `[` / `]` mirror so next/previous follow reading direction.
+ */
+type AXPKeyboardShortcutDirectionBehavior = 'physical' | 'semantic';
+interface AXPKeyboardShortcutBinding {
+    /**
+     * One or more key chords that trigger this action.
+     * Example: `['arrowleft', 'pageup']` or `['ctrl+f']`.
+     */
+    keys: AXPKeyboardShortcutChord[];
+    /** i18n key (e.g. `@general:...`) or plain label for the help dialog. */
+    title: string;
+    /** Optional group label (i18n key or plain) for help dialog grouping. */
+    group?: string;
+    /** When true, fires even if focus is inside an editable field. Default false. */
+    allowInEditableFields?: boolean;
+    /** Optional runtime guard — binding is ignored when this returns false. */
+    when?: () => boolean;
+    /**
+     * RTL handling for horizontal direction keys (`←`/`→`, `[`/`]`).
+     * Omitted = auto (`semantic` for direction keys, `physical` otherwise). Set `physical` to opt out.
+     */
+    directionBehavior?: AXPKeyboardShortcutDirectionBehavior;
+    handler: (event: KeyboardEvent) => void | Promise<void>;
+}
+/**
+ * Declarative shortcut for menus, action items, and other config-driven bindings.
+ * Use a chord string for defaults, or an object to override binding options (e.g. `allowInEditableFields`).
+ */
+type AXPKeyboardShortcutConfig = Pick<AXPKeyboardShortcutBinding, 'allowInEditableFields' | 'when' | 'directionBehavior'> & {
+    keys: AXPKeyboardShortcutChord | readonly AXPKeyboardShortcutChord[];
+};
+type AXPKeyboardShortcut = AXPKeyboardShortcutChord | AXPKeyboardShortcutConfig;
+/** Normalized declarative shortcut used when registering keyboard bindings. */
+interface AXPResolvedKeyboardShortcut {
+    keys: AXPKeyboardShortcutChord[];
+    allowInEditableFields?: boolean;
+    when?: () => boolean;
+    directionBehavior?: AXPKeyboardShortcutDirectionBehavior;
+}
+interface AXPKeyboardShortcutRegistration {
+    /** Stable id for this registration scope (e.g. `task-board-navigator`). */
+    id: string;
+    /** Higher priority bindings win on conflict. */
+    priority?: AXPKeyboardShortcutPriority | number;
+    /** Scope label shown in the help dialog (i18n key or plain). */
+    scope?: string;
+    /** Default group for bindings without their own `group`. */
+    group?: string;
+    /** Optional runtime guard — registration is ignored when this returns false. */
+    when?: () => boolean;
+    shortcuts: AXPKeyboardShortcutBinding[];
+}
+/** Resolved entry for help UI. */
+interface AXPKeyboardShortcutHelpEntry {
+    registrationId: string;
+    bindingTitle: string;
+    /** Raw chords for `ax-kbd-item` rendering (canonical registration). */
+    chords: AXPKeyboardShortcutChord[];
+    /** Chords adjusted for RTL display when `directionBehavior` is `semantic`. */
+    displayChords: AXPKeyboardShortcutChord[];
+    displayKeys: string;
+    scope?: string;
+    group?: string;
+    priority: number;
+}
+
 type AXPActionMenuItem = {
     name?: string;
-    title: string;
+    title: AXPMultiLanguageString;
     icon?: string;
     iconOnly?: boolean;
     color?: string;
+    look?: AXStyleLookType;
     break?: boolean;
     items?: AXPActionMenuItem[];
     command?: AXPExecuteCommand;
     disabled?: boolean | string;
     visible?: boolean | string;
     policy?: string;
+    /**
+     * Keyboard shortcuts for this action.
+     * Use a chord string or `{ keys, allowInEditableFields, ... }`. Pass `[]` to disable.
+     */
+    shortcuts?: AXPKeyboardShortcut[];
 };
 type AXPBackButton = {
-    title: string;
+    title: AXPMultiLanguageString;
 };
 type AXPBreadcrumbItem = {
     name?: string;
-    title: string;
+    title: AXPMultiLanguageString;
     icon?: string;
     command?: AXPExecuteCommand;
 };
@@ -1055,10 +1313,16 @@ type AXPBadge = {
     description?: string;
     color?: 'primary' | 'success' | 'warning' | 'danger';
 };
+type AXPPageStatus = {
+    definitionKey: string;
+    value: string;
+    dataPath?: string;
+    readonly?: boolean;
+};
 interface AXPCommandMessage {
     type?: 'info' | 'success' | 'warning' | 'error';
     code?: string;
-    text: string;
+    text: AXPMultiLanguageString;
     details?: unknown;
 }
 type AXPExecuteCommand = {
@@ -1080,7 +1344,7 @@ interface AXPQueryFetchResult<T = any> {
     };
     message?: {
         code?: string;
-        text?: string;
+        text?: AXPMultiLanguageString;
         details?: any;
     };
 }
@@ -1093,7 +1357,7 @@ type AXPNavigateActionOptions = {
     };
     modal: {
         component: Type<any>;
-        title: string;
+        title: AXPMultiLanguageString;
         options?: any;
     };
 };
@@ -1145,25 +1409,6 @@ declare class AXPIconLogoConfig implements AXPLogoConfig {
     constructor(icon: string, color?: string | undefined);
 }
 
-type AXPPlatformScopeKey = 'C' | 'G' | 'P' | 'T' | 'U';
-declare enum AXPPlatformScope {
-    Environment = "C",
-    Global = "G",
-    Platform = "P",
-    Tenant = "T",
-    User = "U"
-}
-declare function resolvePlatformScopeKey(name: string): AXPPlatformScopeKey;
-declare function resolvePlatformScopeName(scope: AXPPlatformScopeKey): string;
-
-interface AXPSortDefinition {
-    name: string;
-    title: string;
-    dir?: 'asc' | 'desc';
-}
-interface AXPSortQuery extends Pick<AXPSortDefinition, 'name' | 'dir'> {
-}
-
 type AXPValidationRule = {
     rule: string;
     message?: string;
@@ -1200,6 +1445,52 @@ interface AXPReqexValidationRule extends AXPValidationRule {
 }
 type AXPStringValidationRules = (AXPRequiredValidationRule | AXPMinLengthValidationRule | AXPMaxLengthValidationRule | AXPEqualValidationRule<string> | AXPReqexValidationRule)[];
 
+interface AXPPropertyGroup {
+    name: string;
+    title: AXPMultiLanguageString;
+    icon?: string;
+    description?: AXPMultiLanguageString;
+    order?: number;
+}
+interface AXPPropertyInterface {
+    type: string;
+    options: AXPOptionsData;
+    triggers?: AXPWidgetTriggers;
+}
+/**
+ * Platform property bag (entity fields, workflow inputs, etc.).
+ *
+ * For property viewer rows, use `mapAXPPropertyToWidgetProperty` from `@acorex/platform/layout/widget-core`
+ * (keeps `platform/core` free of a dependency on `layout/widget-core`).
+ */
+interface AXPProperty {
+    name: string;
+    title: AXPMultiLanguageString;
+    description?: AXPMultiLanguageString;
+    dataType: AXPDataType;
+    validations?: AXPValidationRules;
+    group?: AXPPropertyGroup | string;
+    order?: number;
+    interface: AXPPropertyInterface;
+}
+
+type AXPPlatformScopeKey = 'P' | 'T' | 'U';
+declare enum AXPPlatformScope {
+    Platform = "P",
+    Tenant = "T",
+    User = "U"
+}
+declare function resolvePlatformScopeKey(name: string): AXPPlatformScopeKey;
+declare function resolvePlatformScopeName(scope: AXPPlatformScopeKey): string;
+
+interface AXPSortDefinition {
+    name: string;
+    title: string;
+    dir?: 'asc' | 'desc';
+}
+interface AXPSortQuery extends Pick<AXPSortDefinition, 'name' | 'dir'> {
+}
+
 interface AXPViewQuery {
     name: string;
     fixed: boolean;
@@ -1319,6 +1610,18 @@ interface AXPMiddlewareErrorResponse {
 interface AXPActivityLogChange {
     type: AXPSystemActionType;
     description: string;
+    /** I18n key for field label. When set with actionKey, used for translated display. */
+    fieldKey?: string;
+    /** Params for fieldKey translation (e.g. for unknown-field with {{name}}). */
+    fieldKeyParams?: Record<string, string>;
+    /** I18n key for action (e.g. @activity-log:changes.replaced). When set with fieldKey, overrides description. */
+    actionKey?: string;
+    oldValue?: unknown;
+    newValue?: unknown;
+    /** Short human-readable summary for Change History (e.g. "Updated from 'X' to 'Y'"). Used when layout is present. */
+    summary?: string;
+    /** Custom layout (AXPWidgetNode) for Change History. When set, rendered via AXPLayoutRenderer instead of default fieldKey/actionKey text. */
+    layout?: unknown;
 }
 interface AXPActivityLog {
     id: string;
@@ -1355,6 +1658,102 @@ declare class AXPActivityLogService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPActivityLogService>;
 }
 
+/**
+ * Stable catalog scope registered by a module provider (integration contract).
+ */
+interface AXPCatalogScopeDefinition {
+    /** Unique key, e.g. `human-capital-management.hr`. */
+    name: string;
+    title: string | AXPMultiLanguageString;
+    description?: string | AXPMultiLanguageString;
+    /**
+     * Entity refs this scope may label, e.g. `AssessmentManagement.Questionnaire`.
+     */
+    targets: string[];
+    icon?: string;
+    /**
+     * Platform utility classes applied to the whole scope badge (surface, on-surface, border).
+     * Example: `ax-primary-surface ax-text-on-primary-surface ax-border-border-primary-surface`.
+     */
+    cssClass?: string;
+    order?: number;
+}
+
+interface AXPCatalogScopeDefinitionProvider {
+    items(): Promise<AXPCatalogScopeDefinition[]>;
+}
+declare const AXP_CATALOG_SCOPE_DEFINITION_PROVIDER: InjectionToken<AXPCatalogScopeDefinitionProvider[]>;
+
+/**
+ * Collects {@link AXPCatalogScopeDefinition} entries from all registered providers.
+ */
+declare class AXPCatalogScopeDefinitionProviderService {
+    private readonly providers;
+    private readonly translation;
+    items(): Promise<AXPCatalogScopeDefinition[]>;
+    get(name: string): Promise<AXPCatalogScopeDefinition | undefined>;
+    /**
+     * Scopes applicable to the given entity ref (`Module.Entity`).
+     */
+    byTarget(entityRef: string): Promise<AXPCatalogScopeDefinition[]>;
+    /**
+     * Resolves display title for a scope key (active locale).
+     */
+    resolveTitle(definition: AXPCatalogScopeDefinition): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCatalogScopeDefinitionProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPCatalogScopeDefinitionProviderService>;
+}
+
+interface AXPDataSourceDataFieldDefinition {
+    name: string;
+    title: string;
+    datatype: string;
+    type: string;
+    options?: AXPOptionsData;
+}
+type AXPLazyDataSource<T = unknown> = AXPMaybePromise<AXDataSource<T>>;
+type AXPDataSourceArray<T = unknown> = AXPMaybePromise<Array<T>>;
+type AXPDataSourceValue<T = unknown> = AXPMaybePromise<T>;
+type AXPDataSourceType<T = any> = AXPLazyDataSource<T> | AXPDataSourceArray<T> | AXPDataSourceValue<T>;
+type AXPDataSourceSample<T = any> = AXPDataSourceArray<T> | AXPDataSourceValue<T>;
+interface AXPDataSourceDefinition<T = any> {
+    name: string;
+    title: string;
+    valueField?: {
+        name: string;
+        title: string;
+    };
+    textField?: {
+        name: string;
+        title: string;
+    };
+    columns: AXPDataSourceDataFieldDefinition[];
+    filters: AXPFilterDefinition[];
+    samples?: AXPDataSourceSample<T>;
+    visible?: boolean;
+    source: () => AXPDataSourceType<T>;
+}
+interface AXPDataSourceDefinitionProvider {
+    items(): Promise<AXPDataSourceDefinition[]>;
+}
+declare const AXP_DATASOURCE_DEFINITION_PROVIDER: InjectionToken<AXPDataSourceDefinitionProvider[]>;
+declare class AXPDataSourceDefinitionProviderService implements AXPDataSourceDefinitionProvider {
+    private providers;
+    items(): Promise<AXPDataSourceDefinition[]>;
+    get<T = any>(name: string): Promise<AXPDataSourceDefinition<T> | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDataSourceDefinitionProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPDataSourceDefinitionProviderService>;
+}
+
+/**
+ * Registered catalog scopes for select / selection-list widgets via {@link AXPPlatformCoreDataSourceKeys.CatalogScopes}.
+ */
+declare class AXPCatalogScopeDefinitionsDataSourceDefinition implements AXPDataSourceDefinitionProvider {
+    private readonly catalogScopeRegistry;
+    items(): Promise<AXPDataSourceDefinition[]>;
+    private readTargetFilter;
+}
+
 /**
  * Represents a color palette with a unique identifier and collection of colors
  */
@@ -1472,7 +1871,182 @@ declare class AXPDefaultColorPalettesProvider extends AXPColorPaletteProvider {
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPDefaultColorPalettesProvider>;
 }
 
+/**
+ * Column width value can be a number (converted to pixels) or a string with any CSS unit
+ * @example 150 (becomes '150px'), '300px', '50%', '2rem', '20ch'
+ */
+type ColumnWidthValue = string | number;
+/**
+ * Matcher for column name - can be exact string match or RegExp pattern
+ * @example 'title', /^user/, /.*name$/i
+ */
+type ColumnNameMatcher = string | RegExp;
+/**
+ * Matcher for widget type - can be exact string match or RegExp pattern (case-insensitive)
+ * @example 'text-box', /^date/, /.*editor$/i
+ */
+type WidgetTypeMatcher = string | RegExp;
+/**
+ * Defines a single width matching rule
+ */
+interface AXPColumnWidthMatcher {
+    /**
+     * Match by column name (exact string or RegExp pattern)
+     * Takes precedence over widgetType matching
+     * @example 'title', /^user/, /.*name$/i
+     */
+    name?: ColumnNameMatcher;
+    /**
+     * Match by widget type (exact string or RegExp pattern, case-insensitive)
+     * Used as fallback when name doesn't match
+     * @example 'text-box', /^date/, /.*editor$/i
+     */
+    widgetType?: WidgetTypeMatcher;
+    /**
+     * Width value to apply if this matcher matches
+     * Numbers are converted to pixels (e.g., 150 -> '150px')
+     * Strings can include any CSS unit (e.g., '300px', '50%', '2rem')
+     */
+    width: ColumnWidthValue;
+    /**
+     * Priority for this matcher within the provider (higher = more specific, applied first)
+     * Default: 0
+     */
+    priority?: number;
+}
+/**
+ * Provider configuration for column width rules
+ */
+interface AXPColumnWidthProvider {
+    /**
+     * Array of matchers to evaluate
+     * Evaluated in priority order (highest first), then by match type (name before widgetType)
+     */
+    matchers: AXPColumnWidthMatcher[];
+    /**
+     * Priority for this provider relative to other providers (higher = applied first)
+     * Default: 100
+     */
+    priority?: number;
+}
+/**
+ * Generic column interface for width resolution
+ * Works with any column type that has these properties
+ */
+interface IColumnWithWidth {
+    /**
+     * Column name
+     */
+    name: string;
+    /**
+     * Current width (if already set)
+     */
+    width?: string;
+    /**
+     * Widget type information (optional)
+     */
+    widget?: {
+        type: string;
+    };
+    /**
+     * Additional options that might contain width
+     */
+    options?: {
+        width?: string;
+    };
+    /**
+     * For entity columns - showAs configuration
+     */
+    showAs?: {
+        type: string;
+    };
+}
+
+/**
+ * Service for resolving column widths based on registered providers
+ * Supports matching by column name (priority) and widget type (fallback)
+ * Uses multi-provider pattern for extensibility
+ */
+declare class AXPColumnWidthService {
+    private readonly providers;
+    /**
+     * Resolve width for a column based on registered providers
+     * Only returns a width if column doesn't already have one set
+     *
+     * @param column Column to resolve width for
+     * @returns Resolved width string (normalized) or undefined if no match or column already has width
+     */
+    resolveWidth(column: IColumnWithWidth): string | undefined;
+    /**
+     * Apply resolved width to a column (mutates the column)
+     * Only applies if column doesn't already have a width
+     *
+     * @param column Column to apply width to
+     * @returns true if width was applied, false if column already had width or no match found
+     */
+    applyWidth(column: IColumnWithWidth): boolean;
+    /**
+     * Collect all matchers from all providers, sorted by provider priority and matcher priority
+     */
+    private collectMatchers;
+    /**
+     * Find first matching matcher by column name
+     * Name matches take precedence over widget type matches
+     */
+    private findNameMatch;
+    /**
+     * Find first matching matcher by widget type (case-insensitive)
+     */
+    private findWidgetTypeMatch;
+    /**
+     * Normalize width value to string format
+     * Numbers are converted to pixels (e.g., 150 -> '150px')
+     * Strings are preserved as-is (supports any CSS unit)
+     */
+    private normalizeWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPColumnWidthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPColumnWidthService>;
+}
+
+/**
+ * Injection token for column width providers
+ * Use this to register multiple column width providers with multi: true
+ *
+ * @example
+ * ```typescript
+ * providers: [
+ *   {
+ *     provide: AXP_COLUMN_WIDTH_PROVIDER,
+ *     useValue: {
+ *       matchers: [
+ *         { name: 'title', width: '300px', priority: 10 },
+ *         { widgetType: /text-box/i, width: '200px' }
+ *       ],
+ *       priority: 150
+ *     },
+ *     multi: true
+ *   }
+ * ]
+ * ```
+ */
+declare const AXP_COLUMN_WIDTH_PROVIDER: InjectionToken<AXPColumnWidthProvider[]>;
+
+/**
+ * Default column width configuration
+ * Migrated from DEFAULT_COLUMN_WIDTHS in column-width.middleware.ts
+ * Provides sensible defaults for common column names
+ */
+declare const defaultColumnWidthProvider: AXPColumnWidthProvider;
+
 type AXPContextState = 'initiated' | 'restored' | 'changed' | 'patch';
+type AXPContextUpdateOrigin = 'user' | 'system';
+interface AXPContextUpdateOptions {
+    origin?: AXPContextUpdateOrigin;
+}
+interface AXPContextPatchOptions {
+    /** When true, updates the saved snapshot together with live data. */
+    updateSaved?: boolean;
+}
 type AXPContextData = {
     [key: string]: any;
 };
@@ -1482,35 +2056,201 @@ declare class AXPContextChangeEvent {
     path?: string;
     state: AXPContextState;
     data: any;
+    origin?: AXPContextUpdateOrigin;
+    /** Aggregated form dirty flag (context snapshot + composite widget dirty). */
+    isFormDirty?: boolean;
 }
 declare const AXPContextStore: i0.Type<{
     data: i0.Signal<AXPContextData>;
     state: i0.Signal<AXPContextState>;
-    initialSnapshot: i0.Signal<{}>;
-    previousSnapshot: i0.Signal<{}>;
+    savedSnapshot: i0.Signal<AXPContextData>;
+    previousSnapshot: i0.Signal<AXPContextData>;
     lastChange: _ngrx_signals.DeepSignal<AXPContextChangeEvent>;
     isChanged: i0.Signal<boolean>;
     isReset: i0.Signal<boolean>;
     isInitiated: i0.Signal<boolean>;
     isEmpty: i0.Signal<boolean>;
+    isSavedCommitted: i0.Signal<boolean>;
     isDirty: i0.Signal<boolean>;
     snapshot: i0.Signal<AXPContextData>;
-    initial: i0.Signal<{}>;
-    previous: i0.Signal<{}>;
+    saved: i0.Signal<AXPContextData>;
+    initial: i0.Signal<AXPContextData>;
+    previous: i0.Signal<AXPContextData>;
     changeEvent: i0.Signal<AXPContextChangeEvent>;
-    update: (path: string, value: any) => void;
-    patch: (context: {}) => void;
+    update: (path: string, value: any, options?: AXPContextUpdateOptions) => void;
+    applyObjectPaths: (obj: Record<string, unknown>, options?: AXPContextUpdateOptions, prefix?: string) => void;
+    patch: (context: Record<string, any>, options?: AXPContextPatchOptions) => void;
+    revertToSaved: () => void;
     reset: () => void;
     set: (initialData: any) => void;
     getValue: (path: string) => any;
+    getSavedValue: (path: string) => any;
+    hasValue: (path: string) => boolean;
+    commitSaved: () => void;
+    applyParentBind: (merged: AXPContextData) => void;
 } & _ngrx_signals.StateSource<{
     data: AXPContextData;
     state: AXPContextState;
-    initialSnapshot: {};
-    previousSnapshot: {};
+    savedSnapshot: AXPContextData;
+    previousSnapshot: AXPContextData;
     lastChange: AXPContextChangeEvent;
 }>>;
 
+interface AXPComponentSlotConfig {
+    name: string;
+    priority?: number;
+    component?: Type<any>;
+    condition?: ((context?: AXPContextData) => boolean | Promise<boolean>) | string;
+    features?: string[];
+    loadComponent?: () => Type<any> | Promise<Type<any>>;
+    options?: AXPOptionsData | (() => AXPOptionsData) | (() => Promise<AXPOptionsData>);
+}
+interface AXPComponentSlotModuleConfigs {
+    [slotName: string]: AXPComponentSlotConfig[];
+}
+declare abstract class AXPComponentSlot {
+    host: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlot, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPComponentSlot, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class AXPComponentSlotDirective implements OnInit {
+    name: i0.InputSignal<string>;
+    host: i0.InputSignal<any>;
+    context: i0.InputSignal<any>;
+    private elementRef;
+    private registryService;
+    private injector;
+    private evaluator;
+    viewContainerRef: ViewContainerRef;
+    contextStore: {
+        data: i0.Signal<AXPContextData>;
+        state: i0.Signal<_acorex_platform_core.AXPContextState>;
+        savedSnapshot: i0.Signal<AXPContextData>;
+        previousSnapshot: i0.Signal<AXPContextData>;
+        lastChange: _ngrx_signals.DeepSignal<_acorex_platform_core.AXPContextChangeEvent>;
+        isChanged: i0.Signal<boolean>;
+        isReset: i0.Signal<boolean>;
+        isInitiated: i0.Signal<boolean>;
+        isEmpty: i0.Signal<boolean>;
+        isSavedCommitted: i0.Signal<boolean>;
+        isDirty: i0.Signal<boolean>;
+        snapshot: i0.Signal<AXPContextData>;
+        saved: i0.Signal<AXPContextData>;
+        initial: i0.Signal<AXPContextData>;
+        previous: i0.Signal<AXPContextData>;
+        changeEvent: i0.Signal<_acorex_platform_core.AXPContextChangeEvent>;
+        update: (path: string, value: any, options?: _acorex_platform_core.AXPContextUpdateOptions) => void;
+        applyObjectPaths: (obj: Record<string, unknown>, options?: _acorex_platform_core.AXPContextUpdateOptions, prefix?: string) => void;
+        patch: (context: Record<string, any>, options?: _acorex_platform_core.AXPContextPatchOptions) => void;
+        revertToSaved: () => void;
+        reset: () => void;
+        set: (initialData: any) => void;
+        getValue: (path: string) => any;
+        getSavedValue: (path: string) => any;
+        hasValue: (path: string) => boolean;
+        commitSaved: () => void;
+        applyParentBind: (merged: AXPContextData) => void;
+    } & _ngrx_signals.StateSource<{
+        data: AXPContextData;
+        state: _acorex_platform_core.AXPContextState;
+        savedSnapshot: AXPContextData;
+        previousSnapshot: AXPContextData;
+        lastChange: _acorex_platform_core.AXPContextChangeEvent;
+    }>;
+    isEmpty: i0.Signal<boolean>;
+    private _viewCount;
+    private componentRefs;
+    private placeholderRefs;
+    constructor();
+    ngOnInit(): Promise<void>;
+    loadComponents(): Promise<void>;
+    private evaluateCondition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlotDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPComponentSlotDirective, "axp-component-slot", ["slot"], { "name": { "alias": "name"; "required": true; "isSignal": true; }; "host": { "alias": "host"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class AXPComponentSlotRegistryService {
+    private registry;
+    register(slotName: string, config: AXPComponentSlotConfig): void;
+    get(slotName: string): AXPComponentSlotConfig[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlotRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPComponentSlotRegistryService>;
+}
+
+declare class AXPComponentSlotModule {
+    static forRoot(configs?: AXPComponentSlotModuleConfigs): ModuleWithProviders<AXPComponentSlotModule>;
+    static forChild(configs?: AXPComponentSlotModuleConfigs): ModuleWithProviders<AXPComponentSlotModule>;
+    /**
+     * @ignore
+     */
+    constructor(instances: any[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlotModule, [{ optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPComponentSlotModule, [typeof AXPComponentSlotDirective], never, [typeof AXPComponentSlotDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPComponentSlotModule>;
+}
+
+/**
+ * Compact hints for assembling platform context into LLM system prompts.
+ * Mirrors fields used by {@link AXPAiPlatformRuntimeContext} and the mock engine runtime prompt
+ * formatter — keep labels short and values bounded.
+ */
+interface AXPContextDefinitionAiHints {
+    /**
+     * Short English label for bullet lists (e.g. `UI locale`, `Current instant (UTC, ISO 8601)`).
+     */
+    promptLabel?: string;
+    /**
+     * One-line guidance for the model (when to use this value, what not to ask the user).
+     */
+    usageHint?: string;
+    /**
+     * When `false`, this definition is omitted from AI system-prompt assembly. Default `true`.
+     */
+    includeInSystemPrompt?: boolean;
+    /**
+     * How to stringify the value compactly in prompts.
+     */
+    valueKind?: 'string' | 'number' | 'boolean' | 'instant' | 'locale' | 'dateTime' | 'object';
+    /**
+     * When `true`, the value must not be sent to the model (PII, secrets, tokens).
+     */
+    sensitive?: boolean;
+    /**
+     * Sort order when rendering the AI context block (lower first).
+     */
+    order?: number;
+}
+/**
+ * Describes a named platform context key (e.g. `currentDate`, `language`).
+ */
+interface AXPContextDefinition {
+    /** Stable identifier used as the context key and in expressions. */
+    name: string;
+    /** Human-readable title for designers and tooling. */
+    title: string;
+    /** What this context represents and when consumers should use it. */
+    description: string;
+    /** Optional metadata for AI system-prompt assembly. */
+    ai?: AXPContextDefinitionAiHints;
+}
+
+interface AXPContextDefinitionProvider {
+    items(): Promise<AXPContextDefinition[]>;
+}
+declare const AXP_CONTEXT_DEFINITION_PROVIDER: InjectionToken<AXPContextDefinitionProvider[]>;
+
+/**
+ * Collects {@link AXPContextDefinition} entries from all registered {@link AXPContextDefinitionProvider} instances.
+ */
+declare class AXPContextDefinitionProviderService implements AXPContextDefinitionProvider {
+    private readonly providers;
+    items(): Promise<AXPContextDefinition[]>;
+    get(name: string): Promise<AXPContextDefinition | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPContextDefinitionProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPContextDefinitionProviderService>;
+}
+
 declare class AXPDataGenerator {
     static uuid(): string;
     static number(max: number): number;
@@ -1547,40 +2287,22 @@ type AXPValueTransformerFunctions = {
 };
 declare function objectKeyValueTransforms(keyName: string): AXPValueTransformerFunctions;
 
-interface AXPDataSourceDataFieldDefinition {
-    name: string;
-    title: string;
-    datatype: string;
-    type: string;
-    options?: AXPOptionsData;
-}
-interface AXPDataSourceDefinition<T = any> {
-    name: string;
-    title: string;
-    valueField?: {
-        name: string;
-        title: string;
-    };
-    textField?: {
-        name: string;
-        title: string;
-    };
-    columns: AXPDataSourceDataFieldDefinition[];
-    filters: AXPFilterDefinition[];
-    samples?: any[];
-    visible?: boolean;
-    source: () => AXDataSource<T> | Promise<AXDataSource<T>>;
-}
-interface AXPDataSourceDefinitionProvider {
-    items(): Promise<AXPDataSourceDefinition[]>;
+declare class AXPContentCheckerDirective {
+    viewContainerRef: ViewContainerRef;
+    elementRef: ElementRef<HTMLDivElement>;
+    isEmpty: i0.Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPContentCheckerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPContentCheckerDirective, "[axp-content-checker]", ["checker"], {}, {}, never, never, true, never>;
 }
-declare const AXP_DATASOURCE_DEFINITION_PROVIDER: InjectionToken<AXPDataSourceDefinitionProvider[]>;
-declare class AXPDataSourceDefinitionProviderService implements AXPDataSourceDefinitionProvider {
-    private providers;
-    items(): Promise<AXPDataSourceDefinition[]>;
-    get(name: string): Promise<AXPDataSourceDefinition | undefined>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDataSourceDefinitionProviderService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AXPDataSourceDefinitionProviderService>;
+
+declare class AXPDblClickDirective {
+    onDblClick: EventEmitter<Event>;
+    private lastTap;
+    private readonly doubleTapThreshold;
+    handleOnDblClick(event: Event): void;
+    onTouchEnd(event: TouchEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDblClickDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPDblClickDirective, "[onDblClick]", never, {}, { "onDblClick": "onDblClick"; }, never, never, true, never>;
 }
 
 declare class AXPElementDataDirective implements OnInit {
@@ -1602,16 +2324,6 @@ declare class AXPElementDataDirective implements OnInit {
     static ɵdir: i0.ɵɵDirectiveDeclaration<AXPElementDataDirective, "[axp-data]", never, { "data": { "alias": "axp-data"; "required": false; "isSignal": true; }; "path": { "alias": "axp-data-path"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class AXPDblClickDirective {
-    onDblClick: EventEmitter<Event>;
-    private lastTap;
-    private readonly doubleTapThreshold;
-    handleOnDblClick(event: Event): void;
-    onTouchEnd(event: TouchEvent): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDblClickDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPDblClickDirective, "[onDblClick]", never, {}, { "onDblClick": "onDblClick"; }, never, never, true, never>;
-}
-
 declare class AXPGridLayoutDirective implements OnChanges {
     private el;
     private renderer;
@@ -1625,77 +2337,6 @@ declare class AXPGridLayoutDirective implements OnChanges {
     static ɵdir: i0.ɵɵDirectiveDeclaration<AXPGridLayoutDirective, "[axp-grid-layout]", never, { "options": { "alias": "axp-grid-layout"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class AXPContentCheckerDirective {
-    viewContainerRef: ViewContainerRef;
-    elementRef: ElementRef<HTMLDivElement>;
-    isEmpty: i0.Signal<boolean>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXPContentCheckerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPContentCheckerDirective, "[axp-content-checker]", ["checker"], {}, {}, never, never, true, never>;
-}
-
-/**
- * Fullscreen directive that provides CSS-based fullscreen functionality
- * Usage: <element axFullscreen #fullscreen="axFullscreen"></element>
- * Then: fullscreen.toggle() or fullscreen.enter() or fullscreen.exit()
- */
-declare class AXFullscreenDirective implements OnDestroy {
-    private elementRef;
-    /**
-     * Current fullscreen state
-     */
-    private readonly isFullscreenState;
-    /**
-     * Original element styles to restore
-     */
-    private originalStyles;
-    /**
-     * Original parent element reference
-     */
-    private originalParent;
-    /**
-     * Fullscreen container element
-     */
-    private fullscreenContainer;
-    /**
-     * Fullscreen change event
-     */
-    readonly fullscreenChange: i0.OutputEmitterRef<boolean>;
-    private readonly destroyRef;
-    private readonly renderer;
-    constructor(elementRef: ElementRef<HTMLElement>);
-    /**
-     * Toggle fullscreen state
-     */
-    toggle(): Promise<void>;
-    /**
-     * Enter fullscreen mode using CSS
-     */
-    enter(): Promise<void>;
-    /**
-     * Exit fullscreen mode
-     */
-    exit(): Promise<void>;
-    /**
-     * Check if currently in fullscreen mode
-     */
-    isFullscreen(): boolean;
-    /**
-     * Store original element styles
-     */
-    private storeOriginalStyles;
-    /**
-     * Restore original element styles
-     */
-    private restoreOriginalStyles;
-    /**
-     * Convert camelCase to kebab-case for CSS properties
-     */
-    private camelToKebabCase;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXFullscreenDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXFullscreenDirective, "[axFullscreen]", ["axFullscreen"], {}, { "fullscreenChange": "fullscreenChange"; }, never, never, true, never>;
-}
-
 type AXPDistributedEventListenerProviderToken<T> = AXPDistributedEventListenerProvider<T> | Promise<AXPDistributedEventListenerProvider<T>>;
 declare const AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER: InjectionToken<AXPDistributedEventListenerProviderToken<any>[]>;
 interface AXPDistributedEventListenerProvider<TInput = any, TOutput = void> {
@@ -1822,7 +2463,7 @@ declare class AXPExpressionEvaluatorScopeProviderContext {
 type AXPExpressionEvaluatorScopeProviders = AXPExpressionEvaluatorScopeProvider[] | (() => AXPExpressionEvaluatorScopeProvider[]);
 declare const AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER: InjectionToken<AXPExpressionEvaluatorScopeProviders>;
 declare class AXPExpressionEvaluatorScopeProviderService {
-    private providers;
+    private readonly injector;
     private cache;
     private load;
     getScopesAsync(): Promise<AXPExpressionEvaluatorScope>;
@@ -1853,6 +2494,142 @@ declare class AXPHookService {
     static ɵprov: i0.ɵɵInjectableDeclaration<AXPHookService>;
 }
 
+/** Acorex overlay root (modal shell, popup, dialog). */
+declare const AX_OVERLAY_CONTAINER_SELECTOR = ".ax-overlay-container";
+/** Anchored widget panel inside an overlay (select, date picker, dropdown). */
+declare const AX_OVERLAY_PANE_SELECTOR = ".ax-overlay-pane";
+/**
+ * True when a visible overlay layer is foreground (modal, popup, widget popover/picker).
+ */
+declare function hasForegroundOverlayLayer(document: Document): boolean;
+/**
+ * Returns visible anchored overlay panes (widget popovers/pickers).
+ */
+declare function getVisibleAnchoredOverlayPanes(document: Document): HTMLElement[];
+/**
+ * Visible anchored panes that are not contained by `excludeContainer` (e.g. dialog shell).
+ */
+declare function getNestedVisibleOverlayPanes(document: Document, excludeContainer: HTMLElement | null): HTMLElement[];
+/**
+ * Collects visible overlay containers in stacking order (later / higher z-index wins).
+ */
+declare function getVisibleOverlayContainers(document: Document): HTMLElement[];
+/** Topmost visible overlay container, if any. */
+declare function getTopVisibleOverlayContainer(document: Document): HTMLElement | null;
+/** Nearest overlay container ancestor of `element`. */
+declare function findOverlayContainerAncestor(element: HTMLElement): HTMLElement | null;
+/**
+ * Returns true when the overlay element is rendered and visible in the viewport.
+ */
+declare function isVisibleOverlayElement(element: Element): boolean;
+
+interface AXPKeyboardShortcutFormatOptions {
+    directionBehavior?: AXPKeyboardShortcutDirectionBehavior;
+    /** From `AXLocaleService.activeProfile().i18nMeta?.rtl`. */
+    isRtl?: boolean;
+    /** Chord was already passed through `resolveDisplayShortcutChord` (e.g. help `displayChords`). */
+    skipDirectionResolve?: boolean;
+}
+/** Maps a horizontal direction key to its RTL semantic counterpart. */
+declare function mirrorHorizontalDirectionalKey(key: string): string;
+/** True when the chord's primary key is a horizontal direction key (`←`/`→`, `[`/`]`). */
+declare function isHorizontalDirectionalShortcutKey(key: string): boolean;
+/**
+ * Resolves direction behavior for a chord.
+ * Horizontal direction keys default to `semantic`; others default to `physical`.
+ * An explicit binding value always wins.
+ */
+declare function resolveEffectiveDirectionBehavior(chord: AXPKeyboardShortcutChord, explicit?: AXPKeyboardShortcutDirectionBehavior): AXPKeyboardShortcutDirectionBehavior;
+/** Resolves the key the user presses for a semantically registered chord in RTL. */
+declare function resolveSemanticDirectionalKey(storedKey: string, rtl: boolean): string;
+/** Chord string with directional key mirrored for RTL display/matching when semantic. */
+declare function resolveDisplayShortcutChord(chord: AXPKeyboardShortcutChord, isRtl: boolean, explicitDirectionBehavior?: AXPKeyboardShortcutDirectionBehavior): string;
+interface ParsedShortcut {
+    ctrl: boolean;
+    shift: boolean;
+    alt: boolean;
+    meta: boolean;
+    key: string;
+}
+/**
+ * Parses a shortcut chord such as `Enter`, `Escape`, or `ctrl+shift+s`.
+ */
+declare function parseKeyboardShortcutChord(chord: AXPKeyboardShortcutChord): ParsedShortcut;
+/**
+ * Returns true when the keyboard event matches the given chord.
+ * On macOS, `ctrl+*` chords also match `meta+*` for common platform shortcuts.
+ */
+declare function matchesKeyboardShortcutChord(event: KeyboardEvent, chord: AXPKeyboardShortcutChord, options?: AXPKeyboardShortcutFormatOptions): boolean;
+/**
+ * Formats one chord for UI display (OS-aware modifier symbols).
+ */
+declare function formatKeyboardShortcutChord(chord: AXPKeyboardShortcutChord, options?: AXPKeyboardShortcutFormatOptions): string;
+/**
+ * Formats multiple chords as a single display string (e.g. `← / PgUp`).
+ */
+declare function formatKeyboardShortcutChords(chords: readonly AXPKeyboardShortcutChord[], options?: AXPKeyboardShortcutFormatOptions): string;
+/** Maps a chord to `ax-kbd-item` key parts (modifiers + display symbols). */
+declare function chordToKbdItemKeys(chord: AXPKeyboardShortcutChord, options?: AXPKeyboardShortcutFormatOptions): string[];
+/**
+ * When focus is in a native edit control, avoid stealing plain key shortcuts.
+ */
+declare function isKeyboardTargetInsideEditableField(target: EventTarget | null): boolean;
+/**
+ * Returns true when Esc should close an open widget overlay first (select, date picker, popover, modal).
+ * Used by the global shortcut registry so page-level Esc bindings do not swallow overlay dismiss.
+ */
+declare function shouldDeferEscapeToOpenOverlay(document: Document): boolean;
+declare function isMacPlatform(): boolean;
+
+/**
+ * Normalizes a declarative shortcut (`'ctrl+s'` or `{ keys: 'home', allowInEditableFields: false }`).
+ */
+declare function normalizeKeyboardShortcut(shortcut: AXPKeyboardShortcut): AXPResolvedKeyboardShortcut | undefined;
+/**
+ * Normalizes an array of declarative shortcuts. Empty or invalid entries are skipped.
+ */
+declare function normalizeKeyboardShortcuts(shortcuts?: readonly AXPKeyboardShortcut[]): AXPResolvedKeyboardShortcut[];
+/** Returns the first chord from declarative shortcuts (for UI hints such as `ax-kbd`). */
+declare function getPrimaryKeyboardShortcutChord(shortcuts?: readonly AXPKeyboardShortcut[]): AXPKeyboardShortcutChord | undefined;
+
+interface AXPKeyboardShortcutRegisterOptions extends AXPKeyboardShortcutRegistration {
+    /** Auto-unregister when the owner is destroyed. */
+    owner: DestroyRef;
+    /** When set, shortcuts are active only while the element is connected to the document. */
+    elementRef?: ElementRef<HTMLElement>;
+}
+declare class AXPKeyboardShortcutRegistry {
+    private readonly document;
+    private readonly localeService;
+    private readonly activeProfile;
+    private readonly registrations;
+    private helpDialogHandler;
+    private listenerAttached;
+    /** Active shortcut entries for the help dialog. */
+    readonly helpEntries: i0.Signal<AXPKeyboardShortcutHelpEntry[]>;
+    /**
+     * Registers a scope of shortcuts. Unregisters automatically when `owner` is destroyed.
+     */
+    register(options: AXPKeyboardShortcutRegisterOptions): void;
+    /**
+     * Wires the F1 help dialog opener (provided by platform/common).
+     */
+    setHelpDialogHandler(handler: () => void | Promise<void>): void;
+    /** OS-aware display string for UI hints. */
+    formatDisplayKeys(chords: readonly AXPKeyboardShortcutChord[]): string;
+    private ensureHelpShortcutRegistered;
+    private createRegistrationId;
+    private unregister;
+    private ensureListener;
+    private readonly onDocumentKeyDown;
+    private resolveActiveCandidates;
+    private isRegistrationActive;
+    private isRtlProfile;
+    private buildHelpEntries;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPKeyboardShortcutRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPKeyboardShortcutRegistry>;
+}
+
 /**
  * Feature definition in module manifest.
  * Defines available features with default values.
@@ -1965,6 +2742,14 @@ interface AXPFeatureDefinition extends AXPModuleFeatureDefinition {
     key: string;
 }
 
+/**
+ * Data source definition for module names/titles from {@link AXPModuleManifestRegistry}.
+ */
+declare class AXPModuleManifestsDataSourceDefinition implements AXPDataSourceDefinitionProvider {
+    private readonly manifestRegistry;
+    items(): Promise<AXPDataSourceDefinition[]>;
+}
+
 /**
  * Registry service for module manifests.
  * Collects and manages all registered module manifests.
@@ -2047,12 +2832,13 @@ declare class AXPModuleManifestRegistry {
 
 interface AXPStartUpTask {
     name: string;
-    statusText: string;
+    statusText: AXPMultiLanguageString;
     priority: number;
     run: () => Promise<void>;
 }
 
 declare class AXPAppStartUpService {
+    private readonly translationService;
     private tasks;
     registerTask(task: AXPStartUpTask): void;
     runAllTasks(): Promise<void>;
@@ -2132,6 +2918,31 @@ declare const AXP_SESSION_SERVICE: InjectionToken<AXPISessionService>;
  */
 declare const AXP_MODULE_MANIFEST_PROVIDER: InjectionToken<AXPModuleManifest[]>;
 
+/**
+ * Locale-aware comparison of {@link AXPMultiLanguageString} values (plain string, `@scope:key`, or locale map).
+ * Resolves each side with {@link resolveMultiLanguageString} for `locale`, then compares with `String#localeCompare`.
+ */
+declare function compareMultiLanguageStrings(a: AXPMultiLanguageString | null | undefined, b: AXPMultiLanguageString | null | undefined, locale: string, collatorOptions?: Intl.CollatorOptions): number;
+/**
+ * Stable sort copy: orders items by resolved string for `getValue(item)` using the active `locale`.
+ */
+declare function sortByMultiLanguageString<T>(items: readonly T[], getValue: (item: T) => AXPMultiLanguageString | null | undefined, locale: string, collatorOptions?: Intl.CollatorOptions): T[];
+/**
+ * True when the resolved value contains `query` (case-insensitive) for `locale`.
+ * Useful for search/filter flows over {@link AXPMultiLanguageString}.
+ */
+declare function searchInMultiLanguageString(value: AXPMultiLanguageString | null | undefined, query: string, locale: string): boolean;
+
+/** Per-locale string map (`{ 'en-US': '...', 'fa-IR': '...' }`). */
+declare function isLocaleStringMap(value: unknown): value is Record<string, string>;
+/**
+ * Use locale-map read/write when the option is on or live/saved data is already a map.
+ * Auto-enables when API data is a map but the editor option was left off.
+ */
+declare function shouldUseLocaleMapShape(localeMapOptionEnabled: boolean, current: unknown, saved: unknown): boolean;
+/** Updates one locale entry; preserves sibling locales from current or saved map. */
+declare function buildLocaleTextMapValue(current: unknown, saved: unknown, lang: string, input: string): Record<string, string> | null;
+
 /**
  * Represents a tag with text, color, and metadata
  */
@@ -2395,6 +3206,26 @@ declare function getEnumValues(enumType: any): {
     id: string;
     title: string;
 }[];
+/**
+ * Semantic equality for lookup/select values when restoring saved baseline shape.
+ * Compares by selection identity (id), including two full items with the same id.
+ */
+declare function isSelectionValueEqual(a: unknown, b: unknown): boolean;
+/**
+ * Semantic equality for dirty-state and baseline checks.
+ * Prefer over lodash `isEqual` when comparing user-edited form/context data to a saved baseline.
+ *
+ * Arrays: `[]`, `null`, and all-empty lists are equivalent; non-empty arrays compare as multisets (order ignored).
+ */
+declare function isFormValueEqual(a: unknown, b: unknown): boolean;
+/**
+ * Returns whether `current` differs from the saved/clean `baseline` snapshot.
+ */
+declare function isFormContextDirty(current: Record<string, unknown>, baseline: Record<string, unknown>): boolean;
+/**
+ * Clones a context object for use as a dirty-tracking baseline.
+ */
+declare function captureFormContextBaseline(context: Record<string, unknown>): Record<string, unknown>;
 
 /**
  * Creates a provider instance within an injection context.
@@ -2417,26 +3248,54 @@ declare function createProviderWithInjectionContext<T>(loader: () => Promise<new
  *
  * @param token - The injection token to provide
  * @param loader - Function that returns a promise resolving to the provider class
- * @param multi - Whether the provider is multi-provider (defaults to true)
+ * @param multi - Optional. Whether the provider is a multi-provider (array of values). Defaults to `true`. Pass `false` for a single provider.
  * @returns Provider configuration object
  *
  * @example
  * ```typescript
- * providers: [
- *   provideLazyProvider(
- *     AXP_SETTING_DEFINITION_PROVIDER,
- *     () => import('./settings.provider').then(m => m.AXMSettingProvider)
- *   )
- * ]
+ * // Multi-provider (default)
+ * provideLazyProvider(
+ *   AXP_DATASOURCE_DEFINITION_PROVIDER,
+ *   () => import('./datasource.provider').then(m => m.AXMDataSourceProvider)
+ * )
+ *
+ * // Single provider
+ * provideLazyProvider(
+ *   SOME_TOKEN,
+ *   () => import('./my.provider').then(m => m.MyProvider),
+ *   false
+ * )
  * ```
  */
 declare function provideLazyProvider<TProvider>(token: InjectionToken<any>, loader: () => Promise<new () => TProvider>, multi?: boolean): Provider;
 
+/**
+ * If `raw` is a plain non-array object with a `value` property, returns `value`; otherwise returns `raw`.
+ */
+declare function unwrapValueProperty(raw: unknown): unknown;
+/**
+ * Coerces to a trimmed string. Plain objects may carry `{ value }` from setting widgets or `{ id }` from select payloads using `valueField: 'id'`.
+ */
+declare function coerceUnknownToTrimmedString(raw: unknown): string;
+/**
+ * Coerces to boolean: direct booleans pass through; wrapped `{ value: true | 'true' }` is respected; otherwise false.
+ */
+declare function coerceUnknownToBoolean(raw: unknown): boolean;
+/** Parses a finite number after optional `{ value }` unwrap; non-finite or empty string yields NaN. */
+declare function coerceUnknownToFiniteNumber(raw: unknown): number;
+/** Parses a Date after optional `{ value }` unwrap; invalid input yields Invalid Date. */
+declare function coerceUnknownToDate(raw: unknown): Date;
+
 declare function extractTextFromHtml(value: string): string;
+/**
+ * True when the string likely contains HTML markup (e.g. `<p>`, `<ul>`), as opposed to plain text.
+ * Used to choose innerHTML vs text interpolation for multilingual fields.
+ */
+declare function containsHtmlMarkup(value: string | null | undefined): boolean;
 /**
  * Generate kebab-case group name from title
  */
 declare function generateKebabCase(title: string): string;
 
-export { AXFullscreenDirective, AXHighlightService, AXPActivityLogProvider, AXPActivityLogService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPColorPaletteProvider, AXPColorPaletteService, AXPComponentLogoConfig, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDefaultColorPalettesProvider, AXPDeviceService, AXPDeviceType, AXPDistributedEventListenerService, AXPElementDataDirective, AXPExportTemplateToken, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPFeatureDefinitionProviderContext, AXPGridLayoutDirective, AXPHookService, AXPIconLogoConfig, AXPImageUrlLogoConfig, AXPModuleManifestModule, AXPModuleManifestRegistry, AXPPlatformScope, AXPScreenSize, AXPSystemActionType, AXPSystemActions, AXPTagProvider, AXPTagService, AXP_ACTIVITY_LOG_PROVIDER, AXP_COLOR_PALETTE_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER, AXP_SESSION_SERVICE, AXP_TAG_PROVIDER, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, cleanDeep, createProviderWithInjectionContext, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, generateKebabCase, getActionButton, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getSmart, getSystemActions, objectKeyValueTransforms, provideLazyProvider, resolveActionLook, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
-export type { AXPActionMenuItem, AXPActivityLog, AXPActivityLogChange, AXPApplicationUserReference, AXPBackButton, AXPBadge, AXPBreadcrumbItem, AXPCategorizedEntity, AXPCategorizedEntityDto, AXPCategoryEntity, AXPCategoryEntityWithItems, AXPColorPalette, AXPColorPaletteFilterOptions, AXPColumnQuery, AXPCommandMessage, AXPContent, AXPContentDirection, AXPContentType, AXPContextData, AXPContextState, AXPDataSource, AXPDataSourceDataFieldDefinition, AXPDataSourceDefinition, AXPDataSourceDefinitionProvider, AXPDataType, AXPDistributedEventListenerProvider, AXPDistributedEventListenerProviderToken, AXPEntityReference, AXPEqualValidationRule, AXPExecuteCommand, AXPExecuteCommandResult, AXPExportCsvOptions, AXPExportExcelOptions, AXPExportOptions, AXPExportPdfOptions, AXPExportPrintOptions, AXPExpression, AXPExpressionEvaluatorScope, AXPExpressionEvaluatorScopeProvider, AXPExpressionEvaluatorScopeProviders, AXPFeatureDefinition, AXPFeatureDefinitionProvider, AXPFeatureName, AXPFileListItem, AXPFileSource, AXPFileStatus, AXPFilterClause, AXPFilterDefinition, AXPFilterQuery, AXPFlowDirection, AXPGridLayoutOptions, AXPGridPlacement, AXPISessionService, AXPLogoConfig, AXPMaxLengthValidationRule, AXPMetaData, AXPMiddlewareErrorResponse, AXPMinLengthValidationRule, AXPModuleFeatureDefinition, AXPModuleFeatureDefinitionWithKey, AXPModuleManifest, AXPNavigateActionCommand, AXPNavigateActionOptions, AXPOptionsData, AXPPagedListResult, AXPPartialNested, AXPPlatformScopeKey, AXPQueryFetchResult, AXPQueryRequest, AXPReqexValidationRule, AXPRequiredValidationRule, AXPSortDefinition, AXPSortQuery, AXPStartUpTask, AXPStringValidationRules, AXPSystemAction, AXPTag, AXPTagFilterOptions, AXPUserReference, AXPValidationRule, AXPValidationRules, AXPValueTransformerFunction, AXPValueTransformerFunctions, AXPValueUnit, AXPValueUnits, AXPViewBlockDefinition, AXPViewDefinition, AXPViewFieldDefinition, AXPViewQuery, AXPWidgetTrigger, AXPWidgetTriggers };
+export { AXHighlightService, AXPActivityLogProvider, AXPActivityLogService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPCatalogScopeDefinitionProviderService, AXPCatalogScopeDefinitionsDataSourceDefinition, AXPColorPaletteProvider, AXPColorPaletteService, AXPColumnWidthService, AXPComponentLogoConfig, AXPComponentSlot, AXPComponentSlotDirective, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextDefinitionProviderService, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDefaultColorPalettesProvider, AXPDeviceService, AXPDeviceType, AXPDistributedEventListenerService, AXPElementDataDirective, AXPExportTemplateToken, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPFeatureDefinitionProviderContext, AXPGridLayoutDirective, AXPHookService, AXPIconLogoConfig, AXPImageUrlLogoConfig, AXPKeyboardShortcutPriority, AXPKeyboardShortcutRegistry, AXPModuleManifestModule, AXPModuleManifestRegistry, AXPModuleManifestsDataSourceDefinition, AXPPlatformCoreDataSourceKeys, AXPPlatformScope, AXPScreenSize, AXPSystemActionType, AXPSystemActions, AXPTagProvider, AXPTagService, AXP_ACTIVITY_LOG_PROVIDER, AXP_CATALOG_SCOPE_DEFINITION_PROVIDER, AXP_COLOR_PALETTE_PROVIDER, AXP_COLUMN_WIDTH_PROVIDER, AXP_CONTEXT_DEFINITION_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER, AXP_DISTRIBUTED_EVENT_LISTENER_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_MODULE_MANIFEST_PROVIDER, AXP_SESSION_SERVICE, AXP_TAG_PROVIDER, AX_OVERLAY_CONTAINER_SELECTOR, AX_OVERLAY_PANE_SELECTOR, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, buildLocaleTextMapValue, captureFormContextBaseline, chordToKbdItemKeys, cleanDeep, coerceUnknownToBoolean, coerceUnknownToDate, coerceUnknownToFiniteNumber, coerceUnknownToTrimmedString, compareMultiLanguageStrings, containsHtmlMarkup, createProviderWithInjectionContext, defaultColumnWidthProvider, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, findOverlayContainerAncestor, formatKeyboardShortcutChord, formatKeyboardShortcutChords, generateKebabCase, getActionButton, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getNestedVisibleOverlayPanes, getPrimaryKeyboardShortcutChord, getSmart, getSystemActions, getTopVisibleOverlayContainer, getVisibleAnchoredOverlayPanes, getVisibleOverlayContainers, hasForegroundOverlayLayer, isFormContextDirty, isFormValueEqual, isHorizontalDirectionalShortcutKey, isKeyboardTargetInsideEditableField, isLocaleStringMap, isMacPlatform, isSelectionValueEqual, isVisibleOverlayElement, matchesKeyboardShortcutChord, mirrorHorizontalDirectionalKey, normalizeDefinitionCategories, normalizeKeyboardShortcut, normalizeKeyboardShortcuts, objectKeyValueTransforms, parseKeyboardShortcutChord, provideLazyProvider, resolveActionLook, resolveDisplayShortcutChord, resolveEffectiveDirectionBehavior, resolvePlatformScopeKey, resolvePlatformScopeName, resolveSemanticDirectionalKey, searchInMultiLanguageString, setSmart, shouldDeferEscapeToOpenOverlay, shouldUseLocaleMapShape, sortByMultiLanguageString, unwrapValueProperty };
+export type { AXPActionMenuItem, AXPActivityLog, AXPActivityLogChange, AXPApplicationUserReference, AXPBackButton, AXPBadge, AXPBreadcrumbItem, AXPCatalogScopeDefinition, AXPCatalogScopeDefinitionProvider, AXPCategorizedEntity, AXPCategorizedEntityDto, AXPCategoryEntity, AXPCategoryEntityWithItems, AXPCategoryListItem, AXPColorPalette, AXPColorPaletteFilterOptions, AXPColumnQuery, AXPColumnWidthMatcher, AXPColumnWidthProvider, AXPCommandMessage, AXPComponentSlotConfig, AXPComponentSlotModuleConfigs, AXPContent, AXPContentDirection, AXPContentType, AXPContextData, AXPContextDefinition, AXPContextDefinitionAiHints, AXPContextDefinitionProvider, AXPContextPatchOptions, AXPContextState, AXPContextUpdateOptions, AXPContextUpdateOrigin, AXPDataSource, AXPDataSourceArray, AXPDataSourceDataFieldDefinition, AXPDataSourceDefinition, AXPDataSourceDefinitionProvider, AXPDataSourceSample, AXPDataSourceType, AXPDataSourceValue, AXPDataType, AXPDefinitionCategory, AXPDistributedEventListenerProvider, AXPDistributedEventListenerProviderToken, AXPEntityOp, AXPEntityReference, AXPEqualValidationRule, AXPExecuteCommand, AXPExecuteCommandResult, AXPExportCsvOptions, AXPExportExcelOptions, AXPExportOptions, AXPExportPdfOptions, AXPExportPrintOptions, AXPExpression, AXPExpressionEvaluatorScope, AXPExpressionEvaluatorScopeProvider, AXPExpressionEvaluatorScopeProviders, AXPFeatureDefinition, AXPFeatureDefinitionProvider, AXPFeatureName, AXPFileListItem, AXPFileSource, AXPFileStatus, AXPFilterClause, AXPFilterDefinition, AXPFilterQuery, AXPFilterTriggerDefinition, AXPFlowDirection, AXPGridLayoutOptions, AXPGridPlacement, AXPISessionService, AXPKeyboardShortcut, AXPKeyboardShortcutBinding, AXPKeyboardShortcutChord, AXPKeyboardShortcutConfig, AXPKeyboardShortcutDirectionBehavior, AXPKeyboardShortcutFormatOptions, AXPKeyboardShortcutHelpEntry, AXPKeyboardShortcutRegisterOptions, AXPKeyboardShortcutRegistration, AXPLazyDataSource, AXPLogoConfig, AXPMaxLengthValidationRule, AXPMaybePromise, AXPMetaData, AXPMiddlewareErrorResponse, AXPMinLengthValidationRule, AXPModuleFeatureDefinition, AXPModuleFeatureDefinitionWithKey, AXPModuleManifest, AXPMultiLanguageString, AXPNavigateActionCommand, AXPNavigateActionOptions, AXPOptionsData, AXPPageStatus, AXPPagedListResult, AXPPartialNested, AXPPlatformScopeKey, AXPProperty, AXPPropertyGroup, AXPPropertyInterface, AXPQueryFetchResult, AXPQueryRequest, AXPReqexValidationRule, AXPRequiredValidationRule, AXPResolvedKeyboardShortcut, AXPSortDefinition, AXPSortQuery, AXPStartUpTask, AXPStringValidationRules, AXPSystemAction, AXPTag, AXPTagFilterOptions, AXPUserReference, AXPValidationRule, AXPValidationRules, AXPValueTransformerFunction, AXPValueTransformerFunctions, AXPValueUnit, AXPValueUnits, AXPViewBlockDefinition, AXPViewDefinition, AXPViewFieldDefinition, AXPViewQuery, AXPWidgetTrigger, AXPWidgetTriggers, ColumnNameMatcher, ColumnWidthValue, IColumnWithWidth, WidgetTypeMatcher };