@acorex/modules 20.2.4-next.3 → 20.2.4-next.5

package/fesm2022/acorex-modules-common.mjs

@@ -1,32 +1,34 @@
-import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
-import { AXPHomePageService, AXPSearchCommandProvider, AXPSearchService, AXPSettingService, AXPEntityCommandScope, AXPLockService, createAllQueryView, AXPEntityQueryType, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
-import * as i0 from '@angular/core';
-import { inject, Injectable, input, signal, ViewEncapsulation, Component, NgModule, InjectionToken, HostListener, computed, Injector, runInInjectionContext, viewChild } from '@angular/core';
-import { firstValueFrom, Subject } from 'rxjs';
+import { AXP_PERMISSION_DEFINITION_PROVIDER, AXPSessionService } from '@acorex/platform/auth';
+import { AXPEntityCommandScope, createQueryView, AXPRefreshEvent, createAllQueryView, AXPEntityQueryType, AXPSettingService, AXPSearchService, AXPLockService, AXPHomePageService, AXPSearchCommandProvider, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
 import * as i1$2 from '@acorex/platform/core';
-import { objectKeyValueTransforms, AXPPlatformScope, AXPActivityLogService, AXPSystemActionType, extractTextFromHtml, AXPDataGenerator, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER } from '@acorex/platform/core';
+import { AXPActivityLogService, AXPExpressionEvaluatorService, getSmart, AXPPlatformScope, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, AXPSystemActionType, extractTextFromHtml, AXPDataGenerator } from '@acorex/platform/core';
+import { AXPWidgetsModule } from '@acorex/platform/widgets';
+import * as i0 from '@angular/core';
+import { inject, Injectable, NgModule, Injector, runInInjectionContext, input, signal, ViewEncapsulation, Component, InjectionToken, HostListener, computed, viewChild } from '@angular/core';
+import { ensureListActions, actionExists, AXPEntityDefinitionRegistryService, AXP_ENTITY_ACTION_PLUGIN, AXMEntityCrudServiceImpl, entityMasterCrudActions, entityMasterDeleteAction, AXP_ENTITY_DEFINITION_LOADER, AXP_ENTITY_STORAGE_BACKEND, AXP_ENTITY_STORAGE_MIDDLEWARE, detectEntityChanges } from '@acorex/platform/layout/entity';
+import * as i1 from '@acorex/platform/workflow';
+import { createWorkFlowEvent, AXPWorkflowAction, AXPWorkflowModule, AXPWorkflowService } from '@acorex/platform/workflow';
+import { AXDialogService } from '@acorex/components/dialog';
+import { AXLoadingDialogService } from '@acorex/components/loading-dialog';
 import * as i4 from '@acorex/core/translation';
 import { AXTranslationService, AXTranslationModule } from '@acorex/core/translation';
 import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
-import { AXPWidgetsModule } from '@acorex/platform/widgets';
 import * as i3 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import * as i2 from '@acorex/components/button';
 import { AXButtonModule } from '@acorex/components/button';
 import { AXBasePageComponent } from '@acorex/components/page';
-import * as i1 from '@acorex/components/decorators';
+import * as i1$1 from '@acorex/components/decorators';
 import { AXDecoratorModule } from '@acorex/components/decorators';
 import * as i2$1 from '@acorex/platform/layout/components';
-import { AXPCompareViewComponent, AXPComponentSlotModule, AXP_EXTRA_PROPERTY_TYPES } from '@acorex/platform/layout/components';
-import * as i1$1 from '@acorex/platform/workflow';
-import { AXPWorkflowAction, AXPWorkflowModule, AXPWorkflowService } from '@acorex/platform/workflow';
+import { AXPCompareViewComponent, AXP_EXTRA_PROPERTY_TYPES, AXPComponentSlotModule } from '@acorex/platform/layout/components';
 import { AXPopupService } from '@acorex/components/popup';
-import { AXPEntityDefinitionRegistryService, AXP_ENTITY_STORAGE_BACKEND, detectEntityChanges, ensureListActions, actionExists, AXP_ENTITY_STORAGE_MIDDLEWARE, AXP_ENTITY_ACTION_PLUGIN, AXMEntityCrudServiceImpl, entityMasterCrudActions, entityMasterDeleteAction, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 import { AXFormatService } from '@acorex/core/format';
+import { get, set } from 'lodash-es';
+import { provideCommandSetups } from '@acorex/platform/runtime';
 import { AXTextBoxModule } from '@acorex/components/text-box';
+import { Subject, firstValueFrom } from 'rxjs';
 import { AXCalendarService } from '@acorex/core/date-time';
-import { AXDialogService } from '@acorex/components/dialog';
-import { provideCommandSetups } from '@acorex/platform/runtime';
 import * as i1$3 from '@angular/forms';
 import { FormsModule } from '@angular/forms';
 import * as i4$1 from '@acorex/components/form';
@@ -39,1187 +41,1956 @@ import * as i7 from '@acorex/components/text-area';
 import { AXTextAreaModule } from '@acorex/components/text-area';
 import { AXValidationModule } from '@acorex/core/validation';
 
-const config = {
-    i18n: 'common',
-};
-const RootConfig = {
-    config,
-    module: {
-        module: 'common',
-        name: 'Common',
-        title: `t('module-name', {scope:"${config.i18n}"})`,
-        icon: 'fa-light fa-file-invoice',
+const AXPWidgetsList = {
+    Editors: {
+        DocumentAttachment: 'document-attachment-editor',
+        TagBox: 'tagable-editor',
+        CheckBox: 'checkbox-editor',
+        ColorBox: 'color-editor',
+        DateTimeBox: 'date-time-editor',
+        Direction: 'direction',
+        LargeTextBox: 'large-text-editor',
+        NumberBox: 'number-editor',
+        UnitValueBox: 'number-unit-editor',
+        PasswordBox: 'password-editor',
+        QueryBuilder: 'query-builder-editor',
+        RichText: 'rich-text-editor',
+        SelectBox: 'select-editor',
+        SelectionList: 'selection-list-editor',
+        TextBox: 'text-editor',
+        InlineDataTable: 'table-editor',
+        ToggleSwitch: 'toggle-editor',
+        FileTypeExtension: 'file-type-extension',
+        MapBox: 'map',
+        MediaGallery: 'gallery',
+        SignatureBox: 'signature',
+        LookupBox: 'lookup-editor',
+    },
+    Layouts: {
+        BlockLayout: 'block-layout',
+        RepeaterLayout: 'repeater-layout',
+        TextBlockLayout: 'text-block-layout',
+        FormField: 'form-field',
+    },
+    Actions: {
+        ActionButton: 'button-action',
+    },
+    Advanced: {
+        QRCode: 'qrcode',
+    },
+    Templates: {
+        Designer: 'template-designer',
     },
-    entities: {},
 };
 
-class AXMMenuProvider {
-    constructor() {
-        this.sessionService = inject(AXPSessionService);
-        this.homePageService = inject(AXPHomePageService);
-    }
-    async provide(context) {
-        const scope = RootConfig.config.i18n;
-        const module = RootConfig.module;
-        const appName = this.sessionService.application?.name;
-        const isAuthorized = await firstValueFrom(this.sessionService.isAuthorized$);
-        if (!isAuthorized) {
-            return;
+const archivePlugin = {
+    name: 'archive',
+    order: 65,
+    apply: (ctx) => {
+        ensureListActions(ctx);
+        //#region ----   Add isArchived Property   ----
+        // Ensure settings group exists
+        const groupId = 'settings';
+        const groups = ctx.groups.list() ?? [];
+        if (!groups.some((g) => g.id === groupId)) {
+            ctx.groups.add({ id: groupId, title: '@general:terms.settings' });
         }
-        //
-        const homePagePath = this.homePageService.getCurrent().path;
-        if (homePagePath) {
-            context.addItems([
-                {
-                    priority: -9,
-                    text: `t('home',{scope:'common'})`,
-                    path: homePagePath,
-                    icon: 'fa-light fa-grid-2',
-                    data: {
-                    //requiredPermission: '',
+        // Add isArchived property if it doesn't exist
+        const props = ctx.properties.list();
+        if (!props.some((p) => p.name === 'isArchived')) {
+            ctx.properties.add({
+                name: 'isArchived',
+                title: '@general:terms.is-archived',
+                groupId,
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsList.Editors.ToggleSwitch,
+                        options: {
+                            // Default to false (not archived)
+                            defaultValue: false,
+                            // trulyText: '@general:terms.archived',
+                            // falsyText: '@general:terms.active',
+                            negative: true,
+                            nullValue: false,
+                        },
                     },
                 },
-            ]);
+                validations: [],
+                options: {
+                    sort: { enabled: true },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true }
+                    }
+                }
+            });
         }
-        context.find('user-profile').addItems([
-            {
-                text: `t('user.title', {scope: "settings"})`,
-                name: 'user-settings',
-                icon: 'fa-light fa-gear',
-                path: `/${this.sessionService.application?.name}/settings/user`,
-            },
-        ]);
-        context.addItems([
-            {
-                name: 'tenant-application-settings',
-                priority: 10000000,
-                text: `t('tenant.title', {scope: "settings"})`,
-                type: 'menu',
-                icon: 'fa-light fa-gear',
-                path: `/${appName}/settings/tenant`,
-                data: {
-                    requiredPermission: 'admin',
-                },
-            },
-        ]);
-    }
-}
-
-class AXMPermissionDefinitionProvider {
-    async define(context) {
-        // context.addPermissions([
-        //   {
-        //     name: 'view_templates',
-        //     title: 'Permission to view templates',
-        //     isArchived: false,
-        //   },
-        // ]);
-    }
-}
+        // Add isArchived to columns for list view
+        const columns = ctx.columns.list() ?? [];
+        if (!columns.some((c) => c.name === 'isArchived')) {
+            ctx.columns.add({
+                name: 'isArchived',
+                title: '@general:terms.is-active',
+                width: 100,
+                sortable: true,
+                filterable: true,
+            });
+        }
+        //#endregion
+        //#region ----   Add Archive Actions   ----
+        ctx.interfaces.update((i) => {
+            const archiveCmdName = 'archive-entity';
+            const restoreArchiveCmdName = 'restore-archive-entity';
+            const bulkArchiveCmdName = 'bulk-archive-entity';
+            const bulkRestoreArchiveCmdName = 'bulk-restore-archive-entity';
+            // Add archive action to list view
+            const listActions = i.master.list.actions;
+            if (!actionExists(listActions, archiveCmdName)) {
+                listActions.push({
+                    title: '@general:actions.archive.title',
+                    command: {
+                        name: archiveCmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'archive',
+                    scope: AXPEntityCommandScope.Individual,
+                    hidden: `{{ context.eval("isArchived") }}`,
+                });
+            }
+            // Add restore archive action to list view
+            if (!actionExists(listActions, restoreArchiveCmdName)) {
+                listActions.push({
+                    title: '@general:actions.restore-archive.title',
+                    command: {
+                        name: restoreArchiveCmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'update',
+                    scope: AXPEntityCommandScope.Individual,
+                    hidden: `{{ !context.eval("isArchived") }}`,
+                });
+            }
+            // Add bulk archive action to list view
+            if (!actionExists(listActions, bulkArchiveCmdName)) {
+                listActions.push({
+                    title: '@general:actions.bulk-archive.title',
+                    command: {
+                        name: bulkArchiveCmdName,
+                        options: {
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'archive',
+                    scope: AXPEntityCommandScope.Selected,
+                });
+            }
+            // Add bulk restore archive action to list view
+            if (!actionExists(listActions, bulkRestoreArchiveCmdName)) {
+                listActions.push({
+                    title: '@general:actions.bulk-restore-archive.title',
+                    command: {
+                        name: bulkRestoreArchiveCmdName,
+                        options: {
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'update',
+                    scope: AXPEntityCommandScope.Selected,
+                });
+            }
+            // Add archive action to single view
+            const singleActions = i.master.single.actions;
+            if (!actionExists(singleActions, archiveCmdName)) {
+                singleActions.push({
+                    title: '@general:actions.archive.title',
+                    command: {
+                        name: archiveCmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'archive',
+                    scope: AXPEntityCommandScope.Individual,
+                    hidden: `{{ context.eval("isArchived") }}`,
+                });
+            }
+            // Add restore archive action to single view
+            if (!actionExists(singleActions, restoreArchiveCmdName)) {
+                singleActions.push({
+                    title: '@general:actions.restore-archive.title',
+                    command: {
+                        name: restoreArchiveCmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'update',
+                    scope: AXPEntityCommandScope.Individual,
+                    hidden: `{{ !context.eval("isArchived") }}`,
+                });
+            }
+            return i;
+        });
+        //#endregion
+        //#region ----   Update Interface Layouts   ----
+        // Ensure update view includes isArchived
+        ctx.interfaces.master.modify.update((update) => {
+            const next = update ?? { sections: [], properties: [] };
+            next.sections = next.sections ?? [];
+            if (!next.sections.some((s) => s.id === groupId)) {
+                next.sections.push({ id: groupId });
+            }
+            next.properties = next.properties ?? [];
+            if (!next.properties.some((p) => p.name === 'isArchived')) {
+                next.properties.push({
+                    name: 'isArchived',
+                    layout: {
+                        positions: { lg: { colSpan: 6, order: 90 } },
+                    },
+                });
+            }
+            return next;
+        });
+        // Ensure single view includes isArchived
+        ctx.interfaces.master.single.update((single) => {
+            const next = single ?? { title: ctx.entity.title, sections: [], properties: [] };
+            next.sections = next.sections ?? [];
+            if (!next.sections.some((s) => s.id === groupId)) {
+                next.sections.push({ id: groupId });
+            }
+            next.properties = next.properties ?? [];
+            if (!next.properties.some((p) => p.name === 'isArchived')) {
+                next.properties.push({
+                    name: 'isArchived',
+                    layout: {
+                        positions: { lg: { colSpan: 6, order: 90 } },
+                    },
+                });
+            }
+            return next;
+        });
+        // Add archive view to show only archived items
+        ctx.interfaces.master.list.update((list) => {
+            const next = list ?? { actions: [], views: [] };
+            next.views = next.views ?? [];
+            // Check if archive view already exists
+            if (!next.views.some((v) => v.name === 'archived')) {
+                next.views.push(createQueryView('archived', '@general:terms.archived', false, {
+                    conditions: [
+                        {
+                            name: 'isArchived',
+                            operator: { type: 'equal' },
+                            value: true,
+                            hidden: true
+                        },
+                    ],
+                    sorts: [
+                        { name: 'archivedAt', dir: 'desc' },
+                        { name: 'title', dir: 'asc' },
+                    ],
+                }));
+            }
+            return next;
+        });
+        //#endregion
+    },
+};
 
-class AXMSearchCommandProvider extends AXPSearchCommandProvider {
+const AXPEntityArchivedEvent = createWorkFlowEvent('[Entity] Archived');
+class AXPEntityArchiveAction extends AXPWorkflowAction {
     constructor() {
         super(...arguments);
-        this.commands = [
-        // {
-        //   group: 'command',
-        //  title: 'New Form Template',
-        //  icon: RootConfig.entities.template.icon,
-        //  description: 'Create a new form template for designing reusable forms.', // Added description
-        //  commands: {
-        //    'create-entity': {
-        //      entity: `${RootConfig.module.name}.${RootConfig.entities.template.name}`,
-        //    },
-        //  },
-        // }
-        ];
-    }
-}
-
-var AXMLockSystemSettings;
-(function (AXMLockSystemSettings) {
-    AXMLockSystemSettings["LockSystem"] = "general:lock-system:lock";
-})(AXMLockSystemSettings || (AXMLockSystemSettings = {}));
-
-class AXMSettingProvider {
-    constructor(injector) {
-        this.injector = injector;
-        this.translateService = this.injector.get(AXTranslationService);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.dialogService = inject(AXDialogService);
+        this.loadingDialog = inject(AXLoadingDialogService);
+        this.translationService = inject(AXTranslationService);
     }
-    async provide(context) {
-        const trans = async (key) => await this.translateService.translateAsync(`settings.${key}`, { scope: 'general' });
-        // Find the 'General Settings' group
-        const group = context.group('general');
-        if (!group) {
+    async execute(context) {
+        const refId = context.getVariable('options.refId');
+        const refType = context.getVariable('options.refType');
+        if (!refId || !refType) {
+            throw new Error('Missing required parameters: refId and refType');
+        }
+        const [moduleName, entityName] = refType.split('.');
+        const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+        // Show confirmation dialog
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('@general:actions.archive.confirm.title'), await this.translationService.translateAsync('@general:actions.archive.confirm.message'), 'warning', 'horizontal', false, 'cancel');
+        if (!dialogResult.result) {
+            context.setOutput('isCanceled', true);
+            context.setOutput('error', 'Operation cancelled by user');
             return;
         }
-        // Add the 'Release Notes' setting
-        group.addSection('lock-system', await trans('general.lock-system.lock.title'), await trans('general.lock-system.lock.description')).addSetting({
-            key: AXMLockSystemSettings.LockSystem,
-            title: await trans('general.lock-system.lock.title'),
-            scope: AXPPlatformScope.Tenant,
-            isInherited: true,
-            defaultValue: false,
-            valueTransforms: objectKeyValueTransforms('id'),
-            widget: {
-                type: AXPWidgetsCatalog.toggle,
-                options: {
-                    label: null,
-                }
-            },
-            description: await trans('general.lock-system.lock.description'),
+        // Show loading dialog
+        const loadingDialog = this.loadingDialog.show({
+            title: await this.translationService.translateAsync('@general:actions.archive.confirm.processing'),
+            mode: 'indeterminate',
+            status: 'Archiving...',
         });
+        try {
+            // Get the current entity data
+            const currentData = await this.getEntityData(refType, refId);
+            // Prepare archive data
+            const archiveData = this.prepareArchiveData(currentData);
+            // Update the entity to mark it as archived
+            if (entityDefinition.commands?.update) {
+                const updateExec = entityDefinition.commands.update.execute;
+                await updateExec(archiveData);
+                context.setOutput('id', refId);
+                context.setOutput('isCanceled', false);
+                // Set refresh metadata
+                if (entityDefinition.parentKey && currentData[entityDefinition.parentKey]) {
+                    context.setVariable('meta', { refreshTargetId: currentData[entityDefinition.parentKey] });
+                }
+            }
+            else {
+                throw new Error('Entity does not support update operation');
+            }
+        }
+        catch (error) {
+            console.error('Archive operation failed:', error);
+            context.setOutput('error', error instanceof Error ? error.message : 'Unknown error');
+            context.setOutput('isCanceled', true);
+        }
+        finally {
+            loadingDialog.close();
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMSettingProvider, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMSettingProvider }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMSettingProvider, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i0.Injector }] });
-
-class AXPComparePopupComponent extends AXBasePageComponent {
-    constructor() {
-        super(...arguments);
-        this.inputs = input(...(ngDevMode ? [undefined, { debugName: "inputs" }] : []));
-        this.isBusy = signal(false, ...(ngDevMode ? [{ debugName: "isBusy" }] : []));
-        this.mode = input('compare', ...(ngDevMode ? [{ debugName: "mode" }] : []));
+    async getEntityData(refType, refId) {
+        try {
+            // Use the entity's byKey query to get actual data
+            const [moduleName, entityName] = refType.split('.');
+            const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+            if (entityDefinition.queries?.byKey) {
+                const queryExec = entityDefinition.queries.byKey.execute;
+                return await queryExec(refId);
+            }
+            // Fallback to basic structure if no query available
+            return { id: refId };
+        }
+        catch (error) {
+            console.error('Failed to retrieve entity data:', error);
+            throw new Error(`Failed to retrieve entity data: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
     }
-    ngOnInit() {
-        super.ngOnInit();
-        // Any additional initialization logic can go here
+    prepareArchiveData(currentData) {
+        const archiveData = { ...currentData };
+        // Set the archived flag
+        archiveData.isArchived = true;
+        // Optionally add archive timestamp
+        archiveData.archivedAt = new Date();
+        return archiveData;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPComparePopupComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.1.6", type: AXPComparePopupComponent, isStandalone: true, selector: "axp-compare-popup", inputs: { inputs: { classPropertyName: "inputs", publicName: "inputs", isSignal: true, isRequired: false, transformFunction: null }, mode: { classPropertyName: "mode", publicName: "mode", isSignal: true, isRequired: false, transformFunction: null } }, providers: [], usesInheritance: true, ngImport: i0, template: "<ax-content>\n  <div class=\"ax-p-6 ax-min-h-[30vh] ax-overflow-y-auto\">\n    <axp-compare-view [inputs]=\"inputs()\" [mode]=\"mode()\"></axp-compare-view>\n  </div>\n</ax-content>\n<ax-footer>\n  <ax-prefix></ax-prefix>\n  <ax-suffix>\n    <ax-button [text]=\"'close' | translate | async\" look=\"solid\" color=\"primary\" (onClick)=\"close()\"> </ax-button>\n  </ax-suffix>\n</ax-footer>", dependencies: [{ kind: "ngmodule", type: 
-                // Angular
-                CommonModule }, { kind: "ngmodule", type: 
-                // ACoreX
-                AXDecoratorModule }, { kind: "component", type: i1.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "component", type: 
-                // Compare View
-                AXPCompareViewComponent, selector: "axp-compare-view", inputs: ["inputs", "mode"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.AXTranslatorPipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityArchiveAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityArchiveAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPComparePopupComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'axp-compare-popup', standalone: true, imports: [
-                        // Angular
-                        CommonModule,
-                        // ACoreX
-                        AXDecoratorModule,
-                        AXButtonModule,
-                        AXTranslationModule,
-                        // Compare View
-                        AXPCompareViewComponent
-                    ], encapsulation: ViewEncapsulation.None, providers: [], template: "<ax-content>\n  <div class=\"ax-p-6 ax-min-h-[30vh] ax-overflow-y-auto\">\n    <axp-compare-view [inputs]=\"inputs()\" [mode]=\"mode()\"></axp-compare-view>\n  </div>\n</ax-content>\n<ax-footer>\n  <ax-prefix></ax-prefix>\n  <ax-suffix>\n    <ax-button [text]=\"'close' | translate | async\" look=\"solid\" color=\"primary\" (onClick)=\"close()\"> </ax-button>\n  </ax-suffix>\n</ax-footer>" }]
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityArchiveAction, decorators: [{
+            type: Injectable
         }] });
-
-var comparePopup_component = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AXPComparePopupComponent: AXPComparePopupComponent
-});
-
-class AXMComparePopupStartAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.popupService = inject(AXPopupService);
-        this.translate = inject(AXTranslationService);
-    }
+class AXPEntityArchiveSuccessAction extends AXPWorkflowAction {
     async execute(context) {
-        const comp = (await Promise.resolve().then(function () { return comparePopup_component; })).AXPComparePopupComponent;
-        this.popupService.open(comp, {
-            title: await this.translate.translateAsync('Compare'),
-            size: 'lg',
-            data: {
-                inputs: signal(context.getVariable('inputs')),
-                mode: signal(context.getVariable('mode')),
-            },
-        });
+        const refType = context.getVariable('options.refType');
+        const id = context.getOutput('id');
+        const meta = context.getVariable('meta');
+        // Dispatch archive event
+        this.dispatch(AXPEntityArchivedEvent({
+            entity: refType,
+            id,
+            meta
+        }));
+        // Refresh the entity list
+        this.dispatch(AXPRefreshEvent({
+            entity: refType,
+            meta
+        }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMComparePopupStartAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMComparePopupStartAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityArchiveSuccessAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityArchiveSuccessAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMComparePopupStartAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityArchiveSuccessAction, decorators: [{
             type: Injectable
         }] });
-class AXMCompareEntityRecordsAction extends AXPWorkflowAction {
+const AXPArchiveEntityWorkflow = {
+    startStepId: 'archive-entity',
+    steps: {
+        'archive-entity': {
+            action: 'AXPEntityArchiveAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
+                    nextStepId: 'show-success-toast',
+                },
+            ],
+        },
+        'show-success-toast': {
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-archived',
+                content: 'workflow.entity-archived-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'archive-success',
+                },
+            ],
+        },
+        'archive-success': {
+            action: 'AXPEntityArchiveSuccessAction',
+        },
+    },
+};
+
+const AXPEntityUnarchivedEvent = createWorkFlowEvent('[Entity] Unarchived');
+class AXPEntityUnarchiveAction extends AXPWorkflowAction {
     constructor() {
         super(...arguments);
-        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.dialogService = inject(AXDialogService);
+        this.loadingDialog = inject(AXLoadingDialogService);
+        this.translationService = inject(AXTranslationService);
     }
     async execute(context) {
-        const [moduleName, entityName] = context.getVariable('entity').split('.');
-        const entityRef = await this.entityRegistry.resolve(moduleName, entityName);
-        const records = context.getVariable('data');
-        const ids = records?.map((r) => r.id);
-        const getById = entityRef.queries.byKey?.execute;
-        //
-        const fields = entityRef.properties
-            .filter(p => p.schema.interface && p.schema.hidden != true)
-            .map((p) => ({
-            path: p.name,
-            title: p.title,
-            description: p.description,
-            widget: {
-                type: p.schema.interface?.type,
-                name: p.name,
-                path: p.name,
-                options: p.schema.interface?.options,
-            },
-        }));
-        const objects = await Promise.all(ids.map(async (c) => {
-            const object = await getById(c);
-            return {
-                id: object.id,
-                title: object.title,
-                description: object.description,
-                context: object,
-            };
-        }));
-        const inputs = {
-            fields: fields,
-            objects: objects,
-        };
-        //
-        context.setVariable('inputs', inputs);
-        context.setVariable('mode', 'records');
-        context.setOutput('result', true);
+        const refId = context.getVariable('options.refId');
+        const refType = context.getVariable('options.refType');
+        if (!refId || !refType) {
+            throw new Error('Missing required parameters: refId and refType');
+        }
+        const [moduleName, entityName] = refType.split('.');
+        const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+        // Show confirmation dialog
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('@general:actions.restore-archive.confirm.title'), await this.translationService.translateAsync('@general:actions.restore-archive.confirm.message'), 'warning', 'horizontal', false, 'cancel');
+        if (!dialogResult.result) {
+            context.setOutput('isCanceled', true);
+            context.setOutput('error', 'Operation cancelled by user');
+            return;
+        }
+        // Show loading dialog
+        const loadingDialog = this.loadingDialog.show({
+            title: await this.translationService.translateAsync('@general:actions.restore-archive.confirm.processing'),
+            mode: 'indeterminate',
+            status: 'Unarchiving...',
+        });
+        try {
+            // Get the current entity data
+            const currentData = await this.getEntityData(refType, refId);
+            // Prepare unarchive data
+            const unarchiveData = this.prepareUnarchiveData(currentData);
+            // Update the entity to mark it as not archived
+            if (entityDefinition.commands?.update) {
+                const updateExec = entityDefinition.commands.update.execute;
+                await updateExec(unarchiveData);
+                context.setOutput('id', refId);
+                context.setOutput('isCanceled', false);
+                // Set refresh metadata
+                if (entityDefinition.parentKey && currentData[entityDefinition.parentKey]) {
+                    context.setVariable('meta', { refreshTargetId: currentData[entityDefinition.parentKey] });
+                }
+            }
+            else {
+                throw new Error('Entity does not support update operation');
+            }
+        }
+        catch (error) {
+            console.error('Unarchive operation failed:', error);
+            context.setOutput('error', error instanceof Error ? error.message : 'Unknown error');
+            context.setOutput('isCanceled', true);
+        }
+        finally {
+            loadingDialog.close();
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordsAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordsAction }); }
+    async getEntityData(refType, refId) {
+        try {
+            // Use the entity's byKey query to get actual data
+            const [moduleName, entityName] = refType.split('.');
+            const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+            if (entityDefinition.queries?.byKey) {
+                const queryExec = entityDefinition.queries.byKey.execute;
+                return await queryExec(refId);
+            }
+            // Fallback to basic structure if no query available
+            return { id: refId };
+        }
+        catch (error) {
+            console.error('Failed to retrieve entity data:', error);
+            throw new Error(`Failed to retrieve entity data: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    prepareUnarchiveData(currentData) {
+        const unarchiveData = { ...currentData };
+        // Set the archived flag to false
+        unarchiveData.isArchived = false;
+        // Remove archive timestamp
+        delete unarchiveData.archivedAt;
+        return unarchiveData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityUnarchiveAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityUnarchiveAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordsAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityUnarchiveAction, decorators: [{
             type: Injectable
         }] });
-class AXMCompareEntityRecordVersionsAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
-        this.activityLogService = inject(AXPActivityLogService);
-        this.formatService = inject(AXFormatService);
-        this.translate = inject(AXTranslationService);
-    }
+class AXPEntityUnarchiveSuccessAction extends AXPWorkflowAction {
     async execute(context) {
-        const [moduleName, entityName] = context.getVariable('entity').split('.');
-        const entityRef = await this.entityRegistry.resolve(moduleName, entityName);
-        const refId = context.getVariable('data.refId');
-        const refType = context.getVariable('data.refType');
-        const ids = context.getVariable('data.ids');
-        const histories = await this.activityLogService.getHistoryByIds(refId, refType, ids);
-        //
-        const fields = entityRef.properties
-            .filter(p => p.schema.interface && p.schema.hidden != true)
-            .map((p) => ({
-            path: p.name,
-            title: p.title,
-            description: p.description,
-            widget: {
-                type: p.schema.interface?.type,
-                name: p.name,
-                path: p.name,
-                options: p.schema.interface?.options,
-            },
+        const refType = context.getVariable('options.refType');
+        const id = context.getOutput('id');
+        const meta = context.getVariable('meta');
+        // Dispatch unarchive event
+        this.dispatch(AXPEntityUnarchivedEvent({
+            entity: refType,
+            id,
+            meta
+        }));
+        // Refresh the entity list
+        this.dispatch(AXPRefreshEvent({
+            entity: refType,
+            meta
         }));
-        const objects = await Promise.all(histories.map(async (h) => ({
-            id: h.id,
-            title: await this.translate.translateAsync(`@activity-log:${h.changeType == 'update' ? 'updated' : 'created'}-by-title`, {
-                params: {
-                    user: h.user?.title,
-                    date: this.formatService.format(h.date, 'datetime', { format: 'short' }),
-                }
-            }),
-            description: h.user?.title,
-            context: h.data,
-        })));
-        const inputs = {
-            fields: fields,
-            objects: objects,
-        };
-        //
-        context.setVariable('inputs', inputs);
-        context.setVariable('mode', 'changes');
-        context.setOutput('result', true);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordVersionsAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordVersionsAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityUnarchiveSuccessAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityUnarchiveSuccessAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordVersionsAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityUnarchiveSuccessAction, decorators: [{
             type: Injectable
         }] });
-const AXMCompareEntityRecordsWorkflow = {
-    startStepId: 'start',
+const AXPUnarchiveEntityWorkflow = {
+    startStepId: 'unarchive-entity',
     steps: {
-        start: {
-            action: 'show-entity-records-compare-action',
+        'unarchive-entity': {
+            action: 'AXPEntityUnarchiveAction',
             nextSteps: [
                 {
-                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
-                    nextStepId: 'show-popup',
-                }
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
+                    nextStepId: 'show-success-toast',
+                },
             ],
         },
-        'show-popup': {
-            action: 'show-compare-popup-action',
+        'show-success-toast': {
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-unarchived',
+                content: 'workflow.entity-unarchived-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'unarchive-success',
+                },
+            ],
+        },
+        'unarchive-success': {
+            action: 'AXPEntityUnarchiveSuccessAction',
         },
     },
 };
-const AXMCompareEntityRecordVersionsWorkflow = {
-    startStepId: 'start',
+
+const AXPEntityBulkArchivedEvent = createWorkFlowEvent('[Entity] Bulk Archived');
+class AXPEntityBulkArchiveAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.dialogService = inject(AXDialogService);
+        this.loadingDialog = inject(AXLoadingDialogService);
+        this.translationService = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const refType = context.getVariable('options.refType');
+        const selectedIds = context.getVariable('selectedIds') || [];
+        if (!refType || selectedIds.length === 0) {
+            throw new Error('Missing required parameters: refType and selectedIds');
+        }
+        const [moduleName, entityName] = refType.split('.');
+        const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+        // Show confirmation dialog
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('@general:actions.bulk-archive.confirm.title'), await this.translationService.translateAsync('@general:actions.bulk-archive.confirm.message', {
+            params: { count: selectedIds.length }
+        }), 'warning', 'horizontal', false, 'cancel');
+        if (!dialogResult.result) {
+            context.setOutput('isCanceled', true);
+            context.setOutput('error', 'Operation cancelled by user');
+            return;
+        }
+        // Show loading dialog
+        const loadingDialog = this.loadingDialog.show({
+            title: await this.translationService.translateAsync('@general:actions.bulk-archive.confirm.processing'),
+            mode: 'indeterminate',
+            status: `Archiving ${selectedIds.length} items...`,
+        });
+        try {
+            const processedIds = [];
+            const failedIds = [];
+            // Process each selected entity
+            for (const id of selectedIds) {
+                try {
+                    // Get the current entity data
+                    const currentData = await this.getEntityData(refType, id);
+                    // Prepare archive data
+                    const archiveData = this.prepareArchiveData(currentData);
+                    // Update the entity to mark it as archived
+                    if (entityDefinition.commands?.update) {
+                        const updateExec = entityDefinition.commands.update.execute;
+                        await updateExec(archiveData);
+                        processedIds.push(id);
+                    }
+                    else {
+                        failedIds.push(id);
+                    }
+                }
+                catch (error) {
+                    console.error(`Failed to archive entity ${id}:`, error);
+                    failedIds.push(id);
+                }
+            }
+            context.setOutput('processedIds', processedIds);
+            context.setOutput('failedIds', failedIds);
+            context.setOutput('isCanceled', false);
+            context.setOutput('totalProcessed', processedIds.length);
+            context.setOutput('totalFailed', failedIds.length);
+        }
+        catch (error) {
+            console.error('Bulk archive operation failed:', error);
+            context.setOutput('error', error instanceof Error ? error.message : 'Unknown error');
+            context.setOutput('isCanceled', true);
+        }
+        finally {
+            loadingDialog.close();
+        }
+    }
+    async getEntityData(refType, refId) {
+        try {
+            // Use the entity's byKey query to get actual data
+            const [moduleName, entityName] = refType.split('.');
+            const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+            if (entityDefinition.queries?.byKey) {
+                const queryExec = entityDefinition.queries.byKey.execute;
+                return await queryExec(refId);
+            }
+            // Fallback to basic structure if no query available
+            return { id: refId };
+        }
+        catch (error) {
+            console.error('Failed to retrieve entity data:', error);
+            throw new Error(`Failed to retrieve entity data: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    prepareArchiveData(currentData) {
+        const archiveData = { ...currentData };
+        // Set the archived flag
+        archiveData.isArchived = true;
+        // Optionally add archive timestamp
+        archiveData.archivedAt = new Date();
+        return archiveData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkArchiveAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkArchiveAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkArchiveAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPEntityBulkArchiveSuccessAction extends AXPWorkflowAction {
+    async execute(context) {
+        const refType = context.getVariable('options.refType');
+        const processedIds = context.getOutput('processedIds') || [];
+        const failedIds = context.getOutput('failedIds') || [];
+        const totalProcessed = context.getOutput('totalProcessed') || 0;
+        const totalFailed = context.getOutput('totalFailed') || 0;
+        // Dispatch bulk archive event
+        this.dispatch(AXPEntityBulkArchivedEvent({
+            entity: refType,
+            ids: processedIds,
+            meta: { failedIds, totalProcessed, totalFailed }
+        }));
+        // Refresh the entity list
+        this.dispatch(AXPRefreshEvent({
+            entity: refType,
+            meta: { refreshType: 'bulk-archive' }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkArchiveSuccessAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkArchiveSuccessAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkArchiveSuccessAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPBulkArchiveEntityWorkflow = {
+    startStepId: 'bulk-archive-entity',
     steps: {
-        start: {
-            action: 'show-entity-record-versions-compare-action',
+        'bulk-archive-entity': {
+            action: 'AXPEntityBulkArchiveAction',
             nextSteps: [
                 {
-                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
-                    nextStepId: 'show-popup',
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
+                    nextStepId: 'show-success-toast',
+                },
+            ],
+        },
+        'show-success-toast': {
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-bulk-archived',
+                content: 'workflow.entity-bulk-archived-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'bulk-archive-success',
+                },
+            ],
+        },
+        'bulk-archive-success': {
+            action: 'AXPEntityBulkArchiveSuccessAction',
+        },
+    },
+};
+
+const AXPEntityBulkUnarchivedEvent = createWorkFlowEvent('[Entity] Bulk Unarchived');
+class AXPEntityBulkUnarchiveAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.dialogService = inject(AXDialogService);
+        this.loadingDialog = inject(AXLoadingDialogService);
+        this.translationService = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const refType = context.getVariable('options.refType');
+        const selectedIds = context.getVariable('selectedIds') || [];
+        if (!refType || selectedIds.length === 0) {
+            throw new Error('Missing required parameters: refType and selectedIds');
+        }
+        const [moduleName, entityName] = refType.split('.');
+        const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+        // Show confirmation dialog
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('@general:actions.bulk-restore-archive.confirm.title'), await this.translationService.translateAsync('@general:actions.bulk-restore-archive.confirm.message', {
+            params: { count: selectedIds.length }
+        }), 'warning', 'horizontal', false, 'cancel');
+        if (!dialogResult.result) {
+            context.setOutput('isCanceled', true);
+            context.setOutput('error', 'Operation cancelled by user');
+            return;
+        }
+        // Show loading dialog
+        const loadingDialog = this.loadingDialog.show({
+            title: await this.translationService.translateAsync('@general:actions.bulk-restore-archive.confirm.processing'),
+            mode: 'indeterminate',
+            status: `Unarchiving ${selectedIds.length} items...`,
+        });
+        try {
+            const processedIds = [];
+            const failedIds = [];
+            // Process each selected entity
+            for (const id of selectedIds) {
+                try {
+                    // Get the current entity data
+                    const currentData = await this.getEntityData(refType, id);
+                    // Prepare unarchive data
+                    const unarchiveData = this.prepareUnarchiveData(currentData);
+                    // Update the entity to mark it as not archived
+                    if (entityDefinition.commands?.update) {
+                        const updateExec = entityDefinition.commands.update.execute;
+                        await updateExec(unarchiveData);
+                        processedIds.push(id);
+                    }
+                    else {
+                        failedIds.push(id);
+                    }
                 }
+                catch (error) {
+                    console.error(`Failed to restore entity ${id}:`, error);
+                    failedIds.push(id);
+                }
+            }
+            context.setOutput('processedIds', processedIds);
+            context.setOutput('failedIds', failedIds);
+            context.setOutput('isCanceled', false);
+            context.setOutput('totalProcessed', processedIds.length);
+            context.setOutput('totalFailed', failedIds.length);
+        }
+        catch (error) {
+            console.error('Bulk unarchive operation failed:', error);
+            context.setOutput('error', error instanceof Error ? error.message : 'Unknown error');
+            context.setOutput('isCanceled', true);
+        }
+        finally {
+            loadingDialog.close();
+        }
+    }
+    async getEntityData(refType, refId) {
+        try {
+            // Use the entity's byKey query to get actual data
+            const [moduleName, entityName] = refType.split('.');
+            const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+            if (entityDefinition.queries?.byKey) {
+                const queryExec = entityDefinition.queries.byKey.execute;
+                return await queryExec(refId);
+            }
+            // Fallback to basic structure if no query available
+            return { id: refId };
+        }
+        catch (error) {
+            console.error('Failed to retrieve entity data:', error);
+            throw new Error(`Failed to retrieve entity data: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    prepareUnarchiveData(currentData) {
+        const unarchiveData = { ...currentData };
+        // Set the archived flag to false
+        unarchiveData.isArchived = false;
+        // Remove archive timestamp
+        delete unarchiveData.archivedAt;
+        return unarchiveData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkUnarchiveAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkUnarchiveAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkUnarchiveAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPEntityBulkUnarchiveSuccessAction extends AXPWorkflowAction {
+    async execute(context) {
+        const refType = context.getVariable('options.refType');
+        const processedIds = context.getOutput('processedIds') || [];
+        const failedIds = context.getOutput('failedIds') || [];
+        const totalProcessed = context.getOutput('totalProcessed') || 0;
+        const totalFailed = context.getOutput('totalFailed') || 0;
+        // Dispatch bulk unarchive event
+        this.dispatch(AXPEntityBulkUnarchivedEvent({
+            entity: refType,
+            ids: processedIds,
+            meta: { failedIds, totalProcessed, totalFailed }
+        }));
+        // Refresh the entity list
+        this.dispatch(AXPRefreshEvent({
+            entity: refType,
+            meta: { refreshType: 'bulk-unarchive' }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkUnarchiveSuccessAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkUnarchiveSuccessAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityBulkUnarchiveSuccessAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPBulkUnarchiveEntityWorkflow = {
+    startStepId: 'bulk-unarchive-entity',
+    steps: {
+        'bulk-unarchive-entity': {
+            action: 'AXPEntityBulkUnarchiveAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
+                    nextStepId: 'show-success-toast',
+                },
             ],
         },
-        'show-popup': {
-            action: 'show-compare-popup-action',
+        'show-success-toast': {
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-bulk-unarchived',
+                content: 'workflow.entity-bulk-unarchived-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'bulk-unarchive-success',
+                },
+            ],
+        },
+        'bulk-unarchive-success': {
+            action: 'AXPEntityBulkUnarchiveSuccessAction',
         },
     },
 };
 
-class AXPCompareModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCompareModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXPCompareModule, imports: [AXPComparePopupComponent, i1$1.AXPWorkflowModule], exports: [AXPComparePopupComponent] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCompareModule, imports: [AXPComparePopupComponent,
-            AXPWorkflowModule.forChild({
+class AXPArchivePluginModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPArchivePluginModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXPArchivePluginModule, imports: [i1.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPArchivePluginModule, providers: [
+            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: archivePlugin },
+        ], imports: [AXPWorkflowModule.forChild({
                 actions: {
-                    'show-compare-popup-action': AXMComparePopupStartAction,
-                    'show-entity-records-compare-action': AXMCompareEntityRecordsAction,
-                    'show-entity-record-versions-compare-action': AXMCompareEntityRecordVersionsAction,
+                    AXPEntityArchiveAction,
+                    AXPEntityArchiveSuccessAction,
+                    AXPEntityUnarchiveAction,
+                    AXPEntityUnarchiveSuccessAction,
+                    AXPEntityBulkArchiveAction,
+                    AXPEntityBulkArchiveSuccessAction,
+                    AXPEntityBulkUnarchiveAction,
+                    AXPEntityBulkUnarchiveSuccessAction,
                 },
                 workflows: {
-                    'show-entity-records-compare': AXMCompareEntityRecordsWorkflow,
-                    'show-entity-record-versions-compare': AXMCompareEntityRecordVersionsWorkflow,
+                    'archive-entity': AXPArchiveEntityWorkflow,
+                    'restore-archive-entity': AXPUnarchiveEntityWorkflow,
+                    'bulk-archive-entity': AXPBulkArchiveEntityWorkflow,
+                    'bulk-restore-archive-entity': AXPBulkUnarchiveEntityWorkflow,
                 },
             })] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCompareModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPArchivePluginModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
-                        AXPComparePopupComponent,
                         AXPWorkflowModule.forChild({
                             actions: {
-                                'show-compare-popup-action': AXMComparePopupStartAction,
-                                'show-entity-records-compare-action': AXMCompareEntityRecordsAction,
-                                'show-entity-record-versions-compare-action': AXMCompareEntityRecordVersionsAction,
+                                AXPEntityArchiveAction,
+                                AXPEntityArchiveSuccessAction,
+                                AXPEntityUnarchiveAction,
+                                AXPEntityUnarchiveSuccessAction,
+                                AXPEntityBulkArchiveAction,
+                                AXPEntityBulkArchiveSuccessAction,
+                                AXPEntityBulkUnarchiveAction,
+                                AXPEntityBulkUnarchiveSuccessAction,
                             },
                             workflows: {
-                                'show-entity-records-compare': AXMCompareEntityRecordsWorkflow,
-                                'show-entity-record-versions-compare': AXMCompareEntityRecordVersionsWorkflow,
+                                'archive-entity': AXPArchiveEntityWorkflow,
+                                'restore-archive-entity': AXPUnarchiveEntityWorkflow,
+                                'bulk-archive-entity': AXPBulkArchiveEntityWorkflow,
+                                'bulk-restore-archive-entity': AXPBulkUnarchiveEntityWorkflow,
                             },
                         }),
                     ],
-                    exports: [AXPComparePopupComponent],
+                    providers: [
+                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: archivePlugin },
+                    ],
                 }]
         }] });
 
-const AXP_GLOBAL_SEARCH_CONFIG_TOKEN = new InjectionToken('AXP_GLOBAL_SEARCH_CONFIG_TOKEN');
+const categoryPlugin = {
+    name: 'category',
+    order: 45,
+    apply: (ctx, options) => {
+        const moduleName = ctx.entity.module;
+        const baseEntityName = ctx.entity.name;
+        const categoryEntityName = `${baseEntityName}Category`;
+        const propertyName = options?.propertyName?.trim()?.length ? options.propertyName : 'categoryIds';
+        const allowMultiple = options?.allowMultiple ?? true;
+        // Ensure group exists (prefer basic-info)
+        const groups = ctx.groups.list() ?? [];
+        const hasBasic = groups.some((g) => g.id === 'basic-info');
+        if (!hasBasic) {
+            ctx.groups.add({ id: 'basic-info', title: '@general:terms.basic-info' });
+        }
+        ctx.columns.add({ name: 'categoryIds', options: { dataPath: 'categories' } });
+        // Ensure property exists
+        const props = ctx.properties.list();
+        if (!props.some((p) => p.name === propertyName)) {
+            ctx.properties.add({
+                name: propertyName,
+                title: '@general:terms.category.plural',
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.LookupBox,
+                        options: {
+                            entity: `${moduleName}.${categoryEntityName}`,
+                            multiple: allowMultiple,
+                            expose: [
+                                { source: 'id', target: 'categories.{id}' },
+                                { source: 'title', target: 'categories.{title}' },
+                            ],
+                        },
+                    },
+                },
+            });
+        }
+        // Ensure category sidebar/filter block
+        ctx.category.update((cat) => {
+            return {
+                entity: `${moduleName}.${categoryEntityName}`,
+                title: '@general:terms.category.plural',
+                textField: 'title',
+                valueField: 'id',
+                applyConditions: [
+                    {
+                        name: propertyName,
+                        operator: { type: 'contains' },
+                        value: 'id',
+                    },
+                ],
+            };
+        });
+        // Ensure layout includes property in create/modify/single
+        const ensureLayoutProperty = (layout) => {
+            layout.sections = layout.sections ?? [];
+            if (!layout.sections.some((s) => s.id === 'basic-info')) {
+                layout.sections.push({ id: 'basic-info' });
+            }
+            layout.properties = layout.properties ?? [];
+            if (!layout.properties.some((p) => p.name === propertyName)) {
+                layout.properties.push({
+                    name: propertyName,
+                    layout: {
+                        positions: { lg: { colSpan: 12, order: 12 } },
+                    },
+                });
+            }
+            return layout;
+        };
+        ctx.interfaces.master.create.update((create) => ensureLayoutProperty(create ?? { sections: [], properties: [] }));
+        ctx.interfaces.master.modify.update((modify) => ensureLayoutProperty(modify ?? { sections: [], properties: [] }));
+        ctx.interfaces.master.single.update((single) => ensureLayoutProperty(single ?? { title: ctx.entity.title, sections: [], properties: [] }));
+        // Mark extension for dynamic category entity generation
+        ctx.entity.extensions ??= {};
+        ctx.entity.extensions.category = {
+            entity: `${moduleName}.${categoryEntityName}`,
+            propertyName,
+            allowMultiple,
+        };
+    },
+};
 
-class AXPGlobalSearchSlotComponent {
+class AXMEntityCategoryProvider {
     constructor() {
-        this.workflow = inject(AXPWorkflowService);
+        this.injector = inject(Injector);
     }
-    async startSearch() {
-        await this.workflow.execute('global-search');
+    preload() {
+        return [];
     }
-    async handleKeyboardEvent(event) {
-        if (event.ctrlKey) {
-            switch (event.code) {
-                case 'KeyK':
-                    event.preventDefault();
-                    event.stopPropagation();
-                    await this.startSearch();
-                    break;
-            }
-        }
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.1.6", type: AXPGlobalSearchSlotComponent, isStandalone: true, selector: "ng-component", host: { listeners: { "document:keydown": "handleKeyboardEvent($event)" } }, ngImport: i0, template: `
-    <ax-button color="primary" class="ax-flex md:ax-hidden" (onClick)="startSearch()">
-      <ax-icon class="fa-regular fa-search">
-      </ax-icon>
-    </ax-button>
-    <div class="ax-bg-primary-200/15 ax-h-10 ax-w-72 ax-rounded-default ax-cursor-pointer ax-justify-between ax-hidden md:ax-flex ax-items-center ax-px-3 hover:ax-bg-primary-200/30 ax-text-primary-text" (click)="startSearch()" *translate="let t">
-      <div class="ax-flex ax-items-center ax-gap-2">
-      <i class="fa-light fa-search ax-text-xl"></i>
-      <span>{{ t('search-placeholder',{scope:'global-search'}) | async}}</span>
-      </div>
-      <kbd class="ax-text-sm">Ctrl+K</kbd>
-    </div>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i1.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "directive", type: i4.AXTranslatorDirective, selector: "[translate]" }, { kind: "ngmodule", type: AXTextBoxModule }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchSlotComponent, decorators: [{
-            type: Component,
-            args: [{
-                    template: `
-    <ax-button color="primary" class="ax-flex md:ax-hidden" (onClick)="startSearch()">
-      <ax-icon class="fa-regular fa-search">
-      </ax-icon>
-    </ax-button>
-    <div class="ax-bg-primary-200/15 ax-h-10 ax-w-72 ax-rounded-default ax-cursor-pointer ax-justify-between ax-hidden md:ax-flex ax-items-center ax-px-3 hover:ax-bg-primary-200/30 ax-text-primary-text" (click)="startSearch()" *translate="let t">
-      <div class="ax-flex ax-items-center ax-gap-2">
-      <i class="fa-light fa-search ax-text-xl"></i>
-      <span>{{ t('search-placeholder',{scope:'global-search'}) | async}}</span>
-      </div>
-      <kbd class="ax-text-sm">Ctrl+K</kbd>
-    </div>
-  `,
-                    imports: [CommonModule, AXButtonModule, AXDecoratorModule, AXTranslationModule, AXTextBoxModule]
-                }]
-        }], propDecorators: { handleKeyboardEvent: [{
-                type: HostListener,
-                args: ['document:keydown', ['$event']]
-            }] } });
-
-class AXPGlobalSearchStartAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.popupService = inject(AXPopupService);
-        this.workflow = inject(AXPWorkflowService);
-        this.config = inject(AXP_GLOBAL_SEARCH_CONFIG_TOKEN);
-    }
-    async execute(context) {
-        const component = await this.config.window();
-        const popup = await this.popupService.open(component, {
-            title: 'Search...',
-            size: 'fit',
-            closeOnBackdropClick: true,
-            data: {
-                text: context.getVariable('text'),
-            },
-            header: false,
-        });
-        if (popup.data) {
-            const result = popup.data;
-            if (result && result.command) {
-                this.workflow.execute(result.command?.name, result.command?.options);
-            }
+    async get(moduleName, entityName) {
+        // Generic per-entity Category provider (works for any module)
+        if (entityName.endsWith('Category')) {
+            const fullKey = `${moduleName}.${entityName}`;
+            const dataService = runInInjectionContext(this.injector, () => new AXMEntityCrudServiceImpl(fullKey));
+            const entityDef = {
+                module: moduleName,
+                name: entityName,
+                parentKey: 'parentId',
+                plugins: [
+                // { name: 'history' },
+                // { name: 'lock' },
+                // { name: 'compare' },
+                ],
+                source: '',
+                title: '@general:terms.category.individual',
+                formats: {
+                    individual: '@general:terms.category.individual',
+                    plural: '@general:terms.category.plural',
+                    searchResult: {
+                        title: '{{ title }}',
+                        description: '{{ module }}',
+                    },
+                },
+                relatedEntities: [],
+                groups: [
+                    { id: 'basic-info', title: '@general:terms.basic-info' },
+                ],
+                properties: [
+                    {
+                        name: 'title',
+                        title: '@general:terms.title',
+                        groupId: 'basic-info',
+                        options: {
+                            sort: { enabled: true },
+                            filter: { advance: { enabled: true }, inline: { enabled: true } },
+                        },
+                        schema: { dataType: 'string', interface: { type: AXPWidgetsCatalog.text } },
+                        validations: [{ rule: 'required' }],
+                    },
+                    {
+                        name: 'parentId',
+                        title: '@general:terms.parent-id',
+                        groupId: 'basic-info',
+                        schema: {
+                            dataType: 'string',
+                            interface: {
+                                type: AXPWidgetsList.Editors.LookupBox,
+                                options: { entity: `${moduleName}.${entityName}` },
+                            },
+                        },
+                    },
+                    {
+                        name: 'description',
+                        title: '@general:terms.description',
+                        groupId: 'basic-info',
+                        schema: { dataType: 'string', interface: { type: AXPWidgetsCatalog.largeText } },
+                    },
+                ],
+                columns: [{ name: 'title' }, { name: 'description' }],
+                commands: {
+                    create: { execute: async (data) => ({ id: await dataService.insertOne(data) }) },
+                    delete: { execute: async (id) => dataService.deleteOne(id) },
+                    update: { execute: async (data) => dataService.updateOne(data.id, data) },
+                },
+                queries: {
+                    byKey: { execute: async (id) => dataService.getOne(id), type: AXPEntityQueryType.Single },
+                    list: {
+                        execute: async (e) => {
+                            const res = await dataService.query(e);
+                            // enrich hasChild for tree views if childCount is available
+                            return {
+                                items: res.items.map((item) => ({ ...item, hasChild: (item.childCount ?? 0) > 0 })),
+                                total: res.total,
+                            };
+                        },
+                        type: AXPEntityQueryType.List,
+                    },
+                },
+                interfaces: {
+                    master: {
+                        create: {
+                            sections: [{ id: 'basic-info' }],
+                            properties: [
+                                { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
+                                { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                                { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                            ],
+                        },
+                        update: {
+                            sections: [{ id: 'basic-info' }],
+                            properties: [
+                                { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
+                                { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                                { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                            ],
+                        },
+                        single: {
+                            title: '{{title}}',
+                            sections: [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }],
+                            properties: [
+                                { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
+                                { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+                                { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+                            ],
+                            actions: [entityMasterDeleteAction()],
+                        },
+                        list: {
+                            actions: [...entityMasterCrudActions()],
+                            views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                        },
+                    },
+                },
+            };
+            return entityDef;
         }
+        return null;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchStartAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchStartAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMEntityCategoryProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMEntityCategoryProvider }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchStartAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMEntityCategoryProvider, decorators: [{
             type: Injectable
         }] });
-const AXPGlobalSearchWorkflow = {
-    startStepId: 'start',
-    steps: {
-        start: {
-            action: 'AXPGlobalSearchStartAction',
-        },
-    },
-};
 
-class AXPGlobalSearchModule {
-    constructor(appInitService, injector) {
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchModule, deps: [{ token: i1$2.AXPAppStartUpService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchModule, imports: [i2$1.AXPComponentSlotModule, i1$1.AXPWorkflowModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchModule, providers: [
+class AXPCategoryModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCategoryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXPCategoryModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCategoryModule, providers: [
+            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: categoryPlugin },
             {
-                provide: AXP_GLOBAL_SEARCH_CONFIG_TOKEN,
-                useValue: {
-                    window: () => import('./acorex-modules-common-search-popup.component-BSQyjDKA.mjs').then((c) => c.AXPGlobalSearchPopupComponent),
+                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                multi: true,
+                useFactory: () => {
+                    const provider = {
+                        define: async (context) => {
+                            // Generate permissions for any entity that declared category extension
+                            // We can’t scan registry here reliably at bootstrap; rely on generic pattern per module via wildcard
+                            // Consumers can still override with module-level providers.
+                            // No-op here; permissions will be added when category entity is resolved via provideEntity elsewhere if needed.
+                        },
+                    };
+                    return provider;
                 },
             },
-        ], imports: [AXPComponentSlotModule.forChild({
-                'root-header-start': [
-                    {
-                        priority: 0,
-                        name: 'search',
-                        component: AXPGlobalSearchSlotComponent,
-                    },
-                ],
-            }),
-            //
-            AXPWorkflowModule.forChild({
-                actions: {
-                    AXPGlobalSearchStartAction
-                },
-                workflows: {
-                    'global-search': AXPGlobalSearchWorkflow,
-                },
-            })] }); }
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMEntityCategoryProvider,
+                multi: true,
+            },
+        ] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCategoryModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [
-                        AXPComponentSlotModule.forChild({
-                            'root-header-start': [
-                                {
-                                    priority: 0,
-                                    name: 'search',
-                                    component: AXPGlobalSearchSlotComponent,
-                                },
-                            ],
-                        }),
-                        //
-                        AXPWorkflowModule.forChild({
-                            actions: {
-                                AXPGlobalSearchStartAction
-                            },
-                            workflows: {
-                                'global-search': AXPGlobalSearchWorkflow,
-                            },
-                        })
-                    ],
-                    exports: [],
-                    declarations: [],
                     providers: [
+                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: categoryPlugin },
                         {
-                            provide: AXP_GLOBAL_SEARCH_CONFIG_TOKEN,
-                            useValue: {
-                                window: () => import('./acorex-modules-common-search-popup.component-BSQyjDKA.mjs').then((c) => c.AXPGlobalSearchPopupComponent),
+                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
+                            multi: true,
+                            useFactory: () => {
+                                const provider = {
+                                    define: async (context) => {
+                                        // Generate permissions for any entity that declared category extension
+                                        // We can’t scan registry here reliably at bootstrap; rely on generic pattern per module via wildcard
+                                        // Consumers can still override with module-level providers.
+                                        // No-op here; permissions will be added when category entity is resolved via provideEntity elsewhere if needed.
+                                    },
+                                };
+                                return provider;
                             },
                         },
-                    ]
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMEntityCategoryProvider,
+                            multi: true,
+                        },
+                    ],
                 }]
-        }], ctorParameters: () => [{ type: i1$2.AXPAppStartUpService }, { type: i0.Injector }] });
+        }] });
 
-class AXPGlobalSearchViewModel {
+const clonePlugin = {
+    name: 'clone',
+    order: 60,
+    apply: (ctx) => {
+        ensureListActions(ctx);
+        ctx.interfaces.update((i) => {
+            const cmdName = 'clone-entity';
+            // Add clone action to list view
+            const listActions = i.master.list.actions;
+            if (!actionExists(listActions, cmdName)) {
+                listActions.push({
+                    title: '@general:actions.clone.title',
+                    command: {
+                        name: cmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'copy',
+                    scope: AXPEntityCommandScope.Individual,
+                });
+            }
+            // Add clone action to single view
+            const singleActions = i.master.single.actions;
+            if (!actionExists(singleActions, cmdName)) {
+                singleActions.push({
+                    title: '@general:actions.clone.title',
+                    command: {
+                        name: cmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'copy',
+                    scope: AXPEntityCommandScope.Individual,
+                });
+            }
+            return i;
+        });
+    },
+};
+
+const AXPEntityClonedEvent = createWorkFlowEvent('[Entity] Cloned');
+class AXPEntityCloneAction extends AXPWorkflowAction {
     constructor() {
-        this.settingKeys = {
-            recent: "global-search:recents:items",
-            pinned: "global-search:pinned:items"
-        };
-        this.searchService = inject(AXPSearchService);
-        this.settingService = inject(AXPSettingService);
-        this._text = signal(null, ...(ngDevMode ? [{ debugName: "_text" }] : []));
-        this.text = this._text.asReadonly();
-        this._results = signal([], ...(ngDevMode ? [{ debugName: "_results" }] : []));
-        this.results = this._results.asReadonly();
-        this._isBusy = signal(false, ...(ngDevMode ? [{ debugName: "_isBusy" }] : []));
-        this.isBusy = this._isBusy.asReadonly();
-        this.isEmpty = computed(() => this.text() && this.results().length == 0, ...(ngDevMode ? [{ debugName: "isEmpty" }] : []));
-        this.isValid = computed(() => (this.text()?.length ?? 0) > 2, ...(ngDevMode ? [{ debugName: "isValid" }] : []));
-        this.isStart = computed(() => !this.isEmpty() && this.results().length == 0, ...(ngDevMode ? [{ debugName: "isStart" }] : []));
-        this.isWelcome = computed(() => this.isStart() && this.pinnedItems().length == 0 && this.recentItems().length == 0, ...(ngDevMode ? [{ debugName: "isWelcome" }] : []));
-        this._recentItems = signal([], ...(ngDevMode ? [{ debugName: "_recentItems" }] : []));
-        this._pinnedItems = signal([], ...(ngDevMode ? [{ debugName: "_pinnedItems" }] : []));
-        this.pinnedItems = this._pinnedItems.asReadonly();
-        this.recentItems = computed(() => this.getTopRecentItems(), ...(ngDevMode ? [{ debugName: "recentItems" }] : []));
-        this.onItemSelected = new Subject();
-        this.loadSettings();
+        super(...arguments);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.dialogService = inject(AXDialogService);
+        this.loadingDialog = inject(AXLoadingDialogService);
+        this.translationService = inject(AXTranslationService);
     }
-    async search(text) {
-        this._isBusy.set(true);
-        this._text.set(text);
-        if (!this.isValid()) {
-            this._results.set([]);
+    async execute(context) {
+        const refId = context.getVariable('options.refId');
+        const refType = context.getVariable('options.refType');
+        if (!refId || !refType) {
+            throw new Error('Missing required parameters: refId and refType');
         }
-        else {
-            await new Promise((resolve) => setTimeout(resolve, 250));
-            const results = await this.searchService.search(text);
-            this._results.set(results);
+        const [moduleName, entityName] = refType.split('.');
+        const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+        // Show confirmation dialog
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('@general:actions.clone.confirm.title'), await this.translationService.translateAsync('@general:actions.clone.confirm.message'), 'warning', 'horizontal', false, 'cancel');
+        if (!dialogResult.result) {
+            context.setOutput('isCanceled', true);
+            context.setOutput('error', 'Operation cancelled by user');
+            return;
         }
-        this._isBusy.set(false);
-    }
-    async execute(item) {
-        this.onItemSelected.next(item);
-        await this.updateSelectionHistory(item);
-    }
-    async pin(item) {
-        const currentPinned = this._pinnedItems();
-        if (!currentPinned.some(i => i.id === item.id)) {
-            this._pinnedItems.set([item, ...currentPinned].slice(0, 5));
-            await this.saveSettings();
+        // Show loading dialog
+        const loadingDialog = this.loadingDialog.show({
+            title: await this.translationService.translateAsync('@general:actions.clone.confirm.processing'),
+            mode: 'indeterminate',
+            status: 'Cloning...',
+        });
+        try {
+            // Get the original entity data
+            const originalData = await this.getEntityData(refType, refId);
+            // Clone the data (remove id and other unique fields)
+            const clonedData = this.prepareClonedData(originalData, entityDefinition);
+            // Create the new entity
+            if (entityDefinition.commands?.create) {
+                const createExec = entityDefinition.commands.create.execute;
+                const newId = await createExec(clonedData);
+                context.setOutput('originalId', refId);
+                context.setOutput('newId', newId);
+                context.setOutput('isCanceled', false);
+                // Set refresh metadata
+                if (entityDefinition.parentKey && clonedData[entityDefinition.parentKey]) {
+                    context.setVariable('meta', { refreshTargetId: clonedData[entityDefinition.parentKey] });
+                }
+            }
+            else {
+                throw new Error('Entity does not support create operation');
+            }
         }
-    }
-    async unpin(item) {
-        const currentPinned = this._pinnedItems();
-        this._pinnedItems.set(currentPinned.filter(i => i.id !== item.id));
-        await this.saveSettings();
-    }
-    async togglePin(item) {
-        if (this.isPinned(item)) {
-            await this.unpin(item);
+        catch (error) {
+            console.error('Clone operation failed:', error);
+            context.setOutput('error', error instanceof Error ? error.message : 'Unknown error');
+            context.setOutput('isCanceled', true);
         }
-        else {
-            await this.pin(item);
+        finally {
+            loadingDialog.close();
         }
     }
-    isPinned(item) {
-        const currentPinned = this._pinnedItems();
-        return currentPinned.some(i => i.id === item.id);
-    }
-    async updateSelectionHistory(item) {
-        // Update recent selections
-        const currentHistory = this._recentItems();
-        const updatedHistory = [item, ...currentHistory.filter(i => i.id !== item.id)].slice(0, 5);
-        this._recentItems.set(updatedHistory);
-        // Save updated settings
-        await this.saveSettings();
-    }
-    getTopRecentItems() {
-        const pinnedIds = new Set(this._pinnedItems().map(item => item.id));
-        return this._recentItems().filter(item => !pinnedIds.has(item.id)).slice(0, 5);
-    }
-    async clearRecentItems() {
-        this._recentItems.set([]);
-        await this.settingService.scope(AXPPlatformScope.User).set(this.settingKeys.recent, []);
-    }
-    async loadSettings() {
-        // Load recent selections
-        const recent = await this.settingService.get(this.settingKeys.recent);
-        if (recent) {
-            this._recentItems.set(recent.slice(0, 5));
+    async getEntityData(refType, refId) {
+        try {
+            // Use the entity's byKey query to get actual data
+            const [moduleName, entityName] = refType.split('.');
+            const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+            if (entityDefinition.queries?.byKey) {
+                const queryExec = entityDefinition.queries.byKey.execute;
+                return await queryExec(refId);
+            }
+            // Fallback to basic structure if no query available
+            return { id: refId };
         }
-        // Load pinned items
-        const pinned = await this.settingService.get(this.settingKeys.pinned);
-        if (pinned) {
-            this._pinnedItems.set(pinned.slice(0, 5));
+        catch (error) {
+            console.error('Failed to retrieve entity data:', error);
+            throw new Error(`Failed to retrieve entity data: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
-    async saveSettings() {
-        // Save recent selections
-        await this.settingService.scope(AXPPlatformScope.User).set(this.settingKeys.recent, this._recentItems().slice(0, 5));
-        // Save pinned items
-        await this.settingService.scope(AXPPlatformScope.User).set(this.settingKeys.pinned, this._pinnedItems().slice(0, 5));
+    prepareClonedData(originalData, entityDefinition) {
+        const clonedData = { ...originalData };
+        // Remove unique identifiers and system fields
+        delete clonedData.id;
+        delete clonedData.createdAt;
+        delete clonedData.updatedAt;
+        delete clonedData.createdBy;
+        delete clonedData.updatedBy;
+        delete clonedData.version;
+        delete clonedData.isArchived;
+        delete clonedData.archivedAt;
+        // Update title to indicate it's a clone
+        if (clonedData.title) {
+            clonedData.title = `${clonedData.title} (Copy)`;
+        }
+        // Update name to indicate it's a clone
+        if (clonedData.name) {
+            clonedData.name = `${clonedData.name} (Copy)`;
+        }
+        // Update code if it exists
+        if (clonedData.code) {
+            clonedData.code = `${clonedData.code}_COPY`;
+        }
+        // Handle parent relationships if they exist
+        if (entityDefinition.parentKey && clonedData[entityDefinition.parentKey]) {
+            // Keep the parent relationship - don't delete
+        }
+        // Reset status fields to default values
+        if (clonedData.isActive !== undefined) {
+            clonedData.isActive = true;
+        }
+        if (clonedData.status !== undefined) {
+            clonedData.status = 'draft'; // or appropriate default status
+        }
+        return clonedData;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityCloneAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityCloneAction }); }
 }
-
-class AXMVersionHistoryPopupStartAction extends AXPWorkflowAction {
-    constructor() {
-        super(...arguments);
-        this.popupService = inject(AXPopupService);
-        this.translate = inject(AXTranslationService);
-    }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityCloneAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPEntityCloneSuccessAction extends AXPWorkflowAction {
     async execute(context) {
-        const comp = (await import('./acorex-modules-common-timeline-version-history-popup.component-ByAc4Yp9.mjs')).AXMTimelineVersionHistoryPopupComponent;
-        this.popupService.open(comp, {
-            title: await this.translate.translateAsync('@activity-log:actions.view-history'),
-            data: {
-                refId: context.getVariable('options.refId'),
-                refType: context.getVariable('options.refType'),
-                fromDate: context.getVariable('options.fromDate'),
-                toDate: context.getVariable('options.toDate'),
-                limit: context.getVariable('options.limit'),
-                offset: context.getVariable('options.offset'),
-            },
-        });
+        const refType = context.getVariable('options.refType');
+        const originalId = context.getOutput('originalId');
+        const newId = context.getOutput('newId');
+        const meta = context.getVariable('meta');
+        // Dispatch clone event
+        this.dispatch(AXPEntityClonedEvent({
+            entity: refType,
+            originalId,
+            newId,
+            meta
+        }));
+        // Refresh the entity list
+        this.dispatch(AXPRefreshEvent({
+            entity: refType,
+            meta
+        }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMVersionHistoryPopupStartAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMVersionHistoryPopupStartAction }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityCloneSuccessAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityCloneSuccessAction }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMVersionHistoryPopupStartAction, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPEntityCloneSuccessAction, decorators: [{
             type: Injectable
         }] });
-const AXMVersionHistoryPopupWorkflow = {
-    startStepId: 'start',
+const AXPCloneEntityWorkflow = {
+    startStepId: 'clone-entity',
     steps: {
-        start: {
-            action: 'show-version-history-popup-action',
+        'clone-entity': {
+            action: 'AXPEntityCloneAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
+                    nextStepId: 'show-success-toast',
+                },
+            ],
+        },
+        'show-success-toast': {
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-cloned',
+                content: 'workflow.entity-cloned-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'clone-success',
+                },
+            ],
+        },
+        'clone-success': {
+            action: 'AXPEntityCloneSuccessAction',
         },
     },
 };
 
-const historyLoggerMiddleware = {
-    target: { ops: ['create', 'update', 'delete'], order: 80 },
-    execute: async (ctx, next) => {
-        const entityRegistry = inject(AXPEntityDefinitionRegistryService);
-        const sessionService = inject(AXPSessionService);
-        const backend = inject(AXP_ENTITY_STORAGE_BACKEND);
-        // Capture previous for update/delete
-        if (ctx.op === 'update' || ctx.op === 'delete') {
-            try {
-                ctx.previous = await ctx.backend.getOneRaw(ctx.entityName, ctx.id);
-            }
-            catch { /* ignore */ }
-        }
-        await next();
-        // Build history entry
-        const now = new Date();
-        const [moduleName, entityModuleName] = ctx.entityName.split('.');
-        const entityConfig = await entityRegistry.resolve(moduleName, entityModuleName);
-        const actions = [];
-        if (ctx.op === 'update' && ctx.previous && ctx.result) {
-            const changes = detectEntityChanges(ctx.previous, ctx.result);
-            // Build actions similar to old addToHistory mapping by widget type
-            if (entityConfig) {
-                for (const [key, value] of Object.entries(changes)) {
-                    const property = entityConfig.properties.find((p) => p.name === key);
-                    if (property && property.schema?.interface) {
-                        const widgetType = property.schema.interface.type;
-                        switch (widgetType) {
-                            case 'file-uploader':
-                                if (value.added?.length) {
-                                    actions.push({
-                                        type: AXPSystemActionType.Upload,
-                                        description: `"${value.added?.map((item) => item.name).join(', ')}"`,
-                                    });
-                                }
-                                if (value.removed?.length) {
-                                    actions.push({
-                                        type: AXPSystemActionType.Delete,
-                                        description: `"${value.removed?.map((item) => item.name).join(', ')}"`,
-                                    });
-                                }
-                                break;
-                            case 'large-text-editor':
-                            case 'rich-text-editor': {
-                                const safeValue = extractTextFromHtml(value.newValue);
-                                actions.push({
-                                    type: AXPSystemActionType.Update,
-                                    description: `${property.title} to "${safeValue.length > 100 ? safeValue.slice(0, 30) + '...' : safeValue}"`,
-                                });
-                                break;
-                            }
-                            case 'text-editor':
-                                actions.push({
-                                    type: AXPSystemActionType.Update,
-                                    description: `${property.title} to "${value.newValue.length > 100 ? value.newValue.slice(0, 30) + '...' : value.newValue}"`,
-                                });
-                                break;
-                            default:
-                                actions.push({ type: AXPSystemActionType.Update, description: `${property.title}` });
-                        }
-                    }
-                }
-            }
-            // Expose raw changes to event middleware
-            ctx.locals.set('changes', changes);
-        }
-        // Compute reference ID and final data per operation
-        let referenceId;
-        let finalData = undefined;
-        if (ctx.op === 'create') {
-            const createdId = String(ctx.result);
-            const createdEntity = { ...ctx.data, id: createdId };
-            referenceId = createdId;
-            finalData = createdEntity;
-        }
-        else if (ctx.op === 'update') {
-            referenceId = String(ctx.id);
-            finalData = ctx.result;
-        }
-        else {
-            // delete
-            referenceId = String(ctx.id);
-            finalData = ctx.previous;
-        }
-        const record = {
-            id: AXPDataGenerator.uuid(),
-            title: entityConfig?.title ?? now.toISOString(),
-            date: now,
-            user: {
-                id: sessionService.user?.id ?? 'system',
-                name: sessionService.user?.name ?? 'System',
-                title: sessionService.user?.title ?? 'System',
-            },
-            reference: { id: referenceId, type: ctx.entityName },
-            changeType: ctx.op === 'create'
-                ? AXPSystemActionType.Create
-                : ctx.op === 'update'
-                    ? AXPSystemActionType.Update
-                    : AXPSystemActionType.Delete,
-            changes: actions,
-            data: finalData,
-        };
-        // Persist via backend raw insert to avoid recursive middleware
-        try {
-            await backend.insertOne(`${ctx.entityName}-history`, { ...record, isCurrent: true });
-        }
-        catch (error) {
-            console.error(error);
-            // swallow errors to avoid breaking main flow
-        }
-    },
-};
-
-const historyPlugin = {
-    name: 'history',
-    order: 50,
-    apply: (ctx) => {
-        ensureListActions(ctx);
-        ctx.interfaces.update((i) => {
-            const cmdName = 'show-version-history-popup';
-            //
-            const listActions = i.master.list.actions;
-            if (!actionExists(listActions, cmdName)) {
-                listActions.push({
-                    title: '@activity-log:actions.view-history',
-                    command: {
-                        name: cmdName,
-                        options: {
-                            refId: '{{ context.eval("id") }}',
-                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
-                        },
-                    },
-                    priority: 'secondary',
-                    type: 'version-history',
-                    scope: AXPEntityCommandScope.Individual,
-                });
-            }
-            //
-            const singleActions = i.master.single.actions;
-            if (!actionExists(singleActions, cmdName)) {
-                singleActions.push({
-                    title: '@activity-log:actions.view-history',
-                    command: {
-                        name: cmdName,
-                        options: {
-                            refId: '{{ context.eval("id") }}',
-                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
-                        },
-                    },
-                    priority: 'secondary',
-                    type: 'version-history',
-                    scope: AXPEntityCommandScope.Individual,
-                });
-            }
-            //
-            return i;
-        });
-    },
-};
-
-const comparePlugin = {
-    name: 'compare',
-    order: 50,
-    apply: (ctx) => {
-        ensureListActions(ctx);
-        ctx.interfaces.update((i) => {
-            const actions = i.master.list.actions;
-            const cmdName = 'show-entity-records-compare';
-            if (!actionExists(actions, cmdName)) {
-                actions.push({
-                    title: '@activity-log:actions.compare-records',
-                    command: { name: cmdName },
-                    priority: 'secondary',
-                    type: 'compare',
-                    scope: AXPEntityCommandScope.Selected,
-                });
-            }
-            return i;
-        });
-    },
-};
-
-class AXPVersionHistoryModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPVersionHistoryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXPVersionHistoryModule, imports: [i1$1.AXPWorkflowModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPVersionHistoryModule, providers: [
-            { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: historyLoggerMiddleware },
-            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: historyPlugin },
-            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: comparePlugin },
+class AXPClonePluginModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPClonePluginModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXPClonePluginModule, imports: [i1.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPClonePluginModule, providers: [
+            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: clonePlugin },
         ], imports: [AXPWorkflowModule.forChild({
                 actions: {
-                    'show-version-history-popup-action': AXMVersionHistoryPopupStartAction,
+                    AXPEntityCloneAction,
+                    AXPEntityCloneSuccessAction,
                 },
                 workflows: {
-                    'show-version-history-popup': AXMVersionHistoryPopupWorkflow,
+                    'clone-entity': AXPCloneEntityWorkflow,
                 },
             })] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPVersionHistoryModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPClonePluginModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
                         AXPWorkflowModule.forChild({
                             actions: {
-                                'show-version-history-popup-action': AXMVersionHistoryPopupStartAction,
+                                AXPEntityCloneAction,
+                                AXPEntityCloneSuccessAction,
                             },
                             workflows: {
-                                'show-version-history-popup': AXMVersionHistoryPopupWorkflow,
+                                'clone-entity': AXPCloneEntityWorkflow,
                             },
                         }),
                     ],
-                    exports: [],
                     providers: [
-                        { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: historyLoggerMiddleware },
-                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: historyPlugin },
-                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: comparePlugin },
+                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: clonePlugin },
                     ],
                 }]
         }] });
 
-class AXPDateTimeEvaluatorScopeProvider {
+class AXPComparePopupComponent extends AXBasePageComponent {
     constructor() {
-        this.calendarService = inject(AXCalendarService);
+        super(...arguments);
+        this.inputs = input(...(ngDevMode ? [undefined, { debugName: "inputs" }] : []));
+        this.isBusy = signal(false, ...(ngDevMode ? [{ debugName: "isBusy" }] : []));
+        this.mode = input('compare', ...(ngDevMode ? [{ debugName: "mode" }] : []));
     }
-    async provide(context) {
-        context.addScope('date', {
-            today: () => {
-                return this.calendarService.now();
-            },
-            tomorrow: () => {
-                return this.calendarService.create(this.calendarService.now()).add('day', 1).startOf('day').date;
-            },
-            yesterday: () => {
-                return this.calendarService.create(this.calendarService.now()).add('day', -1).startOf('day').date;
-            },
-            addDays: (date, days) => {
-                return this.calendarService.create(date).add('day', days).date;
-            },
-        });
+    ngOnInit() {
+        super.ngOnInit();
+        // Any additional initialization logic can go here
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPComparePopupComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.1.6", type: AXPComparePopupComponent, isStandalone: true, selector: "axp-compare-popup", inputs: { inputs: { classPropertyName: "inputs", publicName: "inputs", isSignal: true, isRequired: false, transformFunction: null }, mode: { classPropertyName: "mode", publicName: "mode", isSignal: true, isRequired: false, transformFunction: null } }, providers: [], usesInheritance: true, ngImport: i0, template: "<ax-content>\n  <div class=\"ax-p-6 ax-min-h-[30vh] ax-overflow-y-auto\">\n    <axp-compare-view [inputs]=\"inputs()\" [mode]=\"mode()\"></axp-compare-view>\n  </div>\n</ax-content>\n<ax-footer>\n  <ax-prefix></ax-prefix>\n  <ax-suffix>\n    <ax-button [text]=\"'close' | translate | async\" look=\"solid\" color=\"primary\" (onClick)=\"close()\"> </ax-button>\n  </ax-suffix>\n</ax-footer>", dependencies: [{ kind: "ngmodule", type: 
+                // Angular
+                CommonModule }, { kind: "ngmodule", type: 
+                // ACoreX
+                AXDecoratorModule }, { kind: "component", type: i1$1.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "component", type: 
+                // Compare View
+                AXPCompareViewComponent, selector: "axp-compare-view", inputs: ["inputs", "mode"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.AXTranslatorPipe, name: "translate" }], encapsulation: i0.ViewEncapsulation.None }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPComparePopupComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axp-compare-popup', standalone: true, imports: [
+                        // Angular
+                        CommonModule,
+                        // ACoreX
+                        AXDecoratorModule,
+                        AXButtonModule,
+                        AXTranslationModule,
+                        // Compare View
+                        AXPCompareViewComponent
+                    ], encapsulation: ViewEncapsulation.None, providers: [], template: "<ax-content>\n  <div class=\"ax-p-6 ax-min-h-[30vh] ax-overflow-y-auto\">\n    <axp-compare-view [inputs]=\"inputs()\" [mode]=\"mode()\"></axp-compare-view>\n  </div>\n</ax-content>\n<ax-footer>\n  <ax-prefix></ax-prefix>\n  <ax-suffix>\n    <ax-button [text]=\"'close' | translate | async\" look=\"solid\" color=\"primary\" (onClick)=\"close()\"> </ax-button>\n  </ax-suffix>\n</ax-footer>" }]
+        }] });
 
-class AXPTranslateEvaluatorScopeProvider {
+var comparePopup_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXPComparePopupComponent: AXPComparePopupComponent
+});
+
+class AXMComparePopupStartAction extends AXPWorkflowAction {
     constructor() {
-        this.translateService = inject(AXTranslationService);
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+        this.translate = inject(AXTranslationService);
     }
-    async provide(context) {
-        context.addScope('translate', {
-            resolve: async (text, options) => {
-                return await this.translateService.translateAsync(text, options);
+    async execute(context) {
+        const comp = (await Promise.resolve().then(function () { return comparePopup_component; })).AXPComparePopupComponent;
+        this.popupService.open(comp, {
+            title: await this.translate.translateAsync('Compare'),
+            size: 'lg',
+            data: {
+                inputs: signal(context.getVariable('inputs')),
+                mode: signal(context.getVariable('mode')),
             },
         });
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMComparePopupStartAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMComparePopupStartAction }); }
 }
-
-const lockGuardMiddleware = {
-    target: { ops: ['update', 'delete'], order: 10 },
-    execute: async (ctx, next) => {
-        const lockService = inject(AXPLockService);
-        const session = inject(AXPSessionService);
-        const lock = await lockService.check({ refId: ctx.id, refType: ctx.entityName });
-        if (lock) {
-            const info = await lockService.getInfo({ refId: ctx.id, refType: ctx.entityName });
-            if (info && session.user && info.lockedBy.id !== session.user.id) {
-                throw new Error('This record is locked and cannot be edited.');
-            }
-        }
-        await next();
-    },
-};
-
-class AXMLockPopupWorkflowAction extends AXPWorkflowAction {
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMComparePopupStartAction, decorators: [{
+            type: Injectable
+        }] });
+class AXMCompareEntityRecordsAction extends AXPWorkflowAction {
     constructor() {
         super(...arguments);
-        this.popupService = inject(AXPopupService);
-        this.translationService = inject(AXTranslationService);
+        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
     }
     async execute(context) {
-        const comp = (await Promise.resolve().then(function () { return index; })).AXPLockPopupComponent;
-        const result = await this.popupService.open(comp, {
-            title: await this.translationService.translateAsync('@lock-system:lock.dialog.title'),
-            data: {
-                refId: context.getVariable('options.refId'),
-                refType: context.getVariable('options.refType'),
+        const [moduleName, entityName] = context.getVariable('entity').split('.');
+        const entityRef = await this.entityRegistry.resolve(moduleName, entityName);
+        const records = context.getVariable('data');
+        const ids = records?.map((r) => r.id);
+        const getById = entityRef.queries.byKey?.execute;
+        //
+        const fields = entityRef.properties
+            .filter(p => p.schema.interface && p.schema.hidden != true)
+            .map((p) => ({
+            path: p.name,
+            title: p.title,
+            description: p.description,
+            widget: {
+                type: p.schema.interface?.type,
+                name: p.name,
+                path: p.name,
+                options: p.schema.interface?.options,
             },
-        });
-        if (result.data != null && result.data.isCanceled != null) {
-            context.setOutput('isCanceled', result.data.isCanceled);
-            if (!result.data.isCanceled) {
-                context.setOutput('lockDuration', result.data.duration);
-                context.setOutput('lockReason', result.data.reason);
-            }
-        }
-        else {
-            context.setOutput('isCanceled', true);
-        }
+        }));
+        const objects = await Promise.all(ids.map(async (c) => {
+            const object = await getById(c);
+            return {
+                id: object.id,
+                title: object.title,
+                description: object.description,
+                context: object,
+            };
+        }));
+        const inputs = {
+            fields: fields,
+            objects: objects,
+        };
+        //
+        context.setVariable('inputs', inputs);
+        context.setVariable('mode', 'records');
+        context.setOutput('result', true);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordsAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordsAction }); }
 }
-const AXMLockPopupWorkflow = {
-    startStepId: 'lock-popup',
-    steps: {
-        'lock-popup': {
-            action: 'AXMLockPopupWorkflowAction',
-            nextSteps: [
-                {
-                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
-                    nextStepId: 'successToast',
-                },
-            ],
-        },
-        successToast: {
-            id: 'successToast',
-            action: 'AXPToastAction',
-            input: {
-                color: 'success',
-                title: 'workflow.entity-modified-title',
-                content: 'workflow.entity-modified-body',
-            },
-            nextSteps: [
-                {
-                    conditions: [],
-                    nextStepId: 'modifyConfirmed',
-                },
-            ],
-        },
-        modifyConfirmed: {
-            id: 'modifyConfirmed',
-            action: 'AXPEntityModifyConfirmedAction',
-        },
-    },
-};
-
-class AXMUnlockConfirmWorkflowAction extends AXPWorkflowAction {
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordsAction, decorators: [{
+            type: Injectable
+        }] });
+class AXMCompareEntityRecordVersionsAction extends AXPWorkflowAction {
     constructor() {
         super(...arguments);
-        this.dialogService = inject(AXDialogService);
-        this.translationService = inject(AXTranslationService);
-        this.lockService = inject(AXPLockService);
-        this.sessionService = inject(AXPSessionService);
+        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
+        this.activityLogService = inject(AXPActivityLogService);
+        this.formatService = inject(AXFormatService);
+        this.translate = inject(AXTranslationService);
     }
     async execute(context) {
-        const refId = context.getVariable('options.refId');
-        const refType = context.getVariable('options.refType');
-        // Show confirmation dialog
-        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('@lock-system:unlock.dialog.title'), await this.translationService.translateAsync('@lock-system:unlock.dialog.description'), 'warning', 'horizontal', false, 'cancel');
-        if (dialogResult.result) {
-            try {
-                // Perform unlock
-                await this.lockService.unlock({
-                    refId: refId,
-                    refType: refType,
-                    type: 'user',
-                });
-                context.setOutput('isCanceled', false);
-                context.setOutput('unlocked', true);
-            }
-            catch (error) {
-                console.error('Unlock failed:', error);
-                // Show error dialog
-                await this.dialogService.alert(await this.translationService.translateAsync('@lock-system:unlock.error.title'), await this.translationService.translateAsync('@lock-system:unlock.error.description'), 'danger');
-                context.setOutput('isCanceled', true);
-                context.setOutput('unlocked', false);
-            }
-        }
-        else {
-            context.setOutput('isCanceled', true);
-            context.setOutput('unlocked', false);
-        }
+        const [moduleName, entityName] = context.getVariable('entity').split('.');
+        const entityRef = await this.entityRegistry.resolve(moduleName, entityName);
+        const refId = context.getVariable('data.refId');
+        const refType = context.getVariable('data.refType');
+        const ids = context.getVariable('data.ids');
+        const histories = await this.activityLogService.getHistoryByIds(refId, refType, ids);
+        //
+        const fields = entityRef.properties
+            .filter(p => p.schema.interface && p.schema.hidden != true)
+            .map((p) => ({
+            path: p.name,
+            title: p.title,
+            description: p.description,
+            widget: {
+                type: p.schema.interface?.type,
+                name: p.name,
+                path: p.name,
+                options: p.schema.interface?.options,
+            },
+        }));
+        const objects = await Promise.all(histories.map(async (h) => ({
+            id: h.id,
+            title: await this.translate.translateAsync(`@activity-log:${h.changeType == 'update' ? 'updated' : 'created'}-by-title`, {
+                params: {
+                    user: h.user?.title,
+                    date: this.formatService.format(h.date, 'datetime', { format: 'short' }),
+                }
+            }),
+            description: h.user?.title,
+            context: h.data,
+        })));
+        const inputs = {
+            fields: fields,
+            objects: objects,
+        };
+        //
+        context.setVariable('inputs', inputs);
+        context.setVariable('mode', 'changes');
+        context.setOutput('result', true);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordVersionsAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordVersionsAction }); }
 }
-const AXMUnlockConfirmWorkflow = {
-    startStepId: 'unlock-confirm',
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCompareEntityRecordVersionsAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMCompareEntityRecordsWorkflow = {
+    startStepId: 'start',
     steps: {
-        'unlock-confirm': {
-            action: 'AXMUnlockConfirmWorkflowAction',
+        start: {
+            action: 'show-entity-records-compare-action',
             nextSteps: [
                 {
-                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("unlocked") == true' }],
-                    nextStepId: 'successToast',
-                },
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
+                    nextStepId: 'show-popup',
+                }
             ],
         },
-        successToast: {
-            id: 'successToast',
-            action: 'AXPToastAction',
-            input: {
-                color: 'success',
-                title: 'workflow.entity-modified-title',
-                content: 'workflow.entity-modified-body',
-            },
+        'show-popup': {
+            action: 'show-compare-popup-action',
+        },
+    },
+};
+const AXMCompareEntityRecordVersionsWorkflow = {
+    startStepId: 'start',
+    steps: {
+        start: {
+            action: 'show-entity-record-versions-compare-action',
             nextSteps: [
                 {
-                    conditions: [],
-                    nextStepId: 'modifyConfirmed',
-                },
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
+                    nextStepId: 'show-popup',
+                }
             ],
         },
-        modifyConfirmed: {
-            id: 'modifyConfirmed',
-            action: 'AXPEntityModifyConfirmedAction',
+        'show-popup': {
+            action: 'show-compare-popup-action',
         },
     },
 };
 
-class AXMLockEvaluatorScopeProvider {
-    constructor() {
-        this.lockService = inject(AXPLockService);
-    }
-    async provide(context) {
-        context.addScope('lock', {
-            check: async (refId, refType) => {
-                const lock = await this.lockService.check({
-                    refId, refType
-                });
-                return lock;
-            }
-        });
-    }
-}
-
-const lockPlugin = {
-    name: 'lock',
-    order: 50,
-    apply: (ctx) => {
-        ensureListActions(ctx);
-        ctx.interfaces.update((i) => {
-            const actions = i.master.list.actions;
-            if (!actions.some((a) => a.name === 'lock-entity')) {
-                actions.push({
-                    title: '@lock-system:lock.title',
-                    name: 'lock-entity',
-                    command: {
-                        name: 'lock-popup',
-                        options: {
-                            refId: '{{ context.eval("id") }}',
-                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
-                        },
-                    },
-                    priority: 'secondary',
-                    type: 'lock',
-                    scope: AXPEntityCommandScope.Individual,
-                    hidden: `{{ lock.check(context.eval("id"), "${ctx.entity.module}.${ctx.entity.name}") }}`,
-                });
-            }
-            if (!actions.some((a) => a.name === 'unlock-entity')) {
-                actions.push({
-                    title: '@lock-system:unlock.title',
-                    name: 'unlock-entity',
-                    command: {
-                        name: 'unlock-confirm',
-                        options: {
-                            refId: '{{ context.eval("id") }}',
-                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
-                        },
-                    },
-                    priority: 'secondary',
-                    type: 'unlock',
-                    scope: AXPEntityCommandScope.Individual,
-                    hidden: `{{ (await lock.check(context.eval("id"), "${ctx.entity.module}.${ctx.entity.name}"))  == false }}`,
-                });
-            }
-            return i;
-        });
-    },
-};
-
-class AXMLockSystemModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMLockSystemModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXMLockSystemModule, imports: [i1$1.AXPWorkflowModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMLockSystemModule, providers: [
-            { provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, multi: true, useClass: AXMLockEvaluatorScopeProvider },
-            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: lockPlugin },
-            { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: lockGuardMiddleware },
-        ], imports: [AXPWorkflowModule.forChild({
+class AXPCompareModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCompareModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXPCompareModule, imports: [AXPComparePopupComponent, i1.AXPWorkflowModule], exports: [AXPComparePopupComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCompareModule, imports: [AXPComparePopupComponent,
+            AXPWorkflowModule.forChild({
                 actions: {
-                    AXMLockPopupWorkflowAction,
-                    AXMUnlockConfirmWorkflowAction,
+                    'show-compare-popup-action': AXMComparePopupStartAction,
+                    'show-entity-records-compare-action': AXMCompareEntityRecordsAction,
+                    'show-entity-record-versions-compare-action': AXMCompareEntityRecordVersionsAction,
                 },
                 workflows: {
-                    'lock-popup': AXMLockPopupWorkflow,
-                    'unlock-confirm': AXMUnlockConfirmWorkflow,
+                    'show-entity-records-compare': AXMCompareEntityRecordsWorkflow,
+                    'show-entity-record-versions-compare': AXMCompareEntityRecordVersionsWorkflow,
                 },
             })] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMLockSystemModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCompareModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
+                        AXPComparePopupComponent,
                         AXPWorkflowModule.forChild({
                             actions: {
-                                AXMLockPopupWorkflowAction,
-                                AXMUnlockConfirmWorkflowAction,
+                                'show-compare-popup-action': AXMComparePopupStartAction,
+                                'show-entity-records-compare-action': AXMCompareEntityRecordsAction,
+                                'show-entity-record-versions-compare-action': AXMCompareEntityRecordVersionsAction,
                             },
                             workflows: {
-                                'lock-popup': AXMLockPopupWorkflow,
-                                'unlock-confirm': AXMUnlockConfirmWorkflow,
+                                'show-entity-records-compare': AXMCompareEntityRecordsWorkflow,
+                                'show-entity-record-versions-compare': AXMCompareEntityRecordVersionsWorkflow,
                             },
                         }),
                     ],
+                    exports: [AXPComparePopupComponent],
+                }]
+        }] });
+
+function extractTemplateTokens(template) {
+    const tokens = [];
+    if (!template) {
+        return tokens;
+    }
+    const regex = /\{\{\s*([\s\S]*?)\s*\}\}/g; // capture lazily until closing }}
+    let match;
+    while ((match = regex.exec(template)) !== null) {
+        const token = (match[1] || '').trim();
+        if (token) {
+            tokens.push(token);
+        }
+    }
+    return tokens;
+}
+function getRootFromPath(path) {
+    const trimmed = path.trim();
+    const clean = trimmed.replace(/^context\.eval\(['"]|['"]\)$/g, '');
+    const first = clean.split('.')[0];
+    return first.replace(/\{.*\}$/, '');
+}
+function defaultIdField(dataPath) {
+    const leaf = (dataPath || '').split('.').filter(Boolean).pop() || 'related';
+    return `${leaf}Id`;
+}
+const computedPropertiesMiddleware = {
+    target: { ops: ['getOne', 'getAll', 'query'], order: 12 },
+    execute: async (ctx, next) => {
+        const backend = inject(AXP_ENTITY_STORAGE_BACKEND);
+        const registry = inject(AXPEntityDefinitionRegistryService);
+        const expressionEvaluator = inject(AXPExpressionEvaluatorService);
+        await next();
+        try {
+            const [moduleName, entityName] = ctx.entityName.split('.');
+            const def = await registry.resolve(moduleName, entityName);
+            const plugin = (def?.plugins || []).find((p) => p?.name === 'computed-property');
+            if (!plugin?.options?.['fields']?.length)
+                return;
+            const fields = plugin.options['fields'];
+            const related = def?.relatedEntities || [];
+            const rows = Array.isArray(ctx.result)
+                ? ctx.result
+                : Array.isArray(ctx.result?.items)
+                    ? ctx.result.items
+                    : ctx.result
+                        ? [ctx.result]
+                        : [];
+            if (!rows.length)
+                return;
+            // Pre-hydrate merge-detail children used by fields (by root token)
+            const roots = new Set();
+            for (const f of fields) {
+                const tokens = extractTemplateTokens(f.value);
+                tokens.forEach((t) => roots.add(getRootFromPath(t)));
+            }
+            // For merge-detail referenced children, batch hydrate
+            for (const root of roots) {
+                const re = related.find((r) => r?.persistence?.dataPath === root && (r?.persistence?.strategy || 'embedded') === 'referenced');
+                if (!re)
+                    continue;
+                const p = re.persistence || {};
+                const idField = p.idField || defaultIdField(p.dataPath);
+                const ids = Array.from(new Set(rows.map((r) => get(r, idField)).filter((v) => v != null)));
+                if (!ids.length)
+                    continue;
+                try {
+                    const resp = await backend.query(re.entity, {
+                        skip: 0,
+                        take: ids.length || 1000,
+                        filter: { field: 'id', operator: { type: 'in' }, value: ids },
+                    });
+                    const items = resp?.items ?? [];
+                    const map = new Map();
+                    for (const it of items)
+                        map.set(it.id, it);
+                    for (const row of rows) {
+                        const cid = get(row, idField);
+                        if (!cid)
+                            continue;
+                        const child = map.get(cid);
+                        if (child && p?.dataPath)
+                            set(row, p.dataPath, child);
+                    }
+                }
+                catch { }
+            }
+            // Compute per field for each row
+            for (const row of rows) {
+                for (const f of fields) {
+                    const tokens = extractTemplateTokens(f.value);
+                    // Try to ensure data availability for each token
+                    for (const t of tokens) {
+                        const raw = String(t).trim();
+                        const path = raw.replace(/^context\.eval\(['"]|['"]\)$/g, '');
+                        const root = getRootFromPath(path);
+                        let current = getSmart(row, root);
+                        if (current == null) {
+                            // Try merge-detail already covered above. If still missing, try list-related entities by entity name
+                            const reList = related.find((r) => (r?.layout?.type === 'page-list' || r?.layout?.type === 'tab-list') &&
+                                r?.persistence?.dataPath === root);
+                            if (reList) {
+                                // Build filters: reList.conditions + field.conditions
+                                const baseFilters = (reList.conditions ?? []).map((c) => ({ ...c }));
+                                const extraFilters = (f.conditions ?? []).map((c) => ({ ...c }));
+                                const buildScope = () => ({ ...(row ?? {}), context: { eval: (path) => get(row, path) } });
+                                const evaluateValue = async (val) => {
+                                    if (typeof val === 'string' && expressionEvaluator.isExpression(val)) {
+                                        return await expressionEvaluator.evaluate(val, buildScope());
+                                    }
+                                    return val;
+                                };
+                                let allFilters = await Promise.all([...baseFilters, ...extraFilters].map(async (fl) => ({
+                                    field: fl.name ?? fl.field,
+                                    operator: fl.operator,
+                                    value: await evaluateValue(fl.value),
+                                })));
+                                // If no explicit parent filter exists, infer it: child.parentKey == row.id
+                                try {
+                                    const [cm, ce] = (reList.entity || '').split('.');
+                                    const childDef = await registry.resolve(cm, ce);
+                                    const parentKey = childDef?.parentKey;
+                                    if (parentKey && !allFilters.some((fl) => fl.field === parentKey)) {
+                                        allFilters.push({ field: parentKey, operator: { type: 'equal' }, value: row?.id });
+                                    }
+                                }
+                                catch { }
+                                try {
+                                    const resp = await backend.query(reList.entity, {
+                                        skip: 0,
+                                        take: 1000,
+                                        filter: allFilters.length ? { logic: 'and', filters: allFilters } : undefined,
+                                    });
+                                    const items = resp?.items ?? [];
+                                    set(row, root, items);
+                                }
+                                catch { }
+                            }
+                        }
+                    }
+                    // Evaluate template and set computed value using expression evaluator
+                    const scope = {
+                        ...(row ?? {}),
+                        context: {
+                            eval: (path) => {
+                                return getSmart(row, path);
+                            },
+                        },
+                    };
+                    const evaluated = await expressionEvaluator.evaluate(f.value, scope);
+                    set(row, f.name, evaluated || undefined);
+                }
+            }
+        }
+        catch {
+            // swallow to avoid breaking main flow
+        }
+    },
+};
+
+//#endregion
+//#region ----   Plugin   ----
+const computedPropertiesPlugin = {
+    name: 'computed-property',
+    order: 55,
+    apply: (ctx, options) => {
+        const fields = options?.fields ?? [];
+        if (!fields.length) {
+            return;
+        }
+        // Ensure default group exists
+        const defaultGroupId = 'additional';
+        const ensureGroup = (group) => {
+            const id = group?.id || defaultGroupId;
+            const groups = ctx.groups.list() ?? [];
+            if (!groups.some((g) => g.id === id)) {
+                ctx.groups.add({ id, title: group?.title });
+            }
+            return id;
+        };
+        for (const f of fields) {
+            const groupId = ensureGroup(f.group || { id: defaultGroupId });
+            // If group is newly created and a custom title is provided, update it
+            const groups = ctx.groups.list() ?? [];
+            if (!groups.some((g) => g.id === groupId) && f.group?.title) {
+                ctx.groups.add({ id: groupId, title: f.group.title });
+            }
+            // Ensure property exists on entity
+            const existing = ctx.properties.list().some((p) => p.name === f.name);
+            if (!existing) {
+                ctx.properties.add({
+                    name: f.name,
+                    title: f.title,
+                    groupId,
+                    schema: {
+                        dataType: 'string',
+                        readonly: true,
+                        defaultValue: f.value,
+                        interface: {
+                            type: f.showAs?.type || 'text-editor',
+                            options: { ...(f.showAs?.options ?? {}), readonly: true },
+                        },
+                    },
+                });
+            }
+            // Ensure the field appears in list columns
+            const entityAny = ctx.entity;
+            const currentColumns = Array.isArray(entityAny.columns) ? entityAny.columns : [];
+            const hasColumn = currentColumns.some((c) => (typeof c === 'string' ? c === f.name : c?.name === f.name));
+            if (!hasColumn) {
+                entityAny.columns = [...currentColumns, { name: f.name }];
+            }
+            // Ensure Single (details) view shows it
+            ctx.interfaces.master.single.update((single) => {
+                const next = single ?? { title: ctx.entity.title, sections: [], properties: [] };
+                next.sections = next.sections ?? [];
+                if (!next.sections.some((s) => s.id === groupId)) {
+                    next.sections.push({ id: groupId, order: 90 });
+                }
+                next.properties = next.properties ?? [];
+                if (!next.properties.some((p) => p.name === f.name)) {
+                    next.properties.push({
+                        name: f.name,
+                        layout: {
+                            positions: { lg: { colSpan: f.layout?.colSpan ?? 12, order: f.layout?.order ?? 99 } },
+                            label: { visible: true },
+                        },
+                    });
+                }
+                return next;
+            });
+        }
+    },
+};
+//#endregion
+
+class AXPComputedPropertiesModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPComputedPropertiesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXPComputedPropertiesModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPComputedPropertiesModule, providers: [
+            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: computedPropertiesPlugin },
+            { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: computedPropertiesMiddleware },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPComputedPropertiesModule, decorators: [{
+            type: NgModule,
+            args: [{
                     providers: [
-                        { provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, multi: true, useClass: AXMLockEvaluatorScopeProvider },
-                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: lockPlugin },
-                        { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: lockGuardMiddleware },
+                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: computedPropertiesPlugin },
+                        { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: computedPropertiesMiddleware },
                     ],
                 }]
         }] });
@@ -1369,48 +2140,6 @@ const extraPropertiesPlugin = {
     },
 };
 
-const AXPWidgetsList = {
-    Editors: {
-        DocumentAttachment: 'document-attachment-editor',
-        TagBox: 'tagable-editor',
-        CheckBox: 'checkbox-editor',
-        ColorBox: 'color-editor',
-        DateTimeBox: 'date-time-editor',
-        Direction: 'direction',
-        LargeTextBox: 'large-text-editor',
-        NumberBox: 'number-editor',
-        UnitValueBox: 'number-unit-editor',
-        PasswordBox: 'password-editor',
-        QueryBuilder: 'query-builder-editor',
-        RichText: 'rich-text-editor',
-        SelectBox: 'select-editor',
-        SelectionList: 'selection-list-editor',
-        TextBox: 'text-editor',
-        InlineDataTable: 'table-editor',
-        ToggleSwitch: 'toggle-editor',
-        FileTypeExtension: 'file-type-extension',
-        MapBox: 'map',
-        MediaGallery: 'gallery',
-        SignatureBox: 'signature',
-        LookupBox: 'lookup-editor',
-    },
-    Layouts: {
-        BlockLayout: 'block-layout',
-        RepeaterLayout: 'repeater-layout',
-        TextBlockLayout: 'text-block-layout',
-        FormField: 'form-field',
-    },
-    Actions: {
-        ActionButton: 'button-action',
-    },
-    Advanced: {
-        QRCode: 'qrcode',
-    },
-    Templates: {
-        Designer: 'template-designer',
-    },
-};
-
 const AXP_EXTRA_PROPERTY_TYPES_DEFAULT = [
     { id: AXPWidgetsList.Editors.TextBox, title: 'Text' },
     { id: AXPWidgetsList.Editors.CheckBox, title: 'Checkbox' },
@@ -1462,279 +2191,948 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
                 }]
         }] });
 
-const categoryPlugin = {
-    name: 'category',
-    order: 45,
-    apply: (ctx, options) => {
-        const moduleName = ctx.entity.module;
-        const baseEntityName = ctx.entity.name;
-        const categoryEntityName = `${baseEntityName}Category`;
-        const propertyName = options?.propertyName?.trim()?.length ? options.propertyName : 'categoryIds';
-        const allowMultiple = options?.allowMultiple ?? true;
-        // Ensure group exists (prefer basic-info)
-        const groups = ctx.groups.list() ?? [];
-        const hasBasic = groups.some((g) => g.id === 'basic-info');
-        if (!hasBasic) {
-            ctx.groups.add({ id: 'basic-info', title: '@general:terms.basic-info' });
-        }
-        ctx.columns.add({ name: 'categoryIds', options: { dataPath: 'categories' } });
-        // Ensure property exists
-        const props = ctx.properties.list();
-        if (!props.some((p) => p.name === propertyName)) {
-            ctx.properties.add({
-                name: propertyName,
-                title: '@general:terms.category.plural',
-                groupId: 'basic-info',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
-                        options: {
-                            entity: `${moduleName}.${categoryEntityName}`,
-                            multiple: allowMultiple,
-                            expose: [
-                                { source: 'id', target: 'categories.{id}' },
-                                { source: 'title', target: 'categories.{title}' },
-                            ],
-                        },
-                    },
-                },
-            });
-        }
-        // Ensure category sidebar/filter block
-        ctx.category.update((cat) => {
-            return {
-                entity: `${moduleName}.${categoryEntityName}`,
-                title: '@general:terms.category.plural',
-                textField: 'title',
-                valueField: 'id',
-                applyConditions: [
-                    {
-                        name: propertyName,
-                        operator: { type: 'contains' },
-                        value: 'id',
-                    },
-                ],
-            };
-        });
-        // Ensure layout includes property in create/modify/single
-        const ensureLayoutProperty = (layout) => {
-            layout.sections = layout.sections ?? [];
-            if (!layout.sections.some((s) => s.id === 'basic-info')) {
-                layout.sections.push({ id: 'basic-info' });
+const AXP_GLOBAL_SEARCH_CONFIG_TOKEN = new InjectionToken('AXP_GLOBAL_SEARCH_CONFIG_TOKEN');
+
+class AXPGlobalSearchSlotComponent {
+    constructor() {
+        this.workflow = inject(AXPWorkflowService);
+    }
+    async startSearch() {
+        await this.workflow.execute('global-search');
+    }
+    async handleKeyboardEvent(event) {
+        if (event.ctrlKey) {
+            switch (event.code) {
+                case 'KeyK':
+                    event.preventDefault();
+                    event.stopPropagation();
+                    await this.startSearch();
+                    break;
             }
-            layout.properties = layout.properties ?? [];
-            if (!layout.properties.some((p) => p.name === propertyName)) {
-                layout.properties.push({
-                    name: propertyName,
-                    layout: {
-                        positions: { lg: { colSpan: 12, order: 12 } },
-                    },
-                });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.1.6", type: AXPGlobalSearchSlotComponent, isStandalone: true, selector: "ng-component", host: { listeners: { "document:keydown": "handleKeyboardEvent($event)" } }, ngImport: i0, template: `
+    <ax-button color="primary" class="ax-flex md:ax-hidden" (onClick)="startSearch()">
+      <ax-icon class="fa-regular fa-search">
+      </ax-icon>
+    </ax-button>
+    <div class="ax-bg-primary-200/15 ax-h-10 ax-w-72 ax-rounded-default ax-cursor-pointer ax-justify-between ax-hidden md:ax-flex ax-items-center ax-px-3 hover:ax-bg-primary-200/30 ax-text-primary-text" (click)="startSearch()" *translate="let t">
+      <div class="ax-flex ax-items-center ax-gap-2">
+      <i class="fa-light fa-search ax-text-xl"></i>
+      <span>{{ t('search-placeholder',{scope:'global-search'}) | async}}</span>
+      </div>
+      <kbd class="ax-text-sm">Ctrl+K</kbd>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXButtonModule }, { kind: "component", type: i2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i1$1.AXDecoratorIconComponent, selector: "ax-icon", inputs: ["icon"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "directive", type: i4.AXTranslatorDirective, selector: "[translate]" }, { kind: "ngmodule", type: AXTextBoxModule }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <ax-button color="primary" class="ax-flex md:ax-hidden" (onClick)="startSearch()">
+      <ax-icon class="fa-regular fa-search">
+      </ax-icon>
+    </ax-button>
+    <div class="ax-bg-primary-200/15 ax-h-10 ax-w-72 ax-rounded-default ax-cursor-pointer ax-justify-between ax-hidden md:ax-flex ax-items-center ax-px-3 hover:ax-bg-primary-200/30 ax-text-primary-text" (click)="startSearch()" *translate="let t">
+      <div class="ax-flex ax-items-center ax-gap-2">
+      <i class="fa-light fa-search ax-text-xl"></i>
+      <span>{{ t('search-placeholder',{scope:'global-search'}) | async}}</span>
+      </div>
+      <kbd class="ax-text-sm">Ctrl+K</kbd>
+    </div>
+  `,
+                    imports: [CommonModule, AXButtonModule, AXDecoratorModule, AXTranslationModule, AXTextBoxModule]
+                }]
+        }], propDecorators: { handleKeyboardEvent: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+
+class AXPGlobalSearchStartAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+        this.workflow = inject(AXPWorkflowService);
+        this.config = inject(AXP_GLOBAL_SEARCH_CONFIG_TOKEN);
+    }
+    async execute(context) {
+        const component = await this.config.window();
+        const popup = await this.popupService.open(component, {
+            title: 'Search...',
+            size: 'fit',
+            closeOnBackdropClick: true,
+            data: {
+                text: context.getVariable('text'),
+            },
+            header: false,
+        });
+        if (popup.data) {
+            const result = popup.data;
+            if (result && result.command) {
+                this.workflow.execute(result.command?.name, result.command?.options);
             }
-            return layout;
-        };
-        ctx.interfaces.master.create.update((create) => ensureLayoutProperty(create ?? { sections: [], properties: [] }));
-        ctx.interfaces.master.modify.update((modify) => ensureLayoutProperty(modify ?? { sections: [], properties: [] }));
-        ctx.interfaces.master.single.update((single) => ensureLayoutProperty(single ?? { title: ctx.entity.title, sections: [], properties: [] }));
-        // Mark extension for dynamic category entity generation
-        ctx.entity.extensions ??= {};
-        ctx.entity.extensions.category = {
-            entity: `${moduleName}.${categoryEntityName}`,
-            propertyName,
-            allowMultiple,
-        };
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchStartAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchStartAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchStartAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPGlobalSearchWorkflow = {
+    startStepId: 'start',
+    steps: {
+        start: {
+            action: 'AXPGlobalSearchStartAction',
+        },
     },
 };
 
-class AXMEntityCategoryProvider {
-    constructor() {
-        this.injector = inject(Injector);
-    }
-    preload() {
-        return [];
+class AXPGlobalSearchModule {
+    constructor(appInitService, injector) {
     }
-    async get(moduleName, entityName) {
-        // Generic per-entity Category provider (works for any module)
-        if (entityName.endsWith('Category')) {
-            const fullKey = `${moduleName}.${entityName}`;
-            const dataService = runInInjectionContext(this.injector, () => new AXMEntityCrudServiceImpl(fullKey));
-            const entityDef = {
-                module: moduleName,
-                name: entityName,
-                parentKey: 'parentId',
-                plugins: [
-                // { name: 'history' },
-                // { name: 'lock' },
-                // { name: 'compare' },
-                ],
-                source: '',
-                title: '@general:terms.category.individual',
-                formats: {
-                    individual: '@general:terms.category.individual',
-                    plural: '@general:terms.category.plural',
-                    searchResult: {
-                        title: '{{ title }}',
-                        description: '{{ module }}',
-                    },
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchModule, deps: [{ token: i1$2.AXPAppStartUpService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchModule, imports: [i2$1.AXPComponentSlotModule, i1.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchModule, providers: [
+            {
+                provide: AXP_GLOBAL_SEARCH_CONFIG_TOKEN,
+                useValue: {
+                    window: () => import('./acorex-modules-common-search-popup.component-BSQyjDKA.mjs').then((c) => c.AXPGlobalSearchPopupComponent),
                 },
-                relatedEntities: [],
-                groups: [
-                    { id: 'basic-info', title: '@general:terms.basic-info' },
-                ],
-                properties: [
-                    {
-                        name: 'title',
-                        title: '@general:terms.title',
-                        groupId: 'basic-info',
-                        options: {
-                            sort: { enabled: true },
-                            filter: { advance: { enabled: true }, inline: { enabled: true } },
-                        },
-                        schema: { dataType: 'string', interface: { type: AXPWidgetsCatalog.text } },
-                        validations: [{ rule: 'required' }],
-                    },
-                    {
-                        name: 'parentId',
-                        title: '@general:terms.parent-id',
-                        groupId: 'basic-info',
-                        schema: {
-                            dataType: 'string',
-                            interface: {
-                                type: AXPWidgetsList.Editors.LookupBox,
-                                options: { entity: `${moduleName}.${entityName}` },
-                            },
-                        },
-                    },
+            },
+        ], imports: [AXPComponentSlotModule.forChild({
+                'root-header-start': [
                     {
-                        name: 'description',
-                        title: '@general:terms.description',
-                        groupId: 'basic-info',
-                        schema: { dataType: 'string', interface: { type: AXPWidgetsCatalog.largeText } },
+                        priority: 0,
+                        name: 'search',
+                        component: AXPGlobalSearchSlotComponent,
                     },
                 ],
-                columns: [{ name: 'title' }, { name: 'description' }],
-                commands: {
-                    create: { execute: async (data) => ({ id: await dataService.insertOne(data) }) },
-                    delete: { execute: async (id) => dataService.deleteOne(id) },
-                    update: { execute: async (data) => dataService.updateOne(data.id, data) },
+            }),
+            //
+            AXPWorkflowModule.forChild({
+                actions: {
+                    AXPGlobalSearchStartAction
                 },
-                queries: {
-                    byKey: { execute: async (id) => dataService.getOne(id), type: AXPEntityQueryType.Single },
-                    list: {
-                        execute: async (e) => {
-                            const res = await dataService.query(e);
-                            // enrich hasChild for tree views if childCount is available
-                            return {
-                                items: res.items.map((item) => ({ ...item, hasChild: (item.childCount ?? 0) > 0 })),
-                                total: res.total,
-                            };
-                        },
-                        type: AXPEntityQueryType.List,
-                    },
+                workflows: {
+                    'global-search': AXPGlobalSearchWorkflow,
                 },
-                interfaces: {
-                    master: {
-                        create: {
-                            sections: [{ id: 'basic-info' }],
-                            properties: [
-                                { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-                                { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-                                { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-                            ],
-                        },
-                        update: {
-                            sections: [{ id: 'basic-info' }],
-                            properties: [
-                                { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-                                { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-                                { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPGlobalSearchModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPComponentSlotModule.forChild({
+                            'root-header-start': [
+                                {
+                                    priority: 0,
+                                    name: 'search',
+                                    component: AXPGlobalSearchSlotComponent,
+                                },
                             ],
+                        }),
+                        //
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                AXPGlobalSearchStartAction
+                            },
+                            workflows: {
+                                'global-search': AXPGlobalSearchWorkflow,
+                            },
+                        })
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXP_GLOBAL_SEARCH_CONFIG_TOKEN,
+                            useValue: {
+                                window: () => import('./acorex-modules-common-search-popup.component-BSQyjDKA.mjs').then((c) => c.AXPGlobalSearchPopupComponent),
+                            },
                         },
-                        single: {
-                            title: '{{title}}',
-                            sections: [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }],
-                            properties: [
-                                { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-                                { name: 'parentId', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-                                { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-                            ],
-                            actions: [entityMasterDeleteAction()],
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: i1$2.AXPAppStartUpService }, { type: i0.Injector }] });
+
+class AXPGlobalSearchViewModel {
+    constructor() {
+        this.settingKeys = {
+            recent: "global-search:recents:items",
+            pinned: "global-search:pinned:items"
+        };
+        this.searchService = inject(AXPSearchService);
+        this.settingService = inject(AXPSettingService);
+        this._text = signal(null, ...(ngDevMode ? [{ debugName: "_text" }] : []));
+        this.text = this._text.asReadonly();
+        this._results = signal([], ...(ngDevMode ? [{ debugName: "_results" }] : []));
+        this.results = this._results.asReadonly();
+        this._isBusy = signal(false, ...(ngDevMode ? [{ debugName: "_isBusy" }] : []));
+        this.isBusy = this._isBusy.asReadonly();
+        this.isEmpty = computed(() => this.text() && this.results().length == 0, ...(ngDevMode ? [{ debugName: "isEmpty" }] : []));
+        this.isValid = computed(() => (this.text()?.length ?? 0) > 2, ...(ngDevMode ? [{ debugName: "isValid" }] : []));
+        this.isStart = computed(() => !this.isEmpty() && this.results().length == 0, ...(ngDevMode ? [{ debugName: "isStart" }] : []));
+        this.isWelcome = computed(() => this.isStart() && this.pinnedItems().length == 0 && this.recentItems().length == 0, ...(ngDevMode ? [{ debugName: "isWelcome" }] : []));
+        this._recentItems = signal([], ...(ngDevMode ? [{ debugName: "_recentItems" }] : []));
+        this._pinnedItems = signal([], ...(ngDevMode ? [{ debugName: "_pinnedItems" }] : []));
+        this.pinnedItems = this._pinnedItems.asReadonly();
+        this.recentItems = computed(() => this.getTopRecentItems(), ...(ngDevMode ? [{ debugName: "recentItems" }] : []));
+        this.onItemSelected = new Subject();
+        this.loadSettings();
+    }
+    async search(text) {
+        this._isBusy.set(true);
+        this._text.set(text);
+        if (!this.isValid()) {
+            this._results.set([]);
+        }
+        else {
+            await new Promise((resolve) => setTimeout(resolve, 250));
+            const results = await this.searchService.search(text);
+            this._results.set(results);
+        }
+        this._isBusy.set(false);
+    }
+    async execute(item) {
+        this.onItemSelected.next(item);
+        await this.updateSelectionHistory(item);
+    }
+    async pin(item) {
+        const currentPinned = this._pinnedItems();
+        if (!currentPinned.some(i => i.id === item.id)) {
+            this._pinnedItems.set([item, ...currentPinned].slice(0, 5));
+            await this.saveSettings();
+        }
+    }
+    async unpin(item) {
+        const currentPinned = this._pinnedItems();
+        this._pinnedItems.set(currentPinned.filter(i => i.id !== item.id));
+        await this.saveSettings();
+    }
+    async togglePin(item) {
+        if (this.isPinned(item)) {
+            await this.unpin(item);
+        }
+        else {
+            await this.pin(item);
+        }
+    }
+    isPinned(item) {
+        const currentPinned = this._pinnedItems();
+        return currentPinned.some(i => i.id === item.id);
+    }
+    async updateSelectionHistory(item) {
+        // Update recent selections
+        const currentHistory = this._recentItems();
+        const updatedHistory = [item, ...currentHistory.filter(i => i.id !== item.id)].slice(0, 5);
+        this._recentItems.set(updatedHistory);
+        // Save updated settings
+        await this.saveSettings();
+    }
+    getTopRecentItems() {
+        const pinnedIds = new Set(this._pinnedItems().map(item => item.id));
+        return this._recentItems().filter(item => !pinnedIds.has(item.id)).slice(0, 5);
+    }
+    async clearRecentItems() {
+        this._recentItems.set([]);
+        await this.settingService.scope(AXPPlatformScope.User).set(this.settingKeys.recent, []);
+    }
+    async loadSettings() {
+        // Load recent selections
+        const recent = await this.settingService.get(this.settingKeys.recent);
+        if (recent) {
+            this._recentItems.set(recent.slice(0, 5));
+        }
+        // Load pinned items
+        const pinned = await this.settingService.get(this.settingKeys.pinned);
+        if (pinned) {
+            this._pinnedItems.set(pinned.slice(0, 5));
+        }
+    }
+    async saveSettings() {
+        // Save recent selections
+        await this.settingService.scope(AXPPlatformScope.User).set(this.settingKeys.recent, this._recentItems().slice(0, 5));
+        // Save pinned items
+        await this.settingService.scope(AXPPlatformScope.User).set(this.settingKeys.pinned, this._pinnedItems().slice(0, 5));
+    }
+}
+
+const lockGuardMiddleware = {
+    target: { ops: ['update', 'delete'], order: 10 },
+    execute: async (ctx, next) => {
+        const lockService = inject(AXPLockService);
+        const session = inject(AXPSessionService);
+        const lock = await lockService.check({ refId: ctx.id, refType: ctx.entityName });
+        if (lock) {
+            const info = await lockService.getInfo({ refId: ctx.id, refType: ctx.entityName });
+            if (info && session.user && info.lockedBy.id !== session.user.id) {
+                throw new Error('This record is locked and cannot be edited.');
+            }
+        }
+        await next();
+    },
+};
+
+class AXMLockPopupWorkflowAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+        this.translationService = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const comp = (await Promise.resolve().then(function () { return index; })).AXPLockPopupComponent;
+        const result = await this.popupService.open(comp, {
+            title: await this.translationService.translateAsync('@lock-system:lock.dialog.title'),
+            data: {
+                refId: context.getVariable('options.refId'),
+                refType: context.getVariable('options.refType'),
+            },
+        });
+        if (result.data != null && result.data.isCanceled != null) {
+            context.setOutput('isCanceled', result.data.isCanceled);
+            if (!result.data.isCanceled) {
+                context.setOutput('lockDuration', result.data.duration);
+                context.setOutput('lockReason', result.data.reason);
+            }
+        }
+        else {
+            context.setOutput('isCanceled', true);
+        }
+    }
+}
+const AXMLockPopupWorkflow = {
+    startStepId: 'lock-popup',
+    steps: {
+        'lock-popup': {
+            action: 'AXMLockPopupWorkflowAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
+                    nextStepId: 'successToast',
+                },
+            ],
+        },
+        successToast: {
+            id: 'successToast',
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-modified-title',
+                content: 'workflow.entity-modified-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'modifyConfirmed',
+                },
+            ],
+        },
+        modifyConfirmed: {
+            id: 'modifyConfirmed',
+            action: 'AXPEntityModifyConfirmedAction',
+        },
+    },
+};
+
+class AXMUnlockConfirmWorkflowAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.dialogService = inject(AXDialogService);
+        this.translationService = inject(AXTranslationService);
+        this.lockService = inject(AXPLockService);
+        this.sessionService = inject(AXPSessionService);
+    }
+    async execute(context) {
+        const refId = context.getVariable('options.refId');
+        const refType = context.getVariable('options.refType');
+        // Show confirmation dialog
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('@lock-system:unlock.dialog.title'), await this.translationService.translateAsync('@lock-system:unlock.dialog.description'), 'warning', 'horizontal', false, 'cancel');
+        if (dialogResult.result) {
+            try {
+                // Perform unlock
+                await this.lockService.unlock({
+                    refId: refId,
+                    refType: refType,
+                    type: 'user',
+                });
+                context.setOutput('isCanceled', false);
+                context.setOutput('unlocked', true);
+            }
+            catch (error) {
+                console.error('Unlock failed:', error);
+                // Show error dialog
+                await this.dialogService.alert(await this.translationService.translateAsync('@lock-system:unlock.error.title'), await this.translationService.translateAsync('@lock-system:unlock.error.description'), 'danger');
+                context.setOutput('isCanceled', true);
+                context.setOutput('unlocked', false);
+            }
+        }
+        else {
+            context.setOutput('isCanceled', true);
+            context.setOutput('unlocked', false);
+        }
+    }
+}
+const AXMUnlockConfirmWorkflow = {
+    startStepId: 'unlock-confirm',
+    steps: {
+        'unlock-confirm': {
+            action: 'AXMUnlockConfirmWorkflowAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("unlocked") == true' }],
+                    nextStepId: 'successToast',
+                },
+            ],
+        },
+        successToast: {
+            id: 'successToast',
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-modified-title',
+                content: 'workflow.entity-modified-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'modifyConfirmed',
+                },
+            ],
+        },
+        modifyConfirmed: {
+            id: 'modifyConfirmed',
+            action: 'AXPEntityModifyConfirmedAction',
+        },
+    },
+};
+
+class AXMLockEvaluatorScopeProvider {
+    constructor() {
+        this.lockService = inject(AXPLockService);
+    }
+    async provide(context) {
+        context.addScope('lock', {
+            check: async (refId, refType) => {
+                const lock = await this.lockService.check({
+                    refId, refType
+                });
+                return lock;
+            }
+        });
+    }
+}
+
+const lockPlugin = {
+    name: 'lock',
+    order: 50,
+    apply: (ctx) => {
+        ensureListActions(ctx);
+        ctx.interfaces.update((i) => {
+            const actions = i.master.list.actions;
+            if (!actions.some((a) => a.name === 'lock-entity')) {
+                actions.push({
+                    title: '@lock-system:lock.title',
+                    name: 'lock-entity',
+                    command: {
+                        name: 'lock-popup',
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'lock',
+                    scope: AXPEntityCommandScope.Individual,
+                    hidden: `{{ lock.check(context.eval("id"), "${ctx.entity.module}.${ctx.entity.name}") }}`,
+                });
+            }
+            if (!actions.some((a) => a.name === 'unlock-entity')) {
+                actions.push({
+                    title: '@lock-system:unlock.title',
+                    name: 'unlock-entity',
+                    command: {
+                        name: 'unlock-confirm',
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'unlock',
+                    scope: AXPEntityCommandScope.Individual,
+                    hidden: `{{ (await lock.check(context.eval("id"), "${ctx.entity.module}.${ctx.entity.name}"))  == false }}`,
+                });
+            }
+            return i;
+        });
+    },
+};
+
+class AXMLockSystemModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMLockSystemModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXMLockSystemModule, imports: [i1.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMLockSystemModule, providers: [
+            { provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, multi: true, useClass: AXMLockEvaluatorScopeProvider },
+            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: lockPlugin },
+            { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: lockGuardMiddleware },
+        ], imports: [AXPWorkflowModule.forChild({
+                actions: {
+                    AXMLockPopupWorkflowAction,
+                    AXMUnlockConfirmWorkflowAction,
+                },
+                workflows: {
+                    'lock-popup': AXMLockPopupWorkflow,
+                    'unlock-confirm': AXMUnlockConfirmWorkflow,
+                },
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMLockSystemModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                AXMLockPopupWorkflowAction,
+                                AXMUnlockConfirmWorkflowAction,
+                            },
+                            workflows: {
+                                'lock-popup': AXMLockPopupWorkflow,
+                                'unlock-confirm': AXMUnlockConfirmWorkflow,
+                            },
+                        }),
+                    ],
+                    providers: [
+                        { provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER, multi: true, useClass: AXMLockEvaluatorScopeProvider },
+                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: lockPlugin },
+                        { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: lockGuardMiddleware },
+                    ],
+                }]
+        }] });
+
+class AXPDateTimeEvaluatorScopeProvider {
+    constructor() {
+        this.calendarService = inject(AXCalendarService);
+    }
+    async provide(context) {
+        context.addScope('date', {
+            today: () => {
+                return this.calendarService.now();
+            },
+            tomorrow: () => {
+                return this.calendarService.create(this.calendarService.now()).add('day', 1).startOf('day').date;
+            },
+            yesterday: () => {
+                return this.calendarService.create(this.calendarService.now()).add('day', -1).startOf('day').date;
+            },
+            addDays: (date, days) => {
+                return this.calendarService.create(date).add('day', days).date;
+            },
+        });
+    }
+}
+
+class AXPTranslateEvaluatorScopeProvider {
+    constructor() {
+        this.translateService = inject(AXTranslationService);
+    }
+    async provide(context) {
+        context.addScope('translate', {
+            resolve: async (text, options) => {
+                return await this.translateService.translateAsync(text, options);
+            },
+        });
+    }
+}
+
+class AXMVersionHistoryPopupStartAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+        this.translate = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const comp = (await import('./acorex-modules-common-timeline-version-history-popup.component-ByAc4Yp9.mjs')).AXMTimelineVersionHistoryPopupComponent;
+        this.popupService.open(comp, {
+            title: await this.translate.translateAsync('@activity-log:actions.view-history'),
+            data: {
+                refId: context.getVariable('options.refId'),
+                refType: context.getVariable('options.refType'),
+                fromDate: context.getVariable('options.fromDate'),
+                toDate: context.getVariable('options.toDate'),
+                limit: context.getVariable('options.limit'),
+                offset: context.getVariable('options.offset'),
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMVersionHistoryPopupStartAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMVersionHistoryPopupStartAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMVersionHistoryPopupStartAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMVersionHistoryPopupWorkflow = {
+    startStepId: 'start',
+    steps: {
+        start: {
+            action: 'show-version-history-popup-action',
+        },
+    },
+};
+
+const historyLoggerMiddleware = {
+    target: { ops: ['create', 'update', 'delete'], order: 80 },
+    execute: async (ctx, next) => {
+        const entityRegistry = inject(AXPEntityDefinitionRegistryService);
+        const sessionService = inject(AXPSessionService);
+        const backend = inject(AXP_ENTITY_STORAGE_BACKEND);
+        // Capture previous for update/delete
+        if (ctx.op === 'update' || ctx.op === 'delete') {
+            try {
+                ctx.previous = await ctx.backend.getOneRaw(ctx.entityName, ctx.id);
+            }
+            catch { /* ignore */ }
+        }
+        await next();
+        // Build history entry
+        const now = new Date();
+        const [moduleName, entityModuleName] = ctx.entityName.split('.');
+        const entityConfig = await entityRegistry.resolve(moduleName, entityModuleName);
+        const actions = [];
+        if (ctx.op === 'update' && ctx.previous && ctx.result) {
+            const changes = detectEntityChanges(ctx.previous, ctx.result);
+            // Build actions similar to old addToHistory mapping by widget type
+            if (entityConfig) {
+                for (const [key, value] of Object.entries(changes)) {
+                    const property = entityConfig.properties.find((p) => p.name === key);
+                    if (property && property.schema?.interface) {
+                        const widgetType = property.schema.interface.type;
+                        switch (widgetType) {
+                            case 'file-uploader':
+                                if (value.added?.length) {
+                                    actions.push({
+                                        type: AXPSystemActionType.Upload,
+                                        description: `"${value.added?.map((item) => item.name).join(', ')}"`,
+                                    });
+                                }
+                                if (value.removed?.length) {
+                                    actions.push({
+                                        type: AXPSystemActionType.Delete,
+                                        description: `"${value.removed?.map((item) => item.name).join(', ')}"`,
+                                    });
+                                }
+                                break;
+                            case 'large-text-editor':
+                            case 'rich-text-editor': {
+                                const safeValue = extractTextFromHtml(value.newValue);
+                                actions.push({
+                                    type: AXPSystemActionType.Update,
+                                    description: `${property.title} to "${safeValue.length > 100 ? safeValue.slice(0, 30) + '...' : safeValue}"`,
+                                });
+                                break;
+                            }
+                            case 'text-editor':
+                                actions.push({
+                                    type: AXPSystemActionType.Update,
+                                    description: `${property.title} to "${value.newValue.length > 100 ? value.newValue.slice(0, 30) + '...' : value.newValue}"`,
+                                });
+                                break;
+                            default:
+                                actions.push({ type: AXPSystemActionType.Update, description: `${property.title}` });
+                        }
+                    }
+                }
+            }
+            // Expose raw changes to event middleware
+            ctx.locals.set('changes', changes);
+        }
+        // Compute reference ID and final data per operation
+        let referenceId;
+        let finalData = undefined;
+        if (ctx.op === 'create') {
+            const createdId = String(ctx.result);
+            const createdEntity = { ...ctx.data, id: createdId };
+            referenceId = createdId;
+            finalData = createdEntity;
+        }
+        else if (ctx.op === 'update') {
+            referenceId = String(ctx.id);
+            finalData = ctx.result;
+        }
+        else {
+            // delete
+            referenceId = String(ctx.id);
+            finalData = ctx.previous;
+        }
+        const record = {
+            id: AXPDataGenerator.uuid(),
+            title: entityConfig?.title ?? now.toISOString(),
+            date: now,
+            user: {
+                id: sessionService.user?.id ?? 'system',
+                name: sessionService.user?.name ?? 'System',
+                title: sessionService.user?.title ?? 'System',
+            },
+            reference: { id: referenceId, type: ctx.entityName },
+            changeType: ctx.op === 'create'
+                ? AXPSystemActionType.Create
+                : ctx.op === 'update'
+                    ? AXPSystemActionType.Update
+                    : AXPSystemActionType.Delete,
+            changes: actions,
+            data: finalData,
+        };
+        // Persist via backend raw insert to avoid recursive middleware
+        try {
+            await backend.insertOne(`${ctx.entityName}-history`, { ...record, isCurrent: true });
+        }
+        catch (error) {
+            console.error(error);
+            // swallow errors to avoid breaking main flow
+        }
+    },
+};
+
+const historyPlugin = {
+    name: 'history',
+    order: 50,
+    apply: (ctx) => {
+        ensureListActions(ctx);
+        ctx.interfaces.update((i) => {
+            const cmdName = 'show-version-history-popup';
+            //
+            const listActions = i.master.list.actions;
+            if (!actionExists(listActions, cmdName)) {
+                listActions.push({
+                    title: '@activity-log:actions.view-history',
+                    command: {
+                        name: cmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
                         },
-                        list: {
-                            actions: [...entityMasterCrudActions()],
-                            views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                    },
+                    priority: 'secondary',
+                    type: 'version-history',
+                    scope: AXPEntityCommandScope.Individual,
+                });
+            }
+            //
+            const singleActions = i.master.single.actions;
+            if (!actionExists(singleActions, cmdName)) {
+                singleActions.push({
+                    title: '@activity-log:actions.view-history',
+                    command: {
+                        name: cmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
                         },
                     },
-                },
-            };
-            return entityDef;
-        }
-        return null;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMEntityCategoryProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMEntityCategoryProvider }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMEntityCategoryProvider, decorators: [{
-            type: Injectable
-        }] });
+                    priority: 'secondary',
+                    type: 'version-history',
+                    scope: AXPEntityCommandScope.Individual,
+                });
+            }
+            //
+            return i;
+        });
+    },
+};
 
-class AXPCategoryModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCategoryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXPCategoryModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCategoryModule, providers: [
-            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: categoryPlugin },
-            {
-                provide: AXP_PERMISSION_DEFINITION_PROVIDER,
-                multi: true,
-                useFactory: () => {
-                    const provider = {
-                        define: async (context) => {
-                            // Generate permissions for any entity that declared category extension
-                            // We can’t scan registry here reliably at bootstrap; rely on generic pattern per module via wildcard
-                            // Consumers can still override with module-level providers.
-                            // No-op here; permissions will be added when category entity is resolved via provideEntity elsewhere if needed.
-                        },
-                    };
-                    return provider;
+const comparePlugin = {
+    name: 'compare',
+    order: 50,
+    apply: (ctx) => {
+        ensureListActions(ctx);
+        ctx.interfaces.update((i) => {
+            const actions = i.master.list.actions;
+            const cmdName = 'show-entity-records-compare';
+            if (!actionExists(actions, cmdName)) {
+                actions.push({
+                    title: '@activity-log:actions.compare-records',
+                    command: { name: cmdName },
+                    priority: 'secondary',
+                    type: 'compare',
+                    scope: AXPEntityCommandScope.Selected,
+                });
+            }
+            return i;
+        });
+    },
+};
+
+class AXPVersionHistoryModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPVersionHistoryModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXPVersionHistoryModule, imports: [i1.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPVersionHistoryModule, providers: [
+            { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: historyLoggerMiddleware },
+            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: historyPlugin },
+            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: comparePlugin },
+        ], imports: [AXPWorkflowModule.forChild({
+                actions: {
+                    'show-version-history-popup-action': AXMVersionHistoryPopupStartAction,
                 },
-            },
-            {
-                provide: AXP_ENTITY_DEFINITION_LOADER,
-                useClass: AXMEntityCategoryProvider,
-                multi: true,
-            },
-        ] }); }
+                workflows: {
+                    'show-version-history-popup': AXMVersionHistoryPopupWorkflow,
+                },
+            })] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPCategoryModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPVersionHistoryModule, decorators: [{
             type: NgModule,
             args: [{
-                    providers: [
-                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: categoryPlugin },
-                        {
-                            provide: AXP_PERMISSION_DEFINITION_PROVIDER,
-                            multi: true,
-                            useFactory: () => {
-                                const provider = {
-                                    define: async (context) => {
-                                        // Generate permissions for any entity that declared category extension
-                                        // We can’t scan registry here reliably at bootstrap; rely on generic pattern per module via wildcard
-                                        // Consumers can still override with module-level providers.
-                                        // No-op here; permissions will be added when category entity is resolved via provideEntity elsewhere if needed.
-                                    },
-                                };
-                                return provider;
+                    imports: [
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                'show-version-history-popup-action': AXMVersionHistoryPopupStartAction,
                             },
-                        },
-                        {
-                            provide: AXP_ENTITY_DEFINITION_LOADER,
-                            useClass: AXMEntityCategoryProvider,
-                            multi: true,
-                        },
+                            workflows: {
+                                'show-version-history-popup': AXMVersionHistoryPopupWorkflow,
+                            },
+                        }),
+                    ],
+                    exports: [],
+                    providers: [
+                        { provide: AXP_ENTITY_STORAGE_MIDDLEWARE, multi: true, useValue: historyLoggerMiddleware },
+                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: historyPlugin },
+                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: comparePlugin },
                     ],
                 }]
         }] });
 
+const config = {
+    i18n: 'common',
+};
+const RootConfig = {
+    config,
+    module: {
+        module: 'common',
+        name: 'Common',
+        title: `t('module-name', {scope:"${config.i18n}"})`,
+        icon: 'fa-light fa-file-invoice',
+    },
+    entities: {},
+};
+
+class AXMMenuProvider {
+    constructor() {
+        this.sessionService = inject(AXPSessionService);
+        this.homePageService = inject(AXPHomePageService);
+    }
+    async provide(context) {
+        const scope = RootConfig.config.i18n;
+        const module = RootConfig.module;
+        const appName = this.sessionService.application?.name;
+        const isAuthorized = await firstValueFrom(this.sessionService.isAuthorized$);
+        if (!isAuthorized) {
+            return;
+        }
+        //
+        const homePagePath = this.homePageService.getCurrent().path;
+        if (homePagePath) {
+            context.addItems([
+                {
+                    priority: -9,
+                    text: `t('home',{scope:'common'})`,
+                    path: homePagePath,
+                    icon: 'fa-light fa-grid-2',
+                    data: {
+                    //requiredPermission: '',
+                    },
+                },
+            ]);
+        }
+        context.find('user-profile').addItems([
+            {
+                text: `t('user.title', {scope: "settings"})`,
+                name: 'user-settings',
+                icon: 'fa-light fa-gear',
+                path: `/${this.sessionService.application?.name}/settings/user`,
+            },
+        ]);
+        context.addItems([
+            {
+                name: 'tenant-application-settings',
+                priority: 10000000,
+                text: `t('tenant.title', {scope: "settings"})`,
+                type: 'menu',
+                icon: 'fa-light fa-gear',
+                path: `/${appName}/settings/tenant`,
+                data: {
+                    requiredPermission: 'admin',
+                },
+            },
+        ]);
+    }
+}
+
+class AXMPermissionDefinitionProvider {
+    async define(context) {
+        // context.addPermissions([
+        //   {
+        //     name: 'view_templates',
+        //     title: 'Permission to view templates',
+        //     isArchived: false,
+        //   },
+        // ]);
+    }
+}
+
+class AXMSearchCommandProvider extends AXPSearchCommandProvider {
+    constructor() {
+        super(...arguments);
+        this.commands = [
+        // {
+        //   group: 'command',
+        //  title: 'New Form Template',
+        //  icon: RootConfig.entities.template.icon,
+        //  description: 'Create a new form template for designing reusable forms.', // Added description
+        //  commands: {
+        //    'create-entity': {
+        //      entity: `${RootConfig.module.name}.${RootConfig.entities.template.name}`,
+        //    },
+        //  },
+        // }
+        ];
+    }
+}
+
+class AXMSettingProvider {
+    constructor(injector) {
+        this.injector = injector;
+        this.translateService = this.injector.get(AXTranslationService);
+    }
+    async provide(context) {
+        const trans = async (key) => await this.translateService.translateAsync(`settings.${key}`, { scope: 'general' });
+        // Find the 'General Settings' group
+        const group = context.group('general');
+        if (!group) {
+            return;
+        }
+        // Add the 'Release Notes' setting
+        // group.addSection('lock-system', await trans('general.lock-system.lock.title'), await trans('general.lock-system.lock.description')).addSetting({
+        //     key: AXMLockSystemSettings.LockSystem,  
+        //     title: await trans('general.lock-system.lock.title'),
+        //     scope: AXPPlatformScope.Tenant,
+        //     isInherited: true,
+        //     defaultValue: false,
+        //     valueTransforms: objectKeyValueTransforms('id'),
+        //     widget: {
+        //         type: AXPWidgetsCatalog.toggle,
+        //         options: {
+        //             label: null,
+        //         }
+        //     },
+        //     description: await trans('general.lock-system.lock.description'),
+        // })
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMSettingProvider, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMSettingProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMSettingProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+
 class AXMCommonModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.6", ngImport: i0, type: AXMCommonModule, imports: [AXMLockSystemModule,
@@ -1743,6 +3141,9 @@ class AXMCommonModule {
             AXPGlobalSearchModule,
             AXPWidgetsModule,
             AXPVersionHistoryModule,
+            AXPComputedPropertiesModule,
+            AXPClonePluginModule,
+            AXPArchivePluginModule,
             AXPCompareModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCommonModule, providers: [
             {
@@ -1781,6 +3182,9 @@ class AXMCommonModule {
             AXPGlobalSearchModule,
             AXPWidgetsModule,
             AXPVersionHistoryModule,
+            AXPComputedPropertiesModule,
+            AXPClonePluginModule,
+            AXPArchivePluginModule,
             AXPCompareModule] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXMCommonModule, decorators: [{
@@ -1793,6 +3197,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImpor
                         AXPGlobalSearchModule,
                         AXPWidgetsModule,
                         AXPVersionHistoryModule,
+                        AXPComputedPropertiesModule,
+                        AXPClonePluginModule,
+                        AXPArchivePluginModule,
                         AXPCompareModule,
                     ],
                     exports: [],
@@ -1922,7 +3329,7 @@ class AXPLockPopupComponent extends AXBasePageComponent {
                 // Angular
                 CommonModule }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1$3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: 
                 // ACoreX
-                AXButtonModule }, { kind: "component", type: i2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i1.AXDecoratorClearButtonComponent, selector: "ax-clear-button", inputs: ["icon"] }, { kind: "component", type: i1.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXFormModule }, { kind: "component", type: i4$1.AXFormFieldComponent, selector: "ax-form-field", inputs: ["labelMode"] }, { kind: "component", type: i4$1.AXFormComponent, selector: "ax-form", inputs: ["labelMode", "look", "messageStyle", "updateOn"], outputs: ["onValidate", "updateOnChange"] }, { kind: "directive", type: i4$1.AXValidationRuleDirective, selector: "ax-validation-rule", inputs: ["rule", "options", "message", "disabled"] }, { kind: "ngmodule", type: AXLabelModule }, { kind: "component", type: i5.AXLabelComponent, selector: "ax-label", inputs: ["required", "for"], outputs: ["requiredChange"] }, { kind: "ngmodule", type: AXSelectBoxModule }, { kind: "component", type: i6.AXSelectBoxComponent, selector: "ax-select-box", inputs: ["disabled", "readonly", "tabIndex", "placeholder", "minValue", "maxValue", "value", "state", "name", "id", "type", "look", "multiple", "valueField", "textField", "disabledField", "textTemplate", "selectedItems", "isItemTruncated", "showItemTooltip", "dataSource", "minRecordsForSearch", "caption", "itemTemplate", "selectedTemplate", "emptyTemplate", "loadingTemplate", "dropdownWidth", "searchBoxAutoFocus"], outputs: ["valueChange", "stateChange", "onValueChanged", "onBlur", "onFocus", "readonlyChange", "disabledChange", "onOpened", "onClosed"] }, { kind: "ngmodule", type: AXTextAreaModule }, { kind: "component", type: i7.AXTextAreaComponent, selector: "ax-text-area", inputs: ["disabled", "tabIndex", "readonly", "value", "state", "name", "placeholder", "maxLength", "look", "rows", "allowResize", "showCounter", "class"], outputs: ["onBlur", "onFocus", "valueChange", "stateChange", "onValueChanged", "readonlyChange", "disabledChange", "onKeyDown", "onKeyUp", "onKeyPress"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "directive", type: i4.AXTranslatorDirective, selector: "[translate]" }, { kind: "ngmodule", type: AXValidationModule }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }], encapsulation: i0.ViewEncapsulation.None }); }
+                AXButtonModule }, { kind: "component", type: i2.AXButtonComponent, selector: "ax-button", inputs: ["disabled", "size", "tabIndex", "color", "look", "text", "toggleable", "selected", "iconOnly", "type", "loadingText"], outputs: ["onBlur", "onFocus", "onClick", "selectedChange", "toggleableChange", "lookChange", "colorChange", "disabledChange", "loadingTextChange"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i1$1.AXDecoratorClearButtonComponent, selector: "ax-clear-button", inputs: ["icon"] }, { kind: "component", type: i1$1.AXDecoratorGenericComponent, selector: "ax-footer, ax-header, ax-content, ax-divider, ax-form-hint, ax-prefix, ax-suffix, ax-text, ax-title, ax-subtitle, ax-placeholder, ax-overlay" }, { kind: "ngmodule", type: AXFormModule }, { kind: "component", type: i4$1.AXFormFieldComponent, selector: "ax-form-field", inputs: ["labelMode"] }, { kind: "component", type: i4$1.AXFormComponent, selector: "ax-form", inputs: ["labelMode", "look", "messageStyle", "updateOn"], outputs: ["onValidate", "updateOnChange"] }, { kind: "directive", type: i4$1.AXValidationRuleDirective, selector: "ax-validation-rule", inputs: ["rule", "options", "message", "disabled"] }, { kind: "ngmodule", type: AXLabelModule }, { kind: "component", type: i5.AXLabelComponent, selector: "ax-label", inputs: ["required", "for"], outputs: ["requiredChange"] }, { kind: "ngmodule", type: AXSelectBoxModule }, { kind: "component", type: i6.AXSelectBoxComponent, selector: "ax-select-box", inputs: ["disabled", "readonly", "tabIndex", "placeholder", "minValue", "maxValue", "value", "state", "name", "id", "type", "look", "multiple", "valueField", "textField", "disabledField", "textTemplate", "selectedItems", "isItemTruncated", "showItemTooltip", "dataSource", "minRecordsForSearch", "caption", "itemTemplate", "selectedTemplate", "emptyTemplate", "loadingTemplate", "dropdownWidth", "searchBoxAutoFocus"], outputs: ["valueChange", "stateChange", "onValueChanged", "onBlur", "onFocus", "readonlyChange", "disabledChange", "onOpened", "onClosed", "onItemSelected", "onItemClick"] }, { kind: "ngmodule", type: AXTextAreaModule }, { kind: "component", type: i7.AXTextAreaComponent, selector: "ax-text-area", inputs: ["disabled", "tabIndex", "readonly", "value", "state", "name", "placeholder", "maxLength", "look", "rows", "allowResize", "showCounter", "class"], outputs: ["onBlur", "onFocus", "valueChange", "stateChange", "onValueChanged", "readonlyChange", "disabledChange", "onKeyDown", "onKeyUp", "onKeyPress"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "directive", type: i4.AXTranslatorDirective, selector: "[translate]" }, { kind: "ngmodule", type: AXValidationModule }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }], encapsulation: i0.ViewEncapsulation.None }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.6", ngImport: i0, type: AXPLockPopupComponent, decorators: [{
             type: Component,