@acorex/platform 0.0.0-ACOREX

package/types/acorex-platform-core.d.ts

@@ -0,0 +1,2896 @@
+import * as i0 from '@angular/core';
+import { Type, InjectionToken, OnInit, ViewContainerRef, ModuleWithProviders, ElementRef, EventEmitter, OnChanges, Renderer2, SimpleChanges, OnDestroy, Injector, PipeTransform, Provider } from '@angular/core';
+import { AXStyleColorType, AXDataSource, AXDataSourceSortOption, AXDataSourceFilterOption, AXDataSourceQuery, AXDataSourceCallbackResult } from '@acorex/cdk/common';
+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';
+
+/**
+ * Additional suggested generic actions for future consideration:
+ *
+ * Data & Content Actions:
+ * - Search = 'search' - Search functionality
+ * - Filter = 'filter' - Apply filters
+ * - Sort = 'sort' - Sort data
+ * - Group = 'group' - Group data
+ * - Expand = 'expand' - Expand details
+ * - Collapse = 'collapse' - Collapse details
+ * - Pin = 'pin' - Pin to favorites
+ * - Bookmark = 'bookmark' - Bookmark item
+ * - Favorite = 'favorite' - Mark as favorite
+ * - Star = 'star' - Star rating
+ *
+ * Workflow Actions:
+ * - Start = 'start' - Start process/workflow
+ * - Stop = 'stop' - Stop process
+ * - Pause = 'pause' - Pause process
+ * - Resume = 'resume' - Resume process
+ * - Cancel = 'cancel' - Cancel operation
+ * - Complete = 'complete' - Mark as complete
+ * - Close = 'close' - Close item
+ * - Reopen = 'reopen' - Reopen closed item
+ * - Forward = 'forward' - Forward to next step
+ * - Back = 'back' - Go back
+ *
+ * Communication Actions:
+ * - Reply = 'reply' - Reply to message
+ * - Forward = 'forward' - Forward message
+ * - Notify = 'notify' - Send notification
+ * - Invite = 'invite' - Invite user
+ * - Join = 'join' - Join group/meeting
+ * - Leave = 'leave' - Leave group/meeting
+ *
+ * Security Actions:
+ * - Login = 'login' - User login
+ * - Logout = 'logout' - User logout
+ * - Block = 'block' - Block user/content
+ * - Unblock = 'unblock' - Unblock user/content
+ * - Ban = 'ban' - Ban user
+ * - Unban = 'unban' - Unban user
+ * - Verify = 'verify' - Verify identity
+ * - Authenticate = 'authenticate' - Authenticate
+ *
+ * File & Media Actions:
+ * - Open = 'open' - Open file
+ * - Save = 'save' - Save file
+ * - SaveAs = 'save-as' - Save as new file
+ * - Attach = 'attach' - Attach file
+ * - Detach = 'detach' - Detach file
+ * - Compress = 'compress' - Compress files
+ * - Extract = 'extract' - Extract archive
+ * - Convert = 'convert' - Convert format
+ * - Crop = 'crop' - Crop image
+ * - Resize = 'resize' - Resize image
+ *
+ * System Actions:
+ * - Sync = 'sync' - Synchronize data
+ * - Backup = 'backup' - Create backup
+ * - Restore = 'restore' - Restore from backup
+ * - Reset = 'reset' - Reset to defaults
+ * - Clear = 'clear' - Clear data
+ * - Optimize = 'optimize' - Optimize performance
+ * - Update = 'update' - Update system
+ * - Install = 'install' - Install component
+ * - Uninstall = 'uninstall' - Uninstall component
+ * - Enable = 'enable' - Enable feature
+ * - Disable = 'disable' - Disable feature
+ *
+ * Analytics & Monitoring:
+ * - Monitor = 'monitor' - Monitor activity
+ * - Track = 'track' - Track progress
+ * - Analyze = 'analyze' - Analyze data
+ * - Debug = 'debug' - Debug issue
+ * - Log = 'log' - View logs
+ * - Alert = 'alert' - Set alert
+ * - Dashboard = 'dashboard' - View dashboard
+ * - Metrics = 'metrics' - View metrics
+ *
+ * Collaboration Actions:
+ * - Collaborate = 'collaborate' - Start collaboration
+ * - Share = 'share' - Share content
+ * - Comment = 'comment' - Add comment
+ * - Like = 'like' - Like content
+ * - Follow = 'follow' - Follow user/content
+ * - Subscribe = 'subscribe' - Subscribe to updates
+ * - Unsubscribe = 'unsubscribe' - Unsubscribe
+ * - Rate = 'rate' - Rate content
+ * - Review = 'review' - Review content
+ * - Recommend = 'recommend' - Recommend content
+ */
+declare enum AXPSystemActionType {
+    View = "view",
+    Create = "create",
+    Update = "update",
+    Delete = "delete",
+    Approve = "approve",
+    Reject = "reject",
+    Submit = "submit",
+    Export = "export",
+    Import = "import",
+    Print = "print",
+    Assign = "assign",
+    Lock = "lock",
+    Unlock = "unlock",
+    Share = "share",
+    Configure = "configure",
+    Reorder = "reorder",
+    Preview = "preview",
+    Duplicate = "duplicate",
+    Archive = "archive",
+    Publish = "publish",
+    Unpublish = "unpublish",
+    Upload = "upload",
+    Download = "download",
+    Copy = "copy",
+    Move = "move",
+    Rename = "rename",
+    Restore = "restore",
+    Manage = "manage",
+    Info = "info",
+    Confirm = "confirm",
+    Design = "design",
+    VersionHistory = "version-history",
+    Compare = "compare",
+    Comments = "comments",
+    Sign = "sign",
+    Setup = "setup",
+    Send = "send",
+    Report = "report",
+    Sent = "sent",
+    Review = "review",
+    Generate = "generate",
+    Refresh = "refresh",
+    Reload = "reload",
+    Search = "search",
+    Filter = "filter",
+    Sort = "sort",
+    Start = "start",
+    Stop = "stop",
+    Pause = "pause",
+    Cancel = "cancel",
+    Close = "close",
+    Complete = "complete",
+    Save = "save",
+    SaveAs = "save-as",
+    Sync = "sync",
+    Reset = "reset",
+    Clear = "clear",
+    Distribution = "distribution"
+}
+interface AXPSystemAction {
+    key: string;
+    title: string;
+    icon?: string;
+    color?: string;
+    critical?: boolean;
+    descriptions: {
+        title: string;
+        tooltip: string;
+        permission: string;
+        audit: string;
+    };
+}
+declare const AXPSystemActions: Readonly<{
+    readonly View: {
+        readonly key: AXPSystemActionType.View;
+        readonly title: string;
+        readonly icon: "fa-light fa-eye";
+        readonly color: "primary";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Create: {
+        readonly key: AXPSystemActionType.Create;
+        readonly title: string;
+        readonly icon: "fa-light fa-plus";
+        readonly color: "primary";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Edit: {
+        readonly key: AXPSystemActionType.Update;
+        readonly title: string;
+        readonly icon: "fa-light fa-pen";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Delete: {
+        readonly key: AXPSystemActionType.Delete;
+        readonly title: string;
+        readonly icon: "fa-light fa-trash";
+        readonly color: "danger";
+        readonly critical: true;
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Approve: {
+        readonly key: AXPSystemActionType.Approve;
+        readonly title: string;
+        readonly icon: "fa-light fa-circle-check";
+        readonly color: "success";
+        readonly critical: true;
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Submit: {
+        readonly key: AXPSystemActionType.Submit;
+        readonly title: string;
+        readonly icon: "fa-light fa-paper-plane";
+        readonly color: "primary";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Reject: {
+        readonly key: AXPSystemActionType.Reject;
+        readonly title: string;
+        readonly icon: "fa-light fa-ban";
+        readonly color: "danger";
+        readonly critical: true;
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Export: {
+        readonly key: AXPSystemActionType.Export;
+        readonly title: string;
+        readonly icon: "fa-light fa-download";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Import: {
+        readonly key: AXPSystemActionType.Import;
+        readonly title: string;
+        readonly icon: "fa-light fa-upload";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Print: {
+        readonly key: AXPSystemActionType.Print;
+        readonly title: string;
+        readonly icon: "fa-light fa-print";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Duplicate: {
+        readonly key: AXPSystemActionType.Duplicate;
+        readonly title: string;
+        readonly icon: "fa-light fa-clone";
+        readonly color: "warning";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Archive: {
+        readonly key: AXPSystemActionType.Archive;
+        readonly title: string;
+        readonly icon: "fa-light fa-box-archive";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Restore: {
+        readonly key: AXPSystemActionType.Restore;
+        readonly title: string;
+        readonly icon: "fa-light fa-arrow-rotate-left";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Assign: {
+        readonly key: AXPSystemActionType.Assign;
+        readonly title: string;
+        readonly icon: "fa-light fa-user-plus";
+        readonly color: "primary";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Lock: {
+        readonly key: AXPSystemActionType.Lock;
+        readonly title: string;
+        readonly icon: "fa-light fa-lock";
+        readonly color: "warning";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Unlock: {
+        readonly key: AXPSystemActionType.Unlock;
+        readonly title: string;
+        readonly icon: "fa-light fa-unlock";
+        readonly color: "success";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Share: {
+        readonly key: AXPSystemActionType.Share;
+        readonly title: string;
+        readonly icon: "fa-light fa-share-nodes";
+        readonly color: "info";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Configure: {
+        readonly key: AXPSystemActionType.Configure;
+        readonly title: string;
+        readonly icon: "fa-light fa-sliders";
+        readonly color: "primary";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Reorder: {
+        readonly key: AXPSystemActionType.Reorder;
+        readonly title: string;
+        readonly icon: "fa-light fa-arrow-down-up-across-line";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Preview: {
+        readonly key: AXPSystemActionType.Preview;
+        readonly title: string;
+        readonly icon: "fa-light fa-magnifying-glass";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Publish: {
+        readonly key: AXPSystemActionType.Publish;
+        readonly title: string;
+        readonly icon: "fa-light fa-globe";
+        readonly color: "success";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Unpublish: {
+        readonly key: AXPSystemActionType.Unpublish;
+        readonly title: string;
+        readonly icon: "fa-light fa-globe-slash";
+        readonly color: "danger";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Upload: {
+        readonly key: AXPSystemActionType.Upload;
+        readonly title: string;
+        readonly icon: "fa-light fa-upload";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Download: {
+        readonly key: AXPSystemActionType.Download;
+        readonly title: string;
+        readonly icon: "fa-light fa-download";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Copy: {
+        readonly key: AXPSystemActionType.Copy;
+        readonly title: string;
+        readonly icon: "fa-light fa-copy";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Move: {
+        readonly key: AXPSystemActionType.Move;
+        readonly title: string;
+        readonly icon: "fa-light fa-arrow-right-arrow-left";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Rename: {
+        readonly key: AXPSystemActionType.Rename;
+        readonly title: string;
+        readonly icon: "fa-light fa-pen";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Manage: {
+        readonly key: AXPSystemActionType.Manage;
+        readonly title: string;
+        readonly icon: "fa-light fa-gear";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Info: {
+        readonly key: AXPSystemActionType.Info;
+        readonly title: string;
+        readonly icon: "fa-light fa-info";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Confirm: {
+        readonly key: AXPSystemActionType.Confirm;
+        readonly title: string;
+        readonly icon: "fa-light fa-check";
+        readonly color: "success";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Design: {
+        readonly key: AXPSystemActionType.Design;
+        readonly title: string;
+        readonly icon: "fa-light fa-paintbrush";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly VersionHistory: {
+        readonly key: AXPSystemActionType.VersionHistory;
+        readonly title: string;
+        readonly icon: "fa-light fa-history";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Compare: {
+        readonly key: AXPSystemActionType.Compare;
+        readonly title: string;
+        readonly icon: "fa-light fa-code-compare";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Comments: {
+        readonly key: AXPSystemActionType.Comments;
+        readonly title: string;
+        readonly icon: "fa-light fa-comments";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Sign: {
+        readonly key: AXPSystemActionType.Sign;
+        readonly title: string;
+        readonly icon: "fa-light fa-signature";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Setup: {
+        readonly key: AXPSystemActionType.Setup;
+        readonly title: string;
+        readonly icon: "fa-light fa-cog";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Send: {
+        readonly key: AXPSystemActionType.Send;
+        readonly title: string;
+        readonly icon: "fa-light fa-envelope";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Report: {
+        readonly key: AXPSystemActionType.Report;
+        readonly title: string;
+        readonly icon: "fa-light fa-chart-line";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Sent: {
+        readonly key: AXPSystemActionType.Sent;
+        readonly title: string;
+        readonly icon: "fa-light fa-paper-plane";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Review: {
+        readonly key: AXPSystemActionType.Review;
+        readonly title: string;
+        readonly icon: "fa-light fa-eye";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Generate: {
+        readonly key: AXPSystemActionType.Generate;
+        readonly title: string;
+        readonly icon: "fa-light fa-wand-magic-sparkles";
+        readonly color: "primary";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Refresh: {
+        readonly key: AXPSystemActionType.Refresh;
+        readonly title: string;
+        readonly icon: "fa-light fa-arrows-rotate";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Reload: {
+        readonly key: AXPSystemActionType.Reload;
+        readonly title: string;
+        readonly icon: "fa-light fa-arrows-rotate";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Search: {
+        readonly key: AXPSystemActionType.Search;
+        readonly title: string;
+        readonly icon: "fa-light fa-magnifying-glass";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Filter: {
+        readonly key: AXPSystemActionType.Filter;
+        readonly title: string;
+        readonly icon: "fa-light fa-filter";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Sort: {
+        readonly key: AXPSystemActionType.Sort;
+        readonly title: string;
+        readonly icon: "fa-light fa-arrow-down-up-across-line";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Start: {
+        readonly key: AXPSystemActionType.Start;
+        readonly title: string;
+        readonly icon: "fa-light fa-play";
+        readonly color: "success";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Stop: {
+        readonly key: AXPSystemActionType.Stop;
+        readonly title: string;
+        readonly icon: "fa-light fa-stop";
+        readonly color: "danger";
+        readonly critical: true;
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Pause: {
+        readonly key: AXPSystemActionType.Pause;
+        readonly title: string;
+        readonly icon: "fa-light fa-pause";
+        readonly color: "warning";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Cancel: {
+        readonly key: AXPSystemActionType.Cancel;
+        readonly title: string;
+        readonly icon: "fa-light fa-xmark";
+        readonly critical: true;
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Close: {
+        readonly key: AXPSystemActionType.Close;
+        readonly title: string;
+        readonly icon: "fa-light fa-xmark";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Complete: {
+        readonly key: AXPSystemActionType.Complete;
+        readonly title: string;
+        readonly icon: "fa-light fa-check";
+        readonly color: "success";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Save: {
+        readonly key: AXPSystemActionType.Save;
+        readonly title: string;
+        readonly icon: "fa-light fa-floppy-disk";
+        readonly color: "primary";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly SaveAs: {
+        readonly key: AXPSystemActionType.SaveAs;
+        readonly title: string;
+        readonly icon: "fa-light fa-floppy-disk";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Sync: {
+        readonly key: AXPSystemActionType.Sync;
+        readonly title: string;
+        readonly icon: "fa-light fa-arrows-rotate";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Reset: {
+        readonly key: AXPSystemActionType.Reset;
+        readonly title: string;
+        readonly icon: "fa-light fa-arrow-rotate-left";
+        readonly color: "warning";
+        readonly critical: true;
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Clear: {
+        readonly key: AXPSystemActionType.Clear;
+        readonly title: string;
+        readonly icon: "fa-light fa-eraser";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+    readonly Distribution: {
+        readonly key: AXPSystemActionType.Distribution;
+        readonly title: string;
+        readonly icon: "fa-light fa-share-nodes";
+        readonly color: "default";
+        readonly descriptions: {
+            readonly title: string;
+            readonly tooltip: string;
+            readonly permission: string;
+            readonly audit: string;
+        };
+    };
+}>;
+declare function getSystemActions(type: AXPSystemActionType): AXPSystemAction;
+/**
+ * Resolves the visual appearance (color and icon) for entity actions
+ * using the system actions from the core module.
+ */
+declare function resolveActionLook(actionType: string): {
+    color: AXStyleColorType;
+    icon: string;
+};
+/**
+ * Resolves the title, description, icon and color for button actions
+ * using the system actions from the core module.
+ * @param actionType
+ * @returns
+ */
+declare function getActionButton(actionType: string): {
+    name: string;
+    title: string;
+    description: string;
+    icon: string;
+    color: string;
+};
+
+interface AXPColumnQuery {
+    name: string;
+    title: string;
+    visible: boolean | string;
+}
+
+type AXPPartialNested<T> = {
+    [K in keyof T]?: T[K] extends object ? AXPPartialNested<T[K]> : T[K];
+};
+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 = string | Record<string, string>;
+type AXPMetaData = Record<string, any>;
+type AXPOptionsData<T extends Record<string, unknown> = Record<string, any>> = T;
+interface AXPValueUnit {
+    name: string;
+    title: string;
+    ratio: number;
+    order: number;
+}
+interface AXPValueUnits {
+    name: string;
+    title: string;
+    items: AXPValueUnit[];
+    default: string;
+}
+interface AXPEntityReference {
+    id: string;
+    type: string;
+    title?: string;
+    metadata?: AXPMetaData;
+}
+interface AXPUserReference {
+    id: string;
+    type?: 'user';
+    fullName?: string;
+    username?: string;
+}
+interface AXPApplicationUserReference {
+    id: string;
+    name: string;
+    title: string;
+}
+type AXPContentType = 'text' | 'image' | 'file' | 'video' | 'link';
+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;
+}
+interface AXPQueryRequest {
+    skip: number;
+    take: number;
+    sort?: AXDataSourceSortOption[];
+    filter?: AXDataSourceFilterOption;
+    params?: {
+        [key: string]: string;
+    };
+}
+/**
+ * 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;
+    /** 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;
+    /**
+     * 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: AXPCategoryListItem[];
+}
+type AXPEntityOp = 'initial' | 'create' | 'update' | 'delete' | 'getOne' | 'getAll' | 'query';
+
+type AXPWidgetTrigger = {
+    event: string;
+    action: string | string[];
+    disabled?: boolean;
+};
+type AXPWidgetTriggers = AXPWidgetTrigger[];
+
+type AXPFileStatus = 'attached' | 'uploading' | 'uploaded' | 'deleted' | 'remote' | 'editing';
+interface AXPFileSource {
+    kind: 'blob' | 'url' | 'preview' | 'none' | 'fileId' | 'reference';
+    value?: Blob | string | AXPEntityReference;
+}
+interface AXPFileListItem {
+    id?: string;
+    name: string;
+    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;
+    filters?: AXPFilterClause[];
+}
+interface AXPFilterDefinition extends AXPFilterClause {
+    title: string;
+    isParametric?: boolean;
+    icon?: string;
+    widget: {
+        type: string;
+        options?: AXPOptionsData;
+    };
+    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;
+}
+
+type AXPActionMenuItem = {
+    name?: string;
+    title: string;
+    icon?: string;
+    iconOnly?: boolean;
+    color?: string;
+    break?: boolean;
+    items?: AXPActionMenuItem[];
+    command?: AXPExecuteCommand;
+    disabled?: boolean | string;
+    visible?: boolean | string;
+    policy?: string;
+};
+type AXPBackButton = {
+    title: string;
+};
+type AXPBreadcrumbItem = {
+    name?: string;
+    title: string;
+    icon?: string;
+    command?: AXPExecuteCommand;
+};
+type AXPBadge = {
+    title: string;
+    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;
+    details?: unknown;
+}
+type AXPExecuteCommand = {
+    name: string;
+    options?: AXPMetaData;
+    metadata?: AXPMetaData;
+};
+interface AXPExecuteCommandResult<T = any> {
+    success: boolean;
+    data?: T;
+    message?: AXPCommandMessage;
+    metadata?: AXPMetaData;
+}
+interface AXPQueryFetchResult<T = any> {
+    success: boolean;
+    data?: {
+        items?: T[];
+        total?: number;
+    };
+    message?: {
+        code?: string;
+        text?: string;
+        details?: any;
+    };
+}
+type AXPNavigateActionOptions = {
+    router: {
+        path: string;
+        extras?: NavigationExtras & {
+            target?: string;
+        };
+    };
+    modal: {
+        component: Type<any>;
+        title: string;
+        options?: any;
+    };
+};
+interface AXPNavigateActionCommand<T extends keyof AXPNavigateActionOptions> {
+    type: T;
+    options: AXPNavigateActionOptions[T];
+}
+declare function applySystemActionDefault(action: AXPActionMenuItem, type: AXPSystemActionType): AXPActionMenuItem;
+
+interface AXPGridPlacement {
+    colStart?: number;
+    colEnd?: number;
+    colSpan?: number;
+    rowStart?: number;
+    rowEnd?: number;
+    rowSpan?: number;
+    order?: string | number;
+}
+interface AXPGridLayoutOptions {
+    positions?: {
+        sm?: AXPGridPlacement;
+        md?: AXPGridPlacement;
+        lg?: AXPGridPlacement;
+        xl?: AXPGridPlacement;
+        xxl?: AXPGridPlacement;
+        xxxl?: AXPGridPlacement;
+    };
+}
+type AXPFlowDirection = 'vertical' | 'horizontal';
+type AXPContentDirection = 'rtl' | 'ltr';
+
+interface AXPLogoConfig {
+}
+declare class AXPImageUrlLogoConfig implements AXPLogoConfig {
+    url: string;
+    width?: number | undefined;
+    height?: number | undefined;
+    constructor(url: string, width?: number | undefined, height?: number | undefined);
+}
+declare class AXPComponentLogoConfig implements AXPLogoConfig {
+    component: Type<any>;
+    height?: number | undefined;
+    width?: number | undefined;
+    constructor(component: Type<any>);
+}
+declare class AXPIconLogoConfig implements AXPLogoConfig {
+    icon: string;
+    color?: string | undefined;
+    constructor(icon: string, color?: string | undefined);
+}
+
+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'> {
+}
+
+type AXPValidationRule = {
+    rule: string;
+    message?: string;
+    options?: any;
+    disabled?: boolean | AXPExpression;
+};
+type AXPValidationRules = AXPValidationRule[];
+interface AXPRequiredValidationRule extends AXPValidationRule {
+    rule: 'required';
+}
+interface AXPMinLengthValidationRule extends AXPValidationRule {
+    rule: 'minLength';
+    options: {
+        minLength: number | AXPExpression;
+    };
+}
+interface AXPMaxLengthValidationRule extends AXPValidationRule {
+    rule: 'maxLength';
+    options: {
+        maxLength: number | AXPExpression;
+    };
+}
+interface AXPEqualValidationRule<T> extends AXPValidationRule {
+    rule: 'equal';
+    options: {
+        value: T | AXPExpression;
+    };
+}
+interface AXPReqexValidationRule extends AXPValidationRule {
+    rule: 'regex';
+    options: {
+        value: string;
+    };
+}
+type AXPStringValidationRules = (AXPRequiredValidationRule | AXPMinLengthValidationRule | AXPMaxLengthValidationRule | AXPEqualValidationRule<string> | AXPReqexValidationRule)[];
+
+interface AXPViewQuery {
+    name: string;
+    fixed: boolean;
+    title: string;
+    columns: string[];
+    conditions: AXPFilterQuery[];
+    sorts: AXPSortQuery[];
+}
+
+interface AXPViewDefinition {
+    key: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    blocks: AXPViewBlockDefinition[];
+    layout?: 'vertical' | 'horizontal' | 'grid' | 'custom';
+    actions?: {
+        primary?: AXPActionMenuItem[];
+        secondary?: AXPActionMenuItem[];
+    };
+}
+interface AXPViewBlockDefinition {
+    key: string;
+    type: 'form' | 'table' | 'tabs' | 'list' | 'card' | 'custom';
+    title?: string;
+    description?: string;
+    icon?: string;
+    actions?: {
+        primary?: AXPActionMenuItem[];
+        secondary?: AXPActionMenuItem[];
+    };
+    fields?: AXPViewFieldDefinition[];
+    blocks?: AXPViewBlockDefinition[];
+}
+interface AXPViewFieldDefinition {
+    key: string;
+    title?: string;
+    description?: string;
+    icon?: string;
+    widget?: string;
+}
+
+interface AXPExportOptions {
+    fileNameTemplate?: string;
+    pdf?: AXPExportPdfOptions;
+    excel?: AXPExportExcelOptions;
+    csv?: AXPExportCsvOptions;
+    print?: AXPExportPrintOptions;
+}
+interface AXPExportPdfOptions {
+    enabled: boolean;
+    pageSize?: 'A4' | 'A3' | 'Letter' | 'Legal';
+    orientation?: 'portrait' | 'landscape';
+    margin?: number | {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    font?: string;
+    fontSize?: number;
+    headerEnabled?: boolean;
+    footerEnabled?: boolean;
+    showPageNumbers?: boolean;
+    watermarkText?: string;
+    watermarkOpacity?: number;
+    compression?: boolean;
+    embedImages?: boolean;
+}
+interface AXPExportExcelOptions {
+    enabled: boolean;
+    sheetName?: string;
+    includeFilters?: boolean;
+    freezeHeader?: boolean;
+    autoFitColumns?: boolean;
+    style?: {
+        headerColor?: string;
+        font?: string;
+        fontSize?: number;
+        numberFormat?: 'auto' | 'currency' | 'percent' | 'decimal';
+    };
+    summaryRowEnabled?: boolean;
+    exportHiddenColumns?: boolean;
+}
+interface AXPExportCsvOptions {
+    enabled: boolean;
+    delimiter?: ',' | ';' | '\t';
+    includeHeaders?: boolean;
+    quoteValues?: boolean;
+    encoding?: 'utf-8' | 'utf-16' | 'iso-8859-1';
+}
+interface AXPExportPrintOptions {
+    enabled: boolean;
+    includeHeader?: boolean;
+    includeFooter?: boolean;
+    showPageBreaks?: boolean;
+    customCssUrl?: string;
+}
+declare enum AXPExportTemplateToken {
+    Date = "{date}",
+    Time = "{time}",
+    User = "{user}",
+    ReportTitle = "{title}",
+    UUID = "{uuid}"
+}
+
+interface AXPMiddlewareErrorResponse {
+    success: false;
+    error: {
+        code?: string;
+        message: string;
+        status?: number;
+        details?: any;
+    };
+}
+
+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;
+    title: string;
+    date: Date;
+    user: AXPApplicationUserReference;
+    reference: AXPEntityReference;
+    changeType: AXPSystemActionType.Create | AXPSystemActionType.Update | AXPSystemActionType.Delete;
+    data: any;
+    changes: AXPActivityLogChange[];
+}
+
+declare abstract class AXPActivityLogProvider {
+    abstract getHistory(refId: string, refType: string, options?: {
+        from?: Date;
+        to?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<AXPActivityLog[]>;
+    abstract getHistoryByIds(refId: string, refType: string, ids: string[]): Promise<AXPActivityLog[]>;
+}
+
+declare const AXP_ACTIVITY_LOG_PROVIDER: InjectionToken<AXPActivityLogProvider[]>;
+declare class AXPActivityLogService {
+    private providers;
+    getHistory(refId: string, refType: string, options?: {
+        from?: Date;
+        to?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<AXPActivityLog[]>;
+    getHistoryByIds(refId: string, refType: string, ids: string[]): Promise<AXPActivityLog[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPActivityLogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPActivityLogService>;
+}
+
+/**
+ * Represents a color palette with a unique identifier and collection of colors
+ */
+interface AXPColorPalette {
+    /**
+     * Unique identifier for the palette
+     * @example 'material-design', 'brand-colors', 'pastel-theme'
+     */
+    name: string;
+    /**
+     * Display title for the palette
+     * @example 'Material Design', 'Brand Colors', 'Pastel Theme'
+     */
+    title: string;
+    /**
+     * Array of color codes in any valid CSS color format
+     * @example ['#FF6B6B', '#4ECDC4', 'rgb(255, 107, 107)']
+     */
+    colors: string[];
+    /**
+     * Optional description of the palette
+     */
+    description?: string;
+    /**
+     * Optional category for grouping palettes
+     * @example 'brand', 'material', 'theme', 'custom'
+     */
+    category?: string;
+}
+/**
+ * Options for filtering color palettes
+ */
+interface AXPColorPaletteFilterOptions {
+    category?: string;
+    search?: string;
+}
+
+/**
+ * Abstract class for color palette providers
+ * Implement this to provide palettes from different sources (system, app, module, etc.)
+ */
+declare abstract class AXPColorPaletteProvider {
+    /**
+     * Unique name for this provider (e.g., 'system', 'app', 'module')
+     */
+    abstract name: string;
+    /**
+     * Provide color palettes from this source
+     * @returns Promise of palettes
+     */
+    abstract provide(): Promise<AXPColorPalette[]>;
+}
+/**
+ * Injection token for color palette providers
+ * Use this to register multiple palette providers
+ */
+declare const AXP_COLOR_PALETTE_PROVIDER: InjectionToken<AXPColorPaletteProvider[]>;
+
+/**
+ * Service for managing color palettes from multiple providers
+ * Aggregates palettes from all registered providers
+ */
+declare class AXPColorPaletteService {
+    private providers;
+    private cache;
+    /**
+     * Get all palettes from all providers
+     * @param options Filter options
+     * @returns Promise of palettes
+     */
+    getPalettes(options?: AXPColorPaletteFilterOptions): Promise<AXPColorPalette[]>;
+    /**
+     * Get a palette by name
+     * @param name The unique name of the palette
+     * @returns Promise of palette or undefined if not found
+     */
+    getPalette(name: string): Promise<AXPColorPalette | undefined>;
+    /**
+     * Get palettes by category
+     * @param category The category to filter by
+     * @returns Promise of palettes in the specified category
+     */
+    getByCategory(category: string): Promise<AXPColorPalette[]>;
+    /**
+     * Check if a palette exists
+     * @param name The unique name of the palette
+     * @returns Promise of true if the palette exists
+     */
+    has(name: string): Promise<boolean>;
+    /**
+     * Reload palettes from all providers
+     */
+    reload(): Promise<void>;
+    /**
+     * Get the default palette (material-design) or fallback colors
+     * @returns Promise of default palette, never returns undefined
+     */
+    getDefaultPalette(): Promise<AXPColorPalette>;
+    /**
+     * Load palettes from all providers
+     */
+    private loadPalettes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPColorPaletteService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPColorPaletteService>;
+}
+
+/**
+ * Default system color palette provider
+ * Provides built-in color palettes
+ */
+declare class AXPDefaultColorPalettesProvider extends AXPColorPaletteProvider {
+    name: string;
+    provide(): Promise<AXPColorPalette[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDefaultColorPalettesProvider, never>;
+    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 AXPContextData = {
+    [key: string]: any;
+};
+declare class AXPContextChangeEvent {
+    oldValue?: any;
+    newValue?: any;
+    path?: string;
+    state: AXPContextState;
+    data: any;
+}
+declare const AXPContextStore: i0.Type<{
+    data: i0.Signal<AXPContextData>;
+    state: i0.Signal<AXPContextState>;
+    initialSnapshot: i0.Signal<{}>;
+    previousSnapshot: i0.Signal<{}>;
+    lastChange: _ngrx_signals.DeepSignal<AXPContextChangeEvent>;
+    isChanged: i0.Signal<boolean>;
+    isReset: i0.Signal<boolean>;
+    isInitiated: i0.Signal<boolean>;
+    isEmpty: i0.Signal<boolean>;
+    isDirty: i0.Signal<boolean>;
+    snapshot: i0.Signal<AXPContextData>;
+    initial: i0.Signal<{}>;
+    previous: i0.Signal<{}>;
+    changeEvent: i0.Signal<AXPContextChangeEvent>;
+    update: (path: string, value: any) => void;
+    patch: (context: Record<string, any>, skipDirtyTracking?: boolean) => void;
+    reset: () => void;
+    set: (initialData: any) => void;
+    getValue: (path: string) => any;
+    hasValue: (path: string) => boolean;
+} & _ngrx_signals.StateSource<{
+    data: AXPContextData;
+    state: AXPContextState;
+    initialSnapshot: {};
+    previousSnapshot: {};
+    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>;
+        initialSnapshot: i0.Signal<{}>;
+        previousSnapshot: i0.Signal<{}>;
+        lastChange: _ngrx_signals.DeepSignal<_acorex_platform_core.AXPContextChangeEvent>;
+        isChanged: i0.Signal<boolean>;
+        isReset: i0.Signal<boolean>;
+        isInitiated: i0.Signal<boolean>;
+        isEmpty: i0.Signal<boolean>;
+        isDirty: i0.Signal<boolean>;
+        snapshot: i0.Signal<AXPContextData>;
+        initial: i0.Signal<{}>;
+        previous: i0.Signal<{}>;
+        changeEvent: i0.Signal<_acorex_platform_core.AXPContextChangeEvent>;
+        update: (path: string, value: any) => void;
+        patch: (context: Record<string, any>, skipDirtyTracking?: boolean) => void;
+        reset: () => void;
+        set: (initialData: any) => void;
+        getValue: (path: string) => any;
+        hasValue: (path: string) => boolean;
+    } & _ngrx_signals.StateSource<{
+        data: AXPContextData;
+        state: _acorex_platform_core.AXPContextState;
+        initialSnapshot: {};
+        previousSnapshot: {};
+        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>;
+}
+
+declare class AXPDataGenerator {
+    static uuid(): string;
+    static number(max: number): number;
+    static number(min: number, max: number): number;
+    static date(): Date;
+    static date(start: Date): Date;
+    static date(start: Date, end: Date): Date;
+    static array<T>(length: number | undefined, generator: () => T): T[];
+    static pick<T>(items: T[]): T;
+    static pick<T>(items: T[], count: number): T[];
+    static string(length?: number): string;
+    static boolean(): boolean;
+    static item<T>(array?: T[]): T | undefined;
+    static color(format?: 'hsl' | 'rgb' | 'hex'): string;
+    private static hslToRgb;
+    static alphanumeric(length?: number): string;
+    static alphabet(length?: number): string;
+    static phone(): string;
+    static firstName(): string;
+    static lastName(): string;
+    static email(): string;
+    static email(firstName: string, lastName: string): string;
+    static country(): string;
+    static city(): string;
+    static state(): string;
+    static address(): string;
+    static avatar(): string;
+}
+
+type AXPValueTransformerFunction = (value: any) => any;
+type AXPValueTransformerFunctions = {
+    getter?: AXPValueTransformerFunction;
+    setter?: AXPValueTransformerFunction;
+};
+declare function objectKeyValueTransforms(keyName: string): AXPValueTransformerFunctions;
+
+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>;
+}
+
+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 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 {
+    private elementRef;
+    data: i0.InputSignal<any>;
+    path: i0.InputSignal<string>;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    private updateEffect;
+    /**
+     * Get data from the element
+     */
+    getData(): any;
+    /**
+     * Update data at runtime
+     */
+    setData(data: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPElementDataDirective, never>;
+    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 AXPGridLayoutDirective implements OnChanges {
+    private el;
+    private renderer;
+    options: i0.InputSignal<AXPGridLayoutOptions>;
+    constructor(el: ElementRef, renderer: Renderer2);
+    ngOnChanges(changes: SimpleChanges): void;
+    private applyTailwindClasses;
+    private setClasses;
+    private clearClasses;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPGridLayoutDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPGridLayoutDirective, "[axp-grid-layout]", never, { "options": { "alias": "axp-grid-layout"; "required": true; "isSignal": true; }; }, {}, 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> {
+    key: string;
+    execute(data: TInput): Promise<TOutput> | TOutput;
+    priority?: number;
+}
+
+declare class AXPDistributedEventListenerService {
+    private readonly listenerProviders;
+    private readonly injector;
+    /** Cache for listeners by key. */
+    private listenersByKey;
+    /** Flag to track if providers have been loaded */
+    private providersLoaded;
+    /**
+     * Dispatches an event to all registered listeners for the given key.
+     * @param key The event key.
+     * @param data The event data to pass to listeners.
+     */
+    dispatch(key: string, data?: any): Promise<void>;
+    /**
+       * Dispatch with async response (first matching provider, with retry/timeout)
+       */
+    dispatchAsync<T, R>(key: string, data: T, options?: {
+        timeout: number;
+        retries: number;
+        retryDelay: number;
+    }): Promise<R>;
+    /**
+      * Resolve all providers (handle both direct provider and Promise<provider>)
+      */
+    private resolveProviders;
+    /**
+     * Returns all listeners for a specific event key.
+     * @param key The event key.
+     * @returns Array of listeners for the key.
+     */
+    getListeners(key: string): Promise<AXPDistributedEventListenerProvider<any>[]>;
+    /**
+     * Returns all registered event keys.
+     * @returns Array of all event keys that have listeners.
+     */
+    getRegisteredKeys(): Promise<string[]>;
+    /**
+     * Ensures that all providers have been loaded and cached.
+     */
+    private ensureProvidersLoaded;
+    /** Clears the listeners cache and forces reload on next access. */
+    clearListenersCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDistributedEventListenerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPDistributedEventListenerService>;
+}
+
+declare class AXPBroadcastEventService implements OnDestroy {
+    private channel;
+    private eventSubjects;
+    private pendingRequests;
+    private multiTabEventHistory;
+    private readonly instanceId;
+    constructor();
+    /**
+     * Publish an event without expecting a response
+     */
+    publish<T>(type: string, payload?: T): void;
+    /**
+     * Subscribe to an event
+     */
+    listen<T>(type: string): Observable<{
+        data: T;
+        requestId?: string;
+    }>;
+    /**
+     * Unsubscribe from an event
+     */
+    unsubscribe(type: string): void;
+    /**
+     * Send a message and wait for a response with retry logic
+     */
+    sendAndWaitForResponse<T, R>(type: string, payload?: T, options?: {
+        timeout: number;
+        retries: number;
+        retryDelay: number;
+    }): Promise<R>;
+    /**
+     * Respond to a request
+     */
+    respondToRequest(requestId: string, response: any): void;
+    /**
+     * Cleanup when the service is destroyed
+     */
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPBroadcastEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPBroadcastEventService>;
+}
+
+type AXPExpressionEvaluatorScope = {
+    [name: string]: {
+        [name: string]: Function;
+    };
+};
+declare class AXPExpressionEvaluatorService {
+    private expressionCache;
+    private providerService;
+    private getOrCompileFunction;
+    private getMergedScope;
+    evaluate(source: any | any[], scope?: AXPExpressionEvaluatorScope): Promise<any>;
+    private evaluateStringExpression;
+    isExpression(expression: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPExpressionEvaluatorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPExpressionEvaluatorService>;
+}
+
+interface AXPExpressionEvaluatorScopeProvider {
+    provide(context: AXPExpressionEvaluatorScopeProviderContext): Promise<void>;
+}
+declare class AXPExpressionEvaluatorScopeProviderContext {
+    private scopes;
+    addScope(namespace: string, functions: {
+        [name: string]: Function;
+    }): void;
+    getScopes(): AXPExpressionEvaluatorScope;
+}
+type AXPExpressionEvaluatorScopeProviders = AXPExpressionEvaluatorScopeProvider[] | (() => AXPExpressionEvaluatorScopeProvider[]);
+declare const AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER: InjectionToken<AXPExpressionEvaluatorScopeProviders>;
+declare class AXPExpressionEvaluatorScopeProviderService {
+    private readonly injector;
+    private cache;
+    private load;
+    getScopesAsync(): Promise<AXPExpressionEvaluatorScope>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPExpressionEvaluatorScopeProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPExpressionEvaluatorScopeProviderService>;
+}
+
+declare class AXPHookService {
+    private readonly listenerProviders;
+    private readonly injector;
+    /**
+     * Resolve all providers (handle both direct providers and Promise<provider>)
+     */
+    private resolveProviders;
+    /**
+     * Fire sync hooks (fire-and-forget).
+     * All providers with the given key will be executed.
+     * Execution is not awaited.
+     */
+    fire<T>(key: string, data: T): void;
+    /**
+     * Run async hooks sequentially (waterfall).
+     * The output of each hook is passed as input to the next hook.
+     * Returns the final merged data after all hooks are executed.
+     */
+    runAsync<T>(key: string, initialData: T): Promise<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPHookService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPHookService>;
+}
+
+/**
+ * Feature definition in module manifest.
+ * Defines available features with default values.
+ */
+interface AXPModuleFeatureDefinition {
+    /**
+     * Feature title (translation key or literal)
+     */
+    title: string;
+    /**
+     * Feature description (translation key or literal)
+     */
+    description?: string;
+    /**
+     * Default value for the feature.
+     * Used when user doesn't have explicit feature value.
+     */
+    defaultValue: boolean | number | string | string[] | null;
+    /**
+     * Type hint for validation and UI rendering
+     */
+    type?: 'boolean' | 'number' | 'string' | 'array';
+    /**
+     * Widget interface for feature configuration UI (optional)
+     */
+    interface?: {
+        type: string;
+        options?: Record<string, any>;
+    };
+}
+/**
+ * Feature definition in array format (with key).
+ * Used when features are defined as an array in manifest.
+ */
+interface AXPModuleFeatureDefinitionWithKey extends AXPModuleFeatureDefinition {
+    /**
+     * Full feature key (ModuleName.FeatureKey format).
+     * When using array format, this must be provided.
+     */
+    key: string;
+}
+/**
+ * Module manifest structure.
+ * Defines module metadata and dependencies.
+ * Features are provided via AXP_FEATURE_DEFINITION_PROVIDER token.
+ */
+interface AXPModuleManifest {
+    /**
+     * Module name (must match RootConfig.module.name)
+     */
+    name: string;
+    /**
+     * Module version
+     */
+    version: string;
+    /**
+     * Module title (can reference const.ts or be translation key)
+     */
+    title: string;
+    /**
+     * Module description (optional)
+     */
+    description?: string;
+    /**
+     * Module icon (can reference const.ts)
+     */
+    icon?: string;
+    /**
+     * i18n scope name (can reference const.ts)
+     */
+    i18n?: string;
+    /**
+     * Module dependencies.
+     * Simple array format: module names (e.g., "MeasurementCore") or feature keys (e.g., "DataManagement.MetaDataDefinitions").
+     * Features use ModuleName.FeatureKey format (dot separator).
+     */
+    dependencies?: string[];
+    /**
+     * Whether this module is required (always enabled, cannot be disabled).
+     * Required modules like 'auth' and 'common' are always available.
+     */
+    required?: boolean;
+    /**
+     * Additional metadata
+     */
+    metadata?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Full feature name with module prefix.
+ * Format: ModuleName.FeatureKey
+ */
+type AXPFeatureName = string;
+/**
+ * Feature definition with full name.
+ */
+interface AXPFeatureDefinition extends AXPModuleFeatureDefinition {
+    /**
+     * Full feature name (ModuleName.FeatureKey)
+     */
+    name: AXPFeatureName;
+    /**
+     * Module name
+     */
+    module: string;
+    /**
+     * Feature key (short name)
+     */
+    key: string;
+}
+
+/**
+ * Registered module manifests for select widgets via dataSource name {@link MODULE_MANIFESTS_DATASOURCE_NAME}.
+ */
+declare const MODULE_MANIFESTS_DATASOURCE_NAME = "platform-module-manifests";
+/**
+ * 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.
+ */
+declare class AXPModuleManifestRegistry {
+    private readonly manifests;
+    private readonly featureDefinitions;
+    private readonly injector;
+    private initializationPromise;
+    private isInitialized;
+    /**
+     * Initialize registry by loading all manifest providers.
+     * Should be called during app startup.
+     * Safe to call multiple times - will only initialize once.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Internal initialization logic.
+     */
+    private _doInitialize;
+    /**
+     * Register a module manifest.
+     */
+    register(manifest: AXPModuleManifest): Promise<void>;
+    /**
+     * Get manifest for a module.
+     */
+    get(moduleName: string): AXPModuleManifest | undefined;
+    /**
+     * Get all registered manifests.
+     */
+    getAll(): AXPModuleManifest[];
+    /**
+     * Check if a module manifest is registered.
+     */
+    has(moduleName: string): boolean;
+    /**
+     * Load feature definitions from all registered feature definition providers.
+     * Features are automatically associated with modules based on the module name in the feature key.
+     */
+    private loadFeatureDefinitions;
+    /**
+     * Get all feature definitions from all manifests.
+     */
+    getAllFeatureDefinitions(): AXPFeatureDefinition[];
+    /**
+     * Get feature definition by full name.
+     */
+    getFeatureDefinition(featureName: AXPFeatureName): AXPFeatureDefinition | undefined;
+    /**
+     * Check if a feature is defined in any manifest.
+     */
+    isFeatureDefined(featureName: AXPFeatureName): boolean;
+    /**
+     * Get default value for a feature.
+     * Returns undefined if feature is not defined.
+     */
+    getFeatureDefault(featureName: AXPFeatureName): any;
+    /**
+     * Get all feature definitions for a specific module.
+     */
+    getModuleFeatures(moduleName: string): AXPFeatureDefinition[];
+    /**
+     * Register a feature definition dynamically (e.g., from feature definition provider).
+     * Used to add features that are defined at runtime via AXP_FEATURE_DEFINITION_PROVIDER.
+     */
+    registerFeatureDefinition(definition: AXPFeatureDefinition): void;
+    /**
+     * Check if module dependencies are satisfied.
+     * Returns array of missing dependencies.
+     * Dependencies can be module names or feature keys (ModuleName.FeatureKey format).
+     */
+    checkDependencies(moduleName: string): {
+        missingModules: string[];
+        missingFeatures: string[];
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPModuleManifestRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPModuleManifestRegistry>;
+}
+
+interface AXPStartUpTask {
+    name: string;
+    statusText: string;
+    priority: number;
+    run: () => Promise<void>;
+}
+
+declare class AXPAppStartUpService {
+    private tasks;
+    registerTask(task: AXPStartUpTask): void;
+    runAllTasks(): Promise<void>;
+    private updateStatus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPAppStartUpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPAppStartUpService>;
+}
+declare const AXPAppStartUpProvider: i0.EnvironmentProviders;
+
+/**
+ * Module for managing module manifests initialization.
+ * Handles the registration of manifest startup tasks.
+ */
+declare class AXPModuleManifestModule {
+    /**
+     * @ignore
+     * Initializes module manifest tasks on module construction.
+     */
+    constructor(appInitService: AXPAppStartUpService, injector: Injector);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPModuleManifestModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPModuleManifestModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPModuleManifestModule>;
+}
+
+/**
+ * Context for feature definition providers.
+ * Allows providers to add additional feature definitions dynamically.
+ */
+declare class AXPFeatureDefinitionProviderContext {
+    private readonly features;
+    /**
+     * Add a feature definition.
+     * @param key Full feature key (ModuleName:FeatureKey format with colon separator)
+     * @param definition Feature definition
+     */
+    addFeature(key: string, definition: AXPModuleFeatureDefinition): void;
+    /**
+     * Get all feature definitions.
+     */
+    getFeatures(): Map<string, AXPModuleFeatureDefinition>;
+}
+/**
+ * Interface for feature definition providers.
+ * Used to dynamically provide feature definitions for modules.
+ */
+interface AXPFeatureDefinitionProvider {
+    /**
+     * Provide feature definitions.
+     * @param context Context for adding feature definitions
+     */
+    provide(context: AXPFeatureDefinitionProviderContext): Promise<void>;
+}
+/**
+ * Injection token for feature definition providers.
+ */
+declare const AXP_FEATURE_DEFINITION_PROVIDER: InjectionToken<AXPFeatureDefinitionProvider[]>;
+
+/**
+ * Session service interface for module provider operations.
+ * Implementation: @acorex/platform/auth
+ */
+interface AXPISessionService {
+    isLoading$: any;
+    status$: any;
+    tenant: any | null;
+    application: any | null;
+    user: any | null;
+}
+/**
+ * Injection token for session service.
+ * Implementation: @acorex/platform/auth
+ */
+declare const AXP_SESSION_SERVICE: InjectionToken<AXPISessionService>;
+/**
+ * Injection token for module manifest providers.
+ * Modules register their manifest providers using this token.
+ */
+declare const AXP_MODULE_MANIFEST_PROVIDER: InjectionToken<AXPModuleManifest[]>;
+
+/**
+ * Resolves {@link AXPMultiLanguageString} using the active app locale, and exposes
+ * {@link currentLocale$} for code that prefers an observable (e.g. manual subscriptions).
+ * Templates usually use {@link AXPResolveMultiLanguageStringPipe} instead.
+ */
+declare class AXPMultiLanguageStringResolverService {
+    private readonly translation;
+    /**
+     * Emits the active locale on subscribe and whenever the language changes.
+     */
+    readonly currentLocale$: Observable<string>;
+    /**
+     * Resolves multi-language content for an optional locale (defaults to active).
+     */
+    resolve(content: AXPMultiLanguageString | null | undefined, locale?: string): string;
+    /**
+     * Normalizes multi-language content to a locale map for editors (e.g. multi-language popup `values`).
+     * If `content` is already a locale-to-string map, returns a shallow copy.
+     * If it is a plain string or empty, wraps it as `{ [activeLocale]: text }`.
+     */
+    toLocaleMap(content: AXPMultiLanguageString | null | undefined, activeLocale: string): Record<string, string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPMultiLanguageStringResolverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPMultiLanguageStringResolverService>;
+}
+
+/**
+ * Resolves {@link AXPMultiLanguageString} via {@link AXPMultiLanguageStringResolverService}.
+ * Impure and subscribes to {@link AXPMultiLanguageStringResolverService#currentLocale$} so
+ * OnPush hosts (e.g. grid cells) still refresh when the language changes.
+ *
+ * Optional second argument: explicit locale (e.g. from a host `locale` input). When omitted or null/empty,
+ * the active language is used.
+ *
+ * @example
+ * ```html
+ * {{ value | axpResolveMultiLanguageString }}
+ * {{ value | axpResolveMultiLanguageString: locale() }}
+ * ```
+ */
+declare class AXPResolveMultiLanguageStringPipe implements PipeTransform, OnDestroy {
+    private readonly resolver;
+    private readonly cdr;
+    private readonly localeSubscription;
+    transform(value: AXPMultiLanguageString | null | undefined, locale?: string | null): string;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPResolveMultiLanguageStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AXPResolveMultiLanguageStringPipe, "axpResolveMultiLanguageString", true>;
+}
+
+/**
+ * Resolves {@link AXPMultiLanguageString} to a single string for the given locale.
+ * Fallback order: `currentLocale` → `en-US` → first map value.
+ */
+declare function resolveMultiLanguageString(content: AXPMultiLanguageString | null | undefined, currentLocale: string): string;
+/**
+ * Creates an {@link AXPMultiLanguageString} with `en-US` and `fa-IR` entries.
+ * Use for seed data, tests, and demos that supply English and Persian copy explicitly.
+ */
+declare function createMultiLanguageString(enUs: string, faIr: string): AXPMultiLanguageString;
+/**
+ * True when there is no displayable text in any locale (plain string or ML map).
+ * Pure helper for predicates (e.g. default section detection); prefer widgets / pipes for display.
+ */
+declare function isEffectivelyEmptyLocalizedValue(value: unknown): boolean;
+
+/**
+ * Represents a tag with text, color, and metadata
+ */
+interface AXPTag {
+    id?: string;
+    title: string;
+    color: string;
+    description?: string;
+    scope?: 'system' | 'tenant' | 'user';
+}
+/**
+ * Options for filtering tags
+ */
+interface AXPTagFilterOptions {
+    scope?: ('system' | 'tenant' | 'user')[];
+    search?: string;
+}
+
+/**
+ * Abstract class for tag providers
+ * Implement this to provide tags from different sources (system, tenant, user, etc.)
+ */
+declare abstract class AXPTagProvider {
+    /**
+     * Unique name for this provider (e.g., 'system', 'tenant', 'user')
+     */
+    abstract name: string;
+    /**
+     * Provide tags from this source
+     * @returns Promise of tags
+     */
+    abstract provide(): Promise<AXPTag[]>;
+    /**
+     * Create a new tag (optional - not all providers support creation)
+     * @param tag Tag to create
+     * @returns Created tag with id
+     */
+    create?(tag: Omit<AXPTag, 'id'>): Promise<AXPTag>;
+    /**
+     * Update an existing tag (optional)
+     * @param tag Tag to update
+     * @returns Updated tag
+     */
+    update?(tag: AXPTag): Promise<AXPTag>;
+    /**
+     * Delete a tag (optional)
+     * @param id Tag id to delete
+     */
+    delete?(id: string): Promise<void>;
+}
+/**
+ * Injection token for tag providers
+ * Use this to register multiple tag providers
+ */
+declare const AXP_TAG_PROVIDER: InjectionToken<AXPTagProvider[]>;
+
+/**
+ * Service for managing tags from multiple providers
+ * Aggregates tags from all registered providers
+ */
+declare class AXPTagService {
+    private providers;
+    private cache;
+    /**
+     * Get all tags from all providers
+     * @param options Filter options
+     * @returns Promise of tags
+     */
+    getTags(options?: AXPTagFilterOptions): Promise<AXPTag[]>;
+    /**
+     * Create a new tag using the appropriate provider
+     * @param tag Tag to create
+     * @param providerName Provider to use (defaults to first writable provider)
+     * @returns Created tag
+     */
+    createTag(tag: Omit<AXPTag, 'id'>, providerName?: string): Promise<AXPTag>;
+    /**
+     * Update an existing tag
+     * @param tag Tag to update
+     * @returns Updated tag
+     */
+    updateTag(tag: AXPTag): Promise<AXPTag>;
+    /**
+     * Delete a tag
+     * @param tagId Tag id to delete
+     * @param scope Tag scope
+     */
+    deleteTag(tagId: string, scope: string): Promise<void>;
+    /**
+     * Reload tags from all providers
+     */
+    reload(): Promise<void>;
+    /**
+     * Load tags from all providers
+     */
+    private loadTags;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTagService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPTagService>;
+}
+
+declare class AXPCountdownPipe implements PipeTransform {
+    private calendarService;
+    private countdownSignal;
+    private targetDate;
+    private prevValue;
+    transform(value: number): Observable<string>;
+    private setupTimer;
+    private updateTargetDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCountdownPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AXPCountdownPipe, "countdown", true>;
+}
+
+declare function applyFilterArray(dataArray: any[], filters?: AXDataSourceFilterOption[], logic?: 'and' | 'or'): any[];
+declare function applySortArray(dataArray: any, sorts: AXDataSourceSortOption[]): any;
+declare function applyPagination<T>(dataArray: T[], skip: number, take: number): T[];
+declare function applyQueryArray<T>(dataArray: T[], query: AXDataSourceQuery): Promise<AXDataSourceCallbackResult<T>>;
+
+/**
+ * Screen Size Enum
+ */
+declare enum AXPScreenSize {
+    Small = "small",
+    Medium = "medium",
+    Large = "large"
+}
+/**
+ * Device Type Enum
+ */
+declare enum AXPDeviceType {
+    Mobile = "mobile",
+    Tablet = "tablet",
+    Desktop = "desktop"
+}
+/**
+ * Injectable service that provides reactive device and screen size information.
+ * Monitors window resize events and updates signals accordingly.
+ */
+declare class AXPDeviceService {
+    /**
+     * Current screen size (Small, Medium, Large)
+     */
+    readonly screenSize: i0.WritableSignal<AXPScreenSize>;
+    /**
+     * Current device type (Mobile, Tablet, Desktop)
+     */
+    readonly deviceType: i0.WritableSignal<AXPDeviceType>;
+    /**
+     * Whether the device supports touch input
+     */
+    readonly isTouchDevice: i0.WritableSignal<boolean>;
+    /**
+     * Whether the screen size is Small
+     */
+    readonly isSmall: i0.Signal<boolean>;
+    /**
+     * Whether the screen size is Medium
+     */
+    readonly isMedium: i0.Signal<boolean>;
+    /**
+     * Whether the screen size is Large
+     */
+    readonly isLarge: i0.Signal<boolean>;
+    /**
+     * Whether the device is Mobile
+     */
+    readonly isMobileDevice: i0.Signal<boolean>;
+    /**
+     * Whether the device is Tablet
+     */
+    readonly isTabletDevice: i0.Signal<boolean>;
+    /**
+     * Whether the device is Desktop
+     */
+    readonly isDesktopDevice: i0.Signal<boolean>;
+    /**
+     * Whether the device supports touch (alias for isTouchDevice)
+     */
+    readonly isTouchScreen: i0.Signal<boolean>;
+    private _resizeListener;
+    constructor();
+    /**
+     * Update screen size and device type based on window width
+     */
+    private _updateScreenSize;
+    /**
+     * Set up event listener for window resize
+     */
+    private _setupResizeListener;
+    /**
+     * Remove event listener for window resize
+     */
+    private _removeResizeListener;
+    /**
+     * Clean up resources when service is destroyed
+     */
+    destroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPDeviceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPDeviceService>;
+}
+
+/**
+ * Service for applying and resetting text highlighting within specified HTML elements.
+ */
+declare class AXHighlightService {
+    private querySelector;
+    private searchValue;
+    constructor();
+    /**
+     * Highlights all occurrences of a search value within the elements matching the provided query selector.
+     *
+     * @param querySelector - CSS selector to identify target elements.
+     * @param searchValue - Text to search and highlight.
+     */
+    highlight(querySelector: string, searchValue: string): void;
+    /**
+     * Resets all highlighted text within the elements matching the previously used query selector.
+     */
+    clear(): void;
+    /**
+     * Applies highlighting to a specific element by matching text against the search value.
+     *
+     * @param element - The HTML element to apply highlights to.
+     */
+    private applyHighlight;
+    /**
+     * Recursively applies highlighting to text nodes within an element.
+     *
+     * @param element - The current node being processed.
+     * @param searchRegex - Regular expression for matching text to highlight.
+     */
+    private recursivelyHighlight;
+    /**
+     * Generates the HTML structure for highlighted text.
+     *
+     * @param textContent - The original text content to process.
+     * @param searchRegex - Regular expression for matching text to highlight.
+     * @returns A string of HTML with highlighted portions wrapped in span elements.
+     */
+    private createHighlightedHTML;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXHighlightService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXHighlightService>;
+}
+
+declare function extractNestedFieldsWildcard(obj: any, basePath: string, fields: string[]): any;
+declare function setSmart(obj: any, smartPath: string, value: any): any;
+declare function getSmart(obj: any, smartPath: string): any;
+declare function extractValue<T = any>(value: any, key?: string): T | null;
+declare function cleanDeep(obj: any): any;
+type ChangeEntry = {
+    path: string;
+    oldValue: any;
+    newValue: any;
+    arrayDiff?: {
+        added: any[];
+        removed: any[];
+    };
+};
+declare function getChangedPaths(obj1: any, obj2: any): string[];
+declare function getDetailedChanges(obj1: any, obj2: any): ChangeEntry[];
+declare function getEnumValues(enumType: any): {
+    id: string;
+    title: string;
+}[];
+
+/**
+ * Creates a provider instance within an injection context.
+ * Handles dynamic import, injector resolution, and provider instantiation.
+ *
+ * @param loader - Function that returns a promise resolving to the provider class
+ * @returns Promise that resolves to the provider instance
+ *
+ * @example
+ * ```typescript
+ * useFactory: () => createProviderWithInjectionContext(() =>
+ *   import('./settings.provider').then(m => m.AXMSettingProvider)
+ * )
+ * ```
+ */
+declare function createProviderWithInjectionContext<T>(loader: () => Promise<new () => T>): Promise<T>;
+/**
+ * Creates a provider configuration for lazy-loaded providers with injection context.
+ * Simplifies provider registration in NgModule providers array.
+ *
+ * @param token - The injection token to provide
+ * @param loader - Function that returns a promise resolving to the provider class
+ * @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
+ * // 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;
+
+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 { AXHighlightService, AXPActivityLogProvider, AXPActivityLogService, AXPAppStartUpProvider, AXPAppStartUpService, AXPBroadcastEventService, AXPColorPaletteProvider, AXPColorPaletteService, AXPColumnWidthService, AXPComponentLogoConfig, AXPComponentSlot, AXPComponentSlotDirective, AXPComponentSlotModule, AXPComponentSlotRegistryService, AXPContentCheckerDirective, AXPContextChangeEvent, AXPContextStore, AXPCountdownPipe, AXPDataGenerator, AXPDataSourceDefinitionProviderService, AXPDblClickDirective, AXPDefaultColorPalettesProvider, AXPDeviceService, AXPDeviceType, AXPDistributedEventListenerService, AXPElementDataDirective, AXPExportTemplateToken, AXPExpressionEvaluatorScopeProviderContext, AXPExpressionEvaluatorScopeProviderService, AXPExpressionEvaluatorService, AXPFeatureDefinitionProviderContext, AXPGridLayoutDirective, AXPHookService, AXPIconLogoConfig, AXPImageUrlLogoConfig, AXPModuleManifestModule, AXPModuleManifestRegistry, AXPModuleManifestsDataSourceDefinition, AXPMultiLanguageStringResolverService, AXPPlatformScope, AXPResolveMultiLanguageStringPipe, AXPScreenSize, AXPSystemActionType, AXPSystemActions, AXPTagProvider, AXPTagService, AXP_ACTIVITY_LOG_PROVIDER, AXP_COLOR_PALETTE_PROVIDER, AXP_COLUMN_WIDTH_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, MODULE_MANIFESTS_DATASOURCE_NAME, applyFilterArray, applyPagination, applyQueryArray, applySortArray, applySystemActionDefault, cleanDeep, containsHtmlMarkup, createMultiLanguageString, createProviderWithInjectionContext, defaultColumnWidthProvider, extractNestedFieldsWildcard, extractTextFromHtml, extractValue, generateKebabCase, getActionButton, getChangedPaths, getDetailedChanges, getEnumValues, getNestedKeys, getSmart, getSystemActions, isEffectivelyEmptyLocalizedValue, objectKeyValueTransforms, provideLazyProvider, resolveActionLook, resolveMultiLanguageString, resolvePlatformScopeKey, resolvePlatformScopeName, setSmart };
+export type { AXPActionMenuItem, AXPActivityLog, AXPActivityLogChange, AXPApplicationUserReference, AXPBackButton, AXPBadge, AXPBreadcrumbItem, AXPCategorizedEntity, AXPCategorizedEntityDto, AXPCategoryEntity, AXPCategoryEntityWithItems, AXPCategoryListItem, AXPColorPalette, AXPColorPaletteFilterOptions, AXPColumnQuery, AXPColumnWidthMatcher, AXPColumnWidthProvider, AXPCommandMessage, AXPComponentSlotConfig, AXPComponentSlotModuleConfigs, AXPContent, AXPContentDirection, AXPContentType, AXPContextData, AXPContextState, AXPDataSource, AXPDataSourceArray, AXPDataSourceDataFieldDefinition, AXPDataSourceDefinition, AXPDataSourceDefinitionProvider, AXPDataSourceSample, AXPDataSourceType, AXPDataSourceValue, AXPDataType, 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, AXPLazyDataSource, AXPLogoConfig, AXPMaxLengthValidationRule, AXPMaybePromise, AXPMetaData, AXPMiddlewareErrorResponse, AXPMinLengthValidationRule, AXPModuleFeatureDefinition, AXPModuleFeatureDefinitionWithKey, AXPModuleManifest, AXPMultiLanguageString, AXPNavigateActionCommand, AXPNavigateActionOptions, AXPOptionsData, AXPPageStatus, 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, ColumnNameMatcher, ColumnWidthValue, IColumnWithWidth, WidgetTypeMatcher };