@acorex/modules 20.0.25 → 20.1.0

package/fesm2022/acorex-modules-platform-management.mjs

@@ -1,2 +1,3480 @@
-export { e as AXMAppTermService, f as AXMAppTermServiceImpl, a as AXMAppVersionService, l as AXMAppVersionServiceImpl, n as AXMAppVersionSlotComponent, o as AXMChangeLogPopupAction, p as AXMChangeLogUpdateSettingAction, r as AXMCheckNewVersionAction, s as AXMCheckNewVersionWorkflow, C as AXMColumnFilterSelectorWidget, F as AXMColumnFilterSelectorWidgetColumnComponent, D as AXMColumnFilterSelectorWidgetEditComponent, G as AXMColumnFilterSelectorWidgetFilterComponent, H as AXMColumnFilterSelectorWidgetPrintComponent, E as AXMColumnFilterSelectorWidgetViewComponent, w as AXMDataSourceOutputType, u as AXMDataSourceService, v as AXMDataSourceServiceImpl, x as AXMDataSourceType, B as AXMDynamicDataSourceProvider, J as AXMGlobalVariablesService, K as AXMGlobalVariablesServiceImpl, M as AXMGlossaryService, N as AXMGlossaryServiceImpl, g as AXMListTermsComponent, T as AXMMetaDataDefinitionCategoryService, U as AXMMetaDataDefinitionCategoryServiceImpl, P as AXMMetaDataDefinitionService, j as AXMNewTermWorkflow, m as AXMNotifyAppComponent, h as AXMNotifyNewTermPopupAction, Q as AXMPMetaDataDefinitionServiceImpl, b as AXMPlatformManagementModule, c as AXMPlatformManagementWidgetsModule, i as AXMTermUpdateSettingAction, W as AXMUpdaterModule, q as AXMWhatsNewWorkflow, y as AXM_COLUMN_DEF_WIDGET, z as AXM_FILTER_DEF_WIDGET, V as AXPRegionalStoreService, X as AXPUpdaterService, R as RootConfig, d as appTermEntityEntityFactory, k as appVersionEntityEntityFactory, t as dataSourceEntityFactory, I as globalVariableEntityFactory, L as glossaryEntityFactory, S as metaDataDefinitionCategoryEntityFactory, O as metaDataDefinitionFactory } from './acorex-modules-platform-management-acorex-modules-platform-management-BLhzWiXM.mjs';
+import { createAllQueryView, AXPEntityCommandScope, AXPEntityQueryType, AXPSettingService, AXP_APP_VERSION_PROVIDER, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER } from '@acorex/platform/common';
+import * as i4$1 from '@acorex/platform/layout/components';
+import { AXPThemeLayoutBlockComponent, AXPComponentSlotModule } from '@acorex/platform/layout/components';
+import { AXMEntityCrudServiceImpl, AXPEntityService, AXP_ENTITY_CONFIG_TOKEN, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import * as i3$2 from '@acorex/platform/workflow';
+import { AXPWorkflowAction, AXPWorkflowService, AXPWorkflowTaskProvider, AXPWorkflowModule, AXP_WORKFLOW_TASK_PROVIDER } from '@acorex/platform/workflow';
+import * as i0 from '@angular/core';
+import { Injectable, inject, signal, HostListener, Component, Input, Injector, NgModule } from '@angular/core';
+import { ROUTES } from '@angular/router';
+import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
+import * as i3 from '@acorex/cdk/outline';
+import { AXOutlineModule } from '@acorex/cdk/outline';
+import * as i3$1 from '@acorex/components/decorators';
+import { AXDecoratorModule } from '@acorex/components/decorators';
+import * as i2 from '@acorex/components/side-menu';
+import { AXSideMenuModule } from '@acorex/components/side-menu';
+import * as i5$1 from '@acorex/core/format';
+import { AXFormatModule } from '@acorex/core/format';
+import * as i6 from '@acorex/core/translation';
+import { AXTranslationModule, AXTranslationService } from '@acorex/core/translation';
+import { AXPPageLayoutBaseComponent, AXPPageLayoutComponent, AXPPageLayoutBase } from '@acorex/platform/layout/views';
+import * as i5 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import { AXSafePipe } from '@acorex/core/pipes';
+import { AXPopupService } from '@acorex/components/popup';
+import { AXPPlatformScope, AXPAppStartUpService, objectKeyValueTransforms } from '@acorex/platform/core';
+import * as i4 from '@acorex/components/button';
+import { AXButtonModule } from '@acorex/components/button';
+import * as i2$1 from '@acorex/components/check-box';
+import { AXCheckBoxModule } from '@acorex/components/check-box';
+import * as i1 from '@acorex/components/label';
+import { AXLabelModule } from '@acorex/components/label';
+import { AXBasePageComponent } from '@acorex/components/page';
+import { DomSanitizer } from '@angular/platform-browser';
+import { AXPWidgetsList } from '@acorex/modules/common';
+import { AXPSessionService } from '@acorex/platform/auth';
+import { AXDialogService } from '@acorex/components/dialog';
+import { SwUpdate } from '@angular/service-worker';
+import { firstValueFrom } from 'rxjs';
+import { AXCalendarService } from '@acorex/core/date-time';
+
+const config = {
+    i18n: 'platform-management',
+};
+const RootConfig = {
+    config,
+    module: {
+        route: 'platform-management',
+        name: 'PlatformManagement',
+        title: `t('platformManagement', {scope:"${config.i18n}"})`,
+        icon: 'fa-light fa-cogs',
+    },
+    entities: {
+        glossary: {
+            name: 'Glossary',
+            title: `t("glossary.individual-title", { scope: "${config.i18n}" })`,
+            titlePlural: `t("glossary.plural-title", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-file',
+        },
+        localizationManagement: {
+            name: 'Localization Management',
+            title: `t("localization-management", {scope:"${config.i18n}"})`,
+            icon: 'fa-light fa-globe',
+        },
+        globalVariable: {
+            name: 'GlobalVariables',
+            title: `t("variables", {scope:"${config.i18n}"})`,
+            icon: 'fa-light fa-object-exclude',
+        },
+        appVersion: {
+            name: 'app-version',
+            title: `t("appVersion", {scope:"${config.i18n}"})`,
+            titlePlural: `t("appVersionPlural", {scope:"${config.i18n}"})`,
+            icon: 'fa-light fa-code-branch',
+        },
+        appTerm: {
+            name: 'app-term',
+            title: `t("app-term.individual-title", {scope:"${config.i18n}"})`,
+            titlePlural: `t("app-term.plural-title", {scope:"${config.i18n}"})`,
+            pageTitle: `t("app-term.page-title", {scope:"${config.i18n}"})`,
+            pageDescription: `t("app-term.page-description", {scope:"${config.i18n}"})`,
+            icon: 'fa-light fa-scale-balanced',
+        },
+        metaDataDefinitionCategory: {
+            name: 'MetaDataDefinitionCategory',
+            title: `t("MetaDataDefinitionCategory", {scope:"${config.i18n}"})`,
+            titlePlural: `t("MetaDataDefinitionCategoryPlural", {scope:"${config.i18n}"})`,
+            icon: 'fa-light fa-list',
+        },
+        metaDataDefinition: {
+            name: 'MetaDataDefinition',
+            title: `t("metaDataDefinition", {scope:"${config.i18n}"})`,
+            titlePlural: `t("metaDataDefinitionPlural", {scope:"${config.i18n}"})`,
+            icon: 'fa-light fa-server',
+        },
+    },
+};
+
+class AXMAppTermService extends AXMEntityCrudServiceImpl {
+}
+class AXMAppTermServiceImpl extends AXMEntityCrudServiceImpl {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.appTerm.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMAppTermServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMAppTermServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMAppTermServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function appTermEntityEntityFactory(injector) {
+    const dataService = injector.get(AXMAppTermService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.appTerm.name,
+        source: '',
+        title: RootConfig.entities.appTerm.title,
+        formats: {
+            individual: RootConfig.entities.appTerm.title,
+            plural: RootConfig.entities.appTerm.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.appTerm.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'type',
+                title: `t("type", { scope: "common" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: `t("title", { scope: "common" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'content',
+                title: `t("content", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.richText,
+                        options: {
+                            minLineCount: 5,
+                            maxLineCount: 17,
+                            isFitLine: true,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'version',
+                title: `t("version", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsCatalog.number,
+                    },
+                },
+                options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                    },
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'effectiveDate',
+                title: `t("effectiveDate", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'dateTime',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                    },
+                },
+                options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                    },
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'title' }, { name: 'content' }, { name: 'version' }, { name: 'effectiveDate' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    return Promise.resolve({ id: await dataService.insertOne(data) });
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    await await dataService.deleteOne(id);
+                    return Promise.resolve();
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            await dataService.updateOne(data.id, data);
+                            resolve(data);
+                        }, 1000);
+                    });
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            const entity = await dataService.getOne(id);
+                            resolve(entity);
+                        }, 500);
+                    });
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    const x = await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                    return x;
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'version',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'content',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 10,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'effectiveDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'version',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'content',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 10,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'effectiveDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'type',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'version',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'content',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 10,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'effectiveDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: 'Create New',
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 'Delete Items',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 'Details',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 'Delete',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMListTermsComponent extends AXPPageLayoutBaseComponent {
+    constructor() {
+        super(...arguments);
+        this.service = inject(AXMAppTermService);
+        this.terms = [];
+        this.loaded = signal(false, ...(ngDevMode ? [{ debugName: "loaded" }] : []));
+        this.showScrollSide = signal(true, ...(ngDevMode ? [{ debugName: "showScrollSide" }] : []));
+    }
+    ngAfterViewInit() {
+        this.checkScroll();
+    }
+    onResize() {
+        this.checkScroll();
+    }
+    checkScroll() {
+        const contentElement = document.getElementById('contentDiv');
+        if (contentElement != null) {
+            this.showScrollSide.set(contentElement.offsetHeight > window.innerHeight - 140);
+        }
+    }
+    async ngOnInit() {
+        super.ngOnInit();
+        const result = await this.service.query({
+            skip: 0,
+            take: 1000,
+        });
+        this.terms = result.items.map((term) => {
+            return {
+                ...term,
+                content: term.content.replace(/\n/g, "<br>"),
+            };
+        });
+        this.loaded.set(true);
+        setTimeout(() => this.checkScroll(), 50);
+    }
+    getPageTitle() {
+        return RootConfig.entities.appTerm.pageTitle;
+    }
+    getPageDescription() {
+        return RootConfig.entities.appTerm.pageDescription;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMListTermsComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.1.3", type: AXMListTermsComponent, isStandalone: true, selector: "ng-component", host: { listeners: { "window:resize": "onResize($event)" } }, providers: [
+            {
+                provide: AXPPageLayoutBase,
+                useExisting: AXMListTermsComponent,
+            },
+        ], usesInheritance: true, ngImport: i0, template: "<axp-page-layout *translate=\"let t\">\n  @if(loaded()){\n  <axp-page-content id=\"contentDiv\" axOutlineContainer target=\"h2\" [scrollableElementId]=\"'axp-page-layout'\"\n    [activationOffset]=\"120\" class=\"ax-flex ax-flex-row\">\n    <div class=\"ax-flex ax-flex-col\">\n      @for (term of terms; track term.id) {\n      <div class=\"ax-flex ax-flex-col\">\n        <h2 class=\"ax-px-4 ax-font-semibold ax-text-xl\">{{ term.title }}</h2>\n        <p class=\"ax-px-4 ax-text-sm ax-leading-5  ax-opacity-65\">\n          {{ term.effectiveDate | format : 'datetime' | async }}\n        </p>\n        <div class=\"ax-pt-3 ax-pb-6 ax-px-4 ax-text-base/6\" [innerHTML]=\"term.content | safe:'html'\"></div>\n      </div>\n      }\n    </div>\n    @if(showScrollSide()){\n    <div class=\"ax-hidden lg:ax-block ax-min-w-60\">\n      <ax-side-menu axOutlineSideMenu look=\"with-line\" class=\"ax-w-full ax-sticky ax-top-24\"></ax-side-menu>\n    </div>\n    }\n  </axp-page-content>\n  }\n</axp-page-layout>", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "ngmodule", type: AXFormatModule }, { kind: "component", type: AXPThemeLayoutBlockComponent, selector: "    axp-page-content,     axp-page-footer-container,    axp-page-footer,    axp-page-header,    axp-page-header-container,    axp-page-toolbar,    axp-layout-content,     axp-layout-page-content,     axp-layout-sections,    axp-layout-body,    axp-layout-page-body,    axp-layout-prefix,    axp-layout-suffix,    axp-layout-title-bar,    axp-layout-title,     axp-layout-title-actions,     axp-layout-nav-button,     axp-layout-description,     axp-layout-breadcrumbs,    axp-layout-list-action,    " }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "directive", type: i6.AXTranslatorDirective, selector: "[translate]" }, { kind: "ngmodule", type: AXSideMenuModule }, { kind: "component", type: i2.AXSideMenuComponent, selector: "ax-side-menu", inputs: ["items", "look", "location"], outputs: ["itemsChange"] }, { kind: "directive", type: i2.AXOutlineSideMenuDirective, selector: "[axOutlineSideMenu]", exportAs: ["axOutlineSideMenu"] }, { kind: "ngmodule", type: AXOutlineModule }, { kind: "directive", type: i3.AXOutlineContainerDirective, selector: "[axOutlineContainer]", inputs: ["target", "smoothScroll", "showHashItem", "activationOffset", "copyUrlOnClick", "activateLastAtBottom", "scrollableElementId"], exportAs: ["axOutlineContainer"] }, { kind: "component", type: AXPPageLayoutComponent, selector: "axp-page-layout" }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }, { kind: "pipe", type: i5$1.AXFormatPipe, name: "format" }, { kind: "pipe", type: AXSafePipe, name: "safe" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMListTermsComponent, decorators: [{
+            type: Component,
+            args: [{ imports: [
+                        CommonModule,
+                        AXDecoratorModule,
+                        AXFormatModule,
+                        AXPThemeLayoutBlockComponent,
+                        AXTranslationModule,
+                        AXSideMenuModule,
+                        AXOutlineModule,
+                        AXPPageLayoutComponent,
+                        AXSafePipe
+                    ], providers: [
+                        {
+                            provide: AXPPageLayoutBase,
+                            useExisting: AXMListTermsComponent,
+                        },
+                    ], template: "<axp-page-layout *translate=\"let t\">\n  @if(loaded()){\n  <axp-page-content id=\"contentDiv\" axOutlineContainer target=\"h2\" [scrollableElementId]=\"'axp-page-layout'\"\n    [activationOffset]=\"120\" class=\"ax-flex ax-flex-row\">\n    <div class=\"ax-flex ax-flex-col\">\n      @for (term of terms; track term.id) {\n      <div class=\"ax-flex ax-flex-col\">\n        <h2 class=\"ax-px-4 ax-font-semibold ax-text-xl\">{{ term.title }}</h2>\n        <p class=\"ax-px-4 ax-text-sm ax-leading-5  ax-opacity-65\">\n          {{ term.effectiveDate | format : 'datetime' | async }}\n        </p>\n        <div class=\"ax-pt-3 ax-pb-6 ax-px-4 ax-text-base/6\" [innerHTML]=\"term.content | safe:'html'\"></div>\n      </div>\n      }\n    </div>\n    @if(showScrollSide()){\n    <div class=\"ax-hidden lg:ax-block ax-min-w-60\">\n      <ax-side-menu axOutlineSideMenu look=\"with-line\" class=\"ax-w-full ax-sticky ax-top-24\"></ax-side-menu>\n    </div>\n    }\n  </axp-page-content>\n  }\n</axp-page-layout>" }]
+        }], propDecorators: { onResize: [{
+                type: HostListener,
+                args: ['window:resize', ['$event']]
+            }] } });
+
+var listTerms_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMListTermsComponent: AXMListTermsComponent
+});
+
+class AXMNotifyAppTermComponent extends AXBasePageComponent {
+    constructor() {
+        super(...arguments);
+        this.isConfirm = false;
+        this.i18n = RootConfig.config.i18n;
+    }
+    transformContent(content) {
+        return content.replace(/\n/g, '<br>');
+    }
+    send() {
+        this.close({ data: this.data });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMNotifyAppTermComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.1.3", type: AXMNotifyAppTermComponent, isStandalone: true, selector: "axm-notify-app", usesInheritance: true, ngImport: i0, template: "@for (item of data; track $index) {\n<ax-content class=\"ax-block ax-px-4 ax-py-4 ax-font-bold\">{{ item.title }}</ax-content>\n<ax-content class=\"ax-block ax-px-4 ax-pb-4 ax-text-base/6\" [innerHTML]=\"transformContent(item.content) | safe : 'html'\"></ax-content>\n}\n<ax-footer class=\"ax-flex ax-items-center ax-justify-between ax-p-2\">\n  <ax-check-box [(value)]=\"isConfirm\">\n    <ax-label>{{ 'agreeTerm' | translate : { scope: i18n } | async }}</ax-label>\n  </ax-check-box>\n  <ax-button (click)=\"send()\" [text]=\"'okay' | translate | async\" [disabled]=\"!isConfirm\" color=\"primary\"></ax-button>\n</ax-footer>", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXLabelModule }, { kind: "component", type: i1.AXLabelComponent, selector: "ax-label", inputs: ["required", "for"], outputs: ["requiredChange"] }, { kind: "ngmodule", type: AXCheckBoxModule }, { kind: "component", type: i2$1.AXCheckBoxComponent, selector: "ax-check-box", inputs: ["disabled", "tabIndex", "readonly", "color", "value", "name", "id", "checked", "isLoading", "indeterminate"], outputs: ["onBlur", "onFocus", "valueChange", "onValueChanged"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i3$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: i4.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: "pipe", type: i5.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.AXTranslatorPipe, name: "translate" }, { kind: "pipe", type: AXSafePipe, name: "safe" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMNotifyAppTermComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-notify-app', imports: [
+                        CommonModule,
+                        AXLabelModule,
+                        AXCheckBoxModule,
+                        AXDecoratorModule,
+                        AXButtonModule,
+                        AXTranslationModule,
+                        AXSafePipe,
+                    ], template: "@for (item of data; track $index) {\n<ax-content class=\"ax-block ax-px-4 ax-py-4 ax-font-bold\">{{ item.title }}</ax-content>\n<ax-content class=\"ax-block ax-px-4 ax-pb-4 ax-text-base/6\" [innerHTML]=\"transformContent(item.content) | safe : 'html'\"></ax-content>\n}\n<ax-footer class=\"ax-flex ax-items-center ax-justify-between ax-p-2\">\n  <ax-check-box [(value)]=\"isConfirm\">\n    <ax-label>{{ 'agreeTerm' | translate : { scope: i18n } | async }}</ax-label>\n  </ax-check-box>\n  <ax-button (click)=\"send()\" [text]=\"'okay' | translate | async\" [disabled]=\"!isConfirm\" color=\"primary\"></ax-button>\n</ax-footer>" }]
+        }] });
+
+class AXMNotifyNewTermPopupAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+    }
+    async execute(context) {
+        const data = context.getVariable();
+        await this.popupService.open(AXMNotifyAppTermComponent, {
+            title: 'New Terms And Conditions',
+            data: { data },
+            closeButton: false,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMNotifyNewTermPopupAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMNotifyNewTermPopupAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMNotifyNewTermPopupAction, decorators: [{
+            type: Injectable
+        }] });
+class AXMTermUpdateSettingAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.settingService = inject(AXPSettingService);
+    }
+    async execute(context) {
+        const dataList = context.getVariable();
+        for (const data of dataList) {
+            await this.settingService.scope(AXPPlatformScope.User).set(`is-confirm-term-${data.id}`, true);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMTermUpdateSettingAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMTermUpdateSettingAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMTermUpdateSettingAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMNewTermWorkflow = {
+    startStepId: 'show-popup',
+    steps: {
+        'show-popup': {
+            action: 'AXMNotifyNewTermPopupAction',
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'first-time-add-to-setting',
+                },
+            ],
+        },
+        'first-time-add-to-setting': {
+            action: 'AXMTermUpdateSettingAction',
+        },
+    },
+};
+
+class AXMAppVersionService extends AXMEntityCrudServiceImpl {
+}
+class AXMAppVersionServiceImpl extends AXMEntityCrudServiceImpl {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.appVersion.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMAppVersionServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMAppVersionServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMAppVersionServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function appVersionEntityEntityFactory(injector) {
+    const dataService = injector.get(AXMAppVersionService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.appVersion.name,
+        source: '',
+        title: RootConfig.entities.appVersion.title,
+        formats: {
+            individual: RootConfig.entities.appVersion.title,
+            plural: RootConfig.entities.appVersion.title,
+            searchResult: {
+                title: '{{ versionNumber }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.appVersion.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'versionNumber',
+                title: `t("versionNumber", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'changeLog',
+                title: `t("changeLogs", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.richText,
+                        options: {
+                            minLineCount: 5,
+                            maxLineCount: 17,
+                            isFitLine: true,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'publishDate',
+                title: `t("publishDate", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'dateTime',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                    },
+                },
+                options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                    },
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'showFirstTimePopup',
+                title: `t("notifyUser", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.checkbox,
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'versionNumber' },
+            { name: 'changeLog' },
+            { name: 'publishDate' },
+            { name: 'showFirstTimePopup' },
+        ],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    return Promise.resolve({ id: await dataService.insertOne(data) });
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    await await dataService.deleteOne(id);
+                    return Promise.resolve();
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            await dataService.updateOne(data.id, data);
+                            resolve(data);
+                        }, 1000);
+                    });
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            const entity = await dataService.getOne(id);
+                            resolve(entity);
+                        }, 500);
+                    });
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    console.log(e);
+                    const x = await dataService.query({ skip: e.skip, take: e.take, filter: e.filter, sort: e.sort });
+                    return x;
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'versionNumber',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        order: 1,
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'publishDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        order: 2,
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'showFirstTimePopup',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'changeLog',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        order: 10,
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'versionNumber',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'publishDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'showFirstTimePopup',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'changeLog',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{versionNumber}}',
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'versionNumber',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'publishDate',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'showFirstTimePopup',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'changeLog',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 8,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: 'Create New',
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 'Delete Items',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 'Details',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 'Delete',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [createAllQueryView({ sorts: [{ name: 'versionNumber', dir: 'desc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMNotifyAppComponent extends AXBasePageComponent {
+    constructor() {
+        super(...arguments);
+        this.isShowAgain = true;
+        this.sanitize = inject(DomSanitizer);
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.safeData = this.sanitize.bypassSecurityTrustHtml(this.data.changeLog);
+    }
+    send() {
+        this.close({ data: this.data, isShowAgain: !this.isShowAgain });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMNotifyAppComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.1.3", type: AXMNotifyAppComponent, isStandalone: true, selector: "axm-notify-app", usesInheritance: true, ngImport: i0, template: "<ax-content class=\"ax-block ax-px-4 ax-py-4 ax-text-base/6\" [innerHTML]=\"safeData\"></ax-content>\n<ax-footer class=\"ax-flex ax-items-center ax-justify-between ax-p-2\">\n  <ax-check-box [(value)]=\"isShowAgain\">\n    <ax-label>Don't Show Again</ax-label>\n  </ax-check-box>\n  <ax-button color=\"primary\" (click)=\"send()\" [text]=\"'okay' | translate | async\"></ax-button>\n</ax-footer>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: AXLabelModule }, { kind: "component", type: i1.AXLabelComponent, selector: "ax-label", inputs: ["required", "for"], outputs: ["requiredChange"] }, { kind: "ngmodule", type: AXCheckBoxModule }, { kind: "component", type: i2$1.AXCheckBoxComponent, selector: "ax-check-box", inputs: ["disabled", "tabIndex", "readonly", "color", "value", "name", "id", "checked", "isLoading", "indeterminate"], outputs: ["onBlur", "onFocus", "valueChange", "onValueChanged"] }, { kind: "ngmodule", type: AXDecoratorModule }, { kind: "component", type: i3$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: i4.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: "pipe", type: i5.AsyncPipe, name: "async" }, { kind: "pipe", type: i6.AXTranslatorPipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMNotifyAppComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'axm-notify-app', imports: [CommonModule, AXLabelModule, AXCheckBoxModule, AXDecoratorModule, AXButtonModule, AXTranslationModule], template: "<ax-content class=\"ax-block ax-px-4 ax-py-4 ax-text-base/6\" [innerHTML]=\"safeData\"></ax-content>\n<ax-footer class=\"ax-flex ax-items-center ax-justify-between ax-p-2\">\n  <ax-check-box [(value)]=\"isShowAgain\">\n    <ax-label>Don't Show Again</ax-label>\n  </ax-check-box>\n  <ax-button color=\"primary\" (click)=\"send()\" [text]=\"'okay' | translate | async\"></ax-button>\n</ax-footer>\n" }]
+        }] });
+
+var notifyApp_component = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMNotifyAppComponent: AXMNotifyAppComponent
+});
+
+class AXMAppVersionSlotComponent {
+    constructor() {
+        this.versionProvider = inject(AXP_APP_VERSION_PROVIDER);
+        this.workflowService = inject(AXPWorkflowService);
+        this.versionNumber = '';
+    }
+    async ngOnInit() {
+        this.versionNumber = (await this.versionProvider.provider()).version;
+    }
+    openPopup() {
+        this.workflowService.execute('show-release-notes');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMAppVersionSlotComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.1.3", type: AXMAppVersionSlotComponent, isStandalone: true, selector: "ng-component", inputs: { text: "text" }, ngImport: i0, template: ` <small class="ax-text-sm ax-cursor-pointer" (click)="openPopup()">{{ versionNumber }}</small> `, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMAppVersionSlotComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ` <small class="ax-text-sm ax-cursor-pointer" (click)="openPopup()">{{ versionNumber }}</small> `,
+                    standalone: true,
+                }]
+        }], propDecorators: { text: [{
+                type: Input
+            }] } });
+
+class AppVersionCheckService {
+    constructor() {
+        this.versionProvider = inject(AXP_APP_VERSION_PROVIDER);
+        this.settingsService = inject(AXPSettingService);
+        this.workflowService = inject(AXPWorkflowService);
+        this.appVersionService = inject(AXMAppVersionService);
+    }
+    async checkVersion() {
+        const current = (await this.versionProvider.provider()).version;
+        const initVersion = await this.settingsService.scope(AXPPlatformScope.User).get(`init-application-version`);
+        if (initVersion == null) {
+            await this.settingsService.scope(AXPPlatformScope.User).set(`init-application-version`, current);
+        }
+        else {
+            const versions = await this.appVersionService.query();
+            for (const v of versions.items) {
+                if (v.versionNumber == current && v.versionNumber != initVersion) {
+                    const isSee = await this.settingsService
+                        .scope(AXPPlatformScope.User)
+                        .get(`is-see-check-version-${v.versionNumber}`);
+                    if (!isSee) {
+                        setTimeout(() => {
+                            this.workflowService.execute('show-what-is-new', v);
+                        }, 300);
+                    }
+                }
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AppVersionCheckService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AppVersionCheckService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AppVersionCheckService, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMChangeLogPopupAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+    }
+    async execute(context) {
+        const data = context.getVariable();
+        const comp = (await Promise.resolve().then(function () { return notifyApp_component; })).AXMNotifyAppComponent;
+        const result = await this.popupService.open(comp, {
+            title: `New Features in Version ${data.versionNumber}`,
+            data: { data },
+        });
+        if (result.data?.isShowAgain) {
+            context.setOutput('result', false);
+        }
+        else {
+            context.setOutput('result', true);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMChangeLogPopupAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMChangeLogPopupAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMChangeLogPopupAction, decorators: [{
+            type: Injectable
+        }] });
+class AXMChangeLogUpdateSettingAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.settingService = inject(AXPSettingService);
+    }
+    async execute(context) {
+        const data = context.getVariable();
+        if (context.getOutput('result')) {
+            await this.settingService.scope(AXPPlatformScope.User).set(`is-see-check-version-${data.versionNumber}`, true);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMChangeLogUpdateSettingAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMChangeLogUpdateSettingAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMChangeLogUpdateSettingAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMWhatsNewWorkflow = {
+    startStepId: 'show-popup',
+    steps: {
+        'show-popup': {
+            action: 'AXMChangeLogPopupAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("result") == true' }],
+                    nextStepId: 'first-time-add-to-setting',
+                },
+            ],
+        },
+        'first-time-add-to-setting': {
+            action: 'AXMChangeLogUpdateSettingAction',
+        },
+    },
+};
+class AXMCheckNewVersionAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.appVersionCheckService = inject(AppVersionCheckService);
+        this.settingService = inject(AXPSettingService);
+    }
+    async execute(context) {
+        const shouldShow = await this.settingService.scope(AXPPlatformScope.User).get(`general:startup:release-notes`);
+        if (shouldShow == false) {
+            return;
+        }
+        await this.appVersionCheckService.checkVersion();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCheckNewVersionAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCheckNewVersionAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMCheckNewVersionAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMCheckNewVersionWorkflow = {
+    startStepId: 'check-new-version',
+    steps: {
+        'check-new-version': {
+            action: 'AXMCheckNewVersionAction',
+        },
+    },
+};
+
+class AXMGlobalVariablesService extends AXMEntityCrudServiceImpl {
+}
+class AXMGlobalVariablesServiceImpl extends AXMEntityCrudServiceImpl {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.globalVariable.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMGlobalVariablesServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMGlobalVariablesServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMGlobalVariablesServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function globalVariableEntityFactory(injector) {
+    const dataService = injector.get(AXMGlobalVariablesService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.globalVariable.name,
+        source: '',
+        title: RootConfig.entities.globalVariable.title,
+        formats: {
+            individual: 'Global Variable',
+            plural: 'Global Variables',
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: 'Global Variable',
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: `t("name", { scope: "common" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+                options: {
+                    filter: {
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                    sort: {
+                        enabled: true,
+                    },
+                },
+            },
+            {
+                name: 'title',
+                title: `t("title", { scope: "common" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+                options: {
+                    filter: {
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                    sort: {
+                        enabled: true,
+                    },
+                },
+            },
+            {
+                name: 'value',
+                title: `t("value", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'dataType',
+                title: `t("dataType", { scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            valueField: 'name',
+                            textField: 'title',
+                            dataSource: [
+                                { title: 'String', name: 'String' },
+                                { title: 'Integer', name: 'integer' },
+                                { title: 'Date Time', name: 'dateTime' },
+                                { title: 'Boolean', name: 'boolean' },
+                                { title: 'Function', name: 'function' },
+                                { title: 'Custom', name: 'custom' },
+                            ],
+                            direction: 'horizontal',
+                            multiple: false,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+                options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                    },
+                    sort: {
+                        enabled: true,
+                    },
+                },
+            },
+        ],
+        columns: [{ name: 'title' }, { name: 'dataType' }, { name: 'value' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    return Promise.resolve({ id: await dataService.insertOne(data) });
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    await await dataService.deleteOne(id);
+                    return Promise.resolve();
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            await dataService.updateOne(data.id, data);
+                            resolve(data);
+                        }, 1000);
+                    });
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return new Promise((resolve) => {
+                        setTimeout(async () => {
+                            const entity = await dataService.getOne(id);
+                            resolve(entity);
+                        }, 500);
+                    });
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    const x = await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                    console.log(x);
+                    return x;
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'value',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'dataType',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'value',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'dataType',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'value',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'dataType',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: `t("create", { scope: "common" })`,
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 't("delete", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        {
+                            name: 'all',
+                            title: 't("allItem", { scope: "common" })',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMGlossaryService extends AXMEntityCrudServiceImpl {
+}
+class AXMGlossaryServiceImpl extends AXMGlossaryService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.glossary.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMGlossaryServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMGlossaryServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMGlossaryServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function glossaryEntityFactory(injector) {
+    const dataService = injector.get(AXMGlossaryService);
+    const i18n = RootConfig.config.i18n + '.glossary';
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.glossary.name,
+        source: '',
+        title: RootConfig.entities.glossary.title,
+        formats: {
+            individual: RootConfig.entities.glossary.title,
+            plural: RootConfig.entities.glossary.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.glossary.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'title',
+                title: `t("title", { scope: "${i18n}" })`,
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'parentId',
+                title: `t("parentId",{ scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.LookupBox,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.glossary.name}`,
+                        },
+                    },
+                },
+            },
+            {
+                name: 'translation',
+                title: `t("translation",{ scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.glossary.name}`,
+                            multiLanguage: true,
+                        },
+                    },
+                },
+            },
+        ],
+        columns: [{ name: 'title' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'parentId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'translation',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'parentId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'translation',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            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: 'translation',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: `t("create", { scope: "common" })`,
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("detail", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 't("delete", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMMetaDataDefinitionService extends AXMEntityCrudServiceImpl {
+}
+class AXMPMetaDataDefinitionServiceImpl extends AXMMetaDataDefinitionService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.metaDataDefinition.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMPMetaDataDefinitionServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMPMetaDataDefinitionServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMPMetaDataDefinitionServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function metaDataDefinitionFactory(injector) {
+    const dataService = injector.get(AXMMetaDataDefinitionService);
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.metaDataDefinition.name,
+        source: '',
+        title: RootConfig.entities.metaDataDefinition.title,
+        formats: {
+            individual: RootConfig.entities.metaDataDefinition.title,
+            plural: RootConfig.entities.metaDataDefinition.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        versionHistory: {
+            enabled: true,
+            showInList: true,
+            showInDetail: true,
+        },
+        category: {
+            entity: `${RootConfig.module.name}.${RootConfig.entities.metaDataDefinitionCategory.name}`,
+            title: 'Categories',
+            textField: 'title',
+            valueField: 'id',
+            applyConditions: [
+                {
+                    name: 'categoryIds',
+                    operator: {
+                        type: 'contains',
+                    },
+                    value: 'id',
+                },
+            ],
+        },
+        groups: [
+            {
+                id: 'section',
+                title: RootConfig.entities.metaDataDefinition.title,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: 't("name", { scope: "common" })',
+                groupId: 'section',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: 't("title", { scope: "common" })',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'description',
+                title: 't("description", { scope: "common" })',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+            },
+            {
+                name: 'categoryIds',
+                title: 't("category", { scope: "common" })',
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.metaDataDefinitionCategory.name}`,
+                            multiple: true,
+                            expose: [
+                                { source: 'id', target: 'categories.{id}' },
+                                { source: 'title', target: 'categories.{title}' },
+                            ],
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'interface',
+                title: `t("interface", { scope: "${RootConfig.config.i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.templateDesigner,
+                        options: {
+                            embedded: true,
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [
+            { name: 'name' },
+            { name: 'title' },
+            { name: 'description' },
+            { name: 'categoryIds', options: { dataPath: 'categories' } },
+        ],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'categoryIds',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'interface',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'categoryIds',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'interface',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'categoryIds',
+                            dataPath: 'categories',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'interface',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: `t("create", { scope: "common" })`,
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("detail", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 't("delete", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [createAllQueryView({ sorts: [{ name: 'title', dir: 'asc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMMetaDataDefinitionCategoryService extends AXMEntityCrudServiceImpl {
+}
+class AXMMetaDataDefinitionCategoryServiceImpl extends AXMMetaDataDefinitionCategoryService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.metaDataDefinitionCategory.name}`);
+    }
+    getAllWithItems() {
+        throw new Error('Not implemented');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMMetaDataDefinitionCategoryServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMMetaDataDefinitionCategoryServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMMetaDataDefinitionCategoryServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function metaDataDefinitionCategoryEntityFactory(injector) {
+    const dataService = injector.get(AXMMetaDataDefinitionCategoryService);
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.metaDataDefinitionCategory.name,
+        parentKey: 'parentId',
+        source: '',
+        title: RootConfig.entities.metaDataDefinitionCategory.title,
+        formats: {
+            individual: `t("metaDataDefinitionCategory", { scope: "${i18n}" })`,
+            plural: `t("metaDataDefinitionCategories", { scope: "${i18n}" })`,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'section',
+                title: `t("metaDataDefinitionCategory", { scope: "common" })`,
+            },
+        ],
+        properties: [
+            {
+                name: 'title',
+                title: `t("title",{ scope:  "common" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                        options: {
+                            width: '400px',
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'parentId',
+                title: `t("parent",{ scope: "${i18n}" })`,
+                groupId: 'section',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.metaDataDefinitionCategory.name}`,
+                        },
+                    },
+                },
+            },
+        ],
+        columns: [{ name: 'title' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'parentId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'section',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'parentId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'section',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: `t("create", { scope: "common" })`,
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("detail", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 't("delete", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [createAllQueryView()],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+// Option 1: Class implementation
+// export class MetaDataDefinitionCategory implements AXMMetaDataDefinitionCategoryEntityModel {
+//   id?: string;
+//   title: string;
+//   parentId?: string;
+//   createdAt?: Date;
+//   updatedAt?: Date;
+//   createdBy?: string;
+//   updatedBy?: string;
+//   constructor(data: Omit<AXMMetaDataDefinitionCategoryEntityModel, 'x'>) {
+//     this.id = data.id;
+//     this.title = data.title;
+//     this.parentId = data.parentId;
+//     this.createdAt = data.createdAt;
+//     this.updatedAt = data.updatedAt;
+//     this.createdBy = data.createdBy;
+//     this.updatedBy = data.updatedBy;
+//   }
+//   // Getter for x property
+//   get x(): string {
+//     return this.parentId ? `${this.title}_${this.parentId}` : this.title;
+//   }
+// }
+// // Option 2: Factory function
+// export function createMetaDataDefinitionCategory(
+//   data: Omit<AXMMetaDataDefinitionCategoryEntityModel, 'x'>
+// ): AXMMetaDataDefinitionCategoryEntityModel {
+//   return {
+//     ...data,
+//     get x() {
+//       return this.parentId ? `${this.title}_${this.parentId}` : this.title;
+//     },
+//   };
+// }
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMAppTermService: AXMAppTermService,
+    AXMAppTermServiceImpl: AXMAppTermServiceImpl,
+    AXMAppVersionService: AXMAppVersionService,
+    AXMAppVersionServiceImpl: AXMAppVersionServiceImpl,
+    AXMAppVersionSlotComponent: AXMAppVersionSlotComponent,
+    AXMChangeLogPopupAction: AXMChangeLogPopupAction,
+    AXMChangeLogUpdateSettingAction: AXMChangeLogUpdateSettingAction,
+    AXMCheckNewVersionAction: AXMCheckNewVersionAction,
+    AXMCheckNewVersionWorkflow: AXMCheckNewVersionWorkflow,
+    AXMGlobalVariablesService: AXMGlobalVariablesService,
+    AXMGlobalVariablesServiceImpl: AXMGlobalVariablesServiceImpl,
+    AXMGlossaryService: AXMGlossaryService,
+    AXMGlossaryServiceImpl: AXMGlossaryServiceImpl,
+    AXMListTermsComponent: AXMListTermsComponent,
+    AXMMetaDataDefinitionCategoryService: AXMMetaDataDefinitionCategoryService,
+    AXMMetaDataDefinitionCategoryServiceImpl: AXMMetaDataDefinitionCategoryServiceImpl,
+    AXMMetaDataDefinitionService: AXMMetaDataDefinitionService,
+    AXMNewTermWorkflow: AXMNewTermWorkflow,
+    AXMNotifyAppComponent: AXMNotifyAppComponent,
+    AXMNotifyNewTermPopupAction: AXMNotifyNewTermPopupAction,
+    AXMPMetaDataDefinitionServiceImpl: AXMPMetaDataDefinitionServiceImpl,
+    AXMTermUpdateSettingAction: AXMTermUpdateSettingAction,
+    AXMWhatsNewWorkflow: AXMWhatsNewWorkflow,
+    appTermEntityEntityFactory: appTermEntityEntityFactory,
+    appVersionEntityEntityFactory: appVersionEntityEntityFactory,
+    globalVariableEntityFactory: globalVariableEntityFactory,
+    glossaryEntityFactory: glossaryEntityFactory,
+    metaDataDefinitionCategoryEntityFactory: metaDataDefinitionCategoryEntityFactory,
+    metaDataDefinitionFactory: metaDataDefinitionFactory
+});
+
+class AXMEntityLoader {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    preload() {
+        const module = RootConfig.module.name;
+        return Array.from(Object.values(RootConfig.entities)).map((entity) => ({
+            module: module,
+            entity: entity.name,
+        }));
+    }
+    async get(moduleName, entityName) {
+        if (moduleName == RootConfig.module.name) {
+            return new Promise(async (resolve) => {
+                switch (entityName) {
+                    case RootConfig.entities.glossary.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).glossaryEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    case RootConfig.entities.globalVariable.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).globalVariableEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    case RootConfig.entities.appVersion.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).appVersionEntityEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    case RootConfig.entities.appTerm.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).appTermEntityEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    case RootConfig.entities.metaDataDefinitionCategory.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).metaDataDefinitionCategoryEntityFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    case RootConfig.entities.metaDataDefinition.name: {
+                        const entity = (await Promise.resolve().then(function () { return index; })).metaDataDefinitionFactory;
+                        resolve(entity(this.injector));
+                        break;
+                    }
+                    default:
+                        resolve(null);
+                }
+            });
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMEntityLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMEntityLoader, decorators: [{
+            type: Injectable
+        }] });
+
+var AXPApplicationTermsSettings;
+(function (AXPApplicationTermsSettings) {
+    AXPApplicationTermsSettings["ApplicationTerms"] = "general:startup:application-terms";
+})(AXPApplicationTermsSettings || (AXPApplicationTermsSettings = {}));
+
+class AppTermsCheckService {
+    constructor() {
+        this.settingsService = inject(AXPSettingService);
+        this.workflowService = inject(AXPWorkflowService);
+        this.appTermService = inject(AXMAppTermService);
+        this.appInitService = inject(AXPAppStartUpService);
+        this.sessionService = inject(AXPSessionService);
+        this.appInitService.registerTask({
+            name: 'Terms',
+            statusText: 'Check New Terms And Conditions...',
+            priority: 6,
+            run: async () => {
+                this.sessionService.application$.subscribe(async (app) => {
+                    if (app != null) {
+                        const filterTerms = [];
+                        const terms = await this.appTermService.query();
+                        for (const term of terms.items) {
+                            const isConfirm = await this.settingsService
+                                .scope(AXPPlatformScope.User)
+                                .get(`is-confirm-term-${term.id}`);
+                            const isEnableToShow = await this.settingsService
+                                .scope(AXPPlatformScope.User)
+                                .get(AXPApplicationTermsSettings.ApplicationTerms);
+                            if (!isConfirm && isEnableToShow) {
+                                filterTerms.push(term);
+                            }
+                        }
+                        if (filterTerms.length > 0) {
+                            setTimeout(() => {
+                                this.workflowService.execute('new-term', filterTerms);
+                            }, 500);
+                        }
+                    }
+                });
+            },
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AppTermsCheckService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AppTermsCheckService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AppTermsCheckService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class AXMShowReleaseNotesPopupAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+    }
+    async execute(context) {
+        const scope = RootConfig.config.i18n;
+        const comp = (await import('./acorex-modules-platform-management-list-version.component-BOfUQDwo.mjs')).AXMListVersionComponent;
+        this.popupService.open(comp, {
+            title: `t('release-notes',{scope: "${scope}"})`,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMShowReleaseNotesPopupAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMShowReleaseNotesPopupAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMShowReleaseNotesPopupAction, decorators: [{
+            type: Injectable
+        }] });
+const AXMShowReleaseNotesWorkflow = {
+    startStepId: 'show-popup',
+    steps: {
+        'show-popup': {
+            action: 'AXMShowReleaseNotesPopupAction',
+        },
+    },
+};
+
+var AXPReleaseNotesSettings;
+(function (AXPReleaseNotesSettings) {
+    AXPReleaseNotesSettings["ReleaseNotes"] = "general:startup:release-notes";
+})(AXPReleaseNotesSettings || (AXPReleaseNotesSettings = {}));
+
+class AXPReleaseNotesSettingProvider {
+    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;
+        }
+        // Find the 'Startup' section
+        const section = group.section('startup');
+        if (!section) {
+            return;
+        }
+        // Add the 'Release Notes' setting
+        section.addSetting({
+            key: AXPReleaseNotesSettings.ReleaseNotes,
+            title: await trans('general.startup.release-notes.title'),
+            scope: AXPPlatformScope.User,
+            isInherited: true,
+            defaultValue: false,
+            valueTransforms: objectKeyValueTransforms('id'),
+            widget: {
+                type: AXPWidgetsCatalog.toggle,
+                options: {
+                    label: null,
+                }
+            },
+            description: await trans('general.startup.release-notes.description'),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXPReleaseNotesSettingProvider, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXPReleaseNotesSettingProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXPReleaseNotesSettingProvider, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+
+class AXPUpdaterService {
+    constructor() {
+        const swUpdate = inject(SwUpdate, { optional: true });
+        const dialogService = inject(AXDialogService);
+        const translateService = inject(AXTranslationService);
+        if (swUpdate?.isEnabled) {
+            swUpdate.versionUpdates.subscribe((event) => {
+                if (event.type === 'VERSION_READY') {
+                    console.log('New version available');
+                    const scope = RootConfig.config.i18n;
+                    const dialog = dialogService.open({
+                        icon: 'fa-regular fa-info',
+                        content: translateService.translateSync('updater.content', { scope: scope }),
+                        title: translateService.translateSync('updater.title', { scope: scope }),
+                        type: 'primary',
+                        orientation: 'horizontal',
+                        buttons: [
+                            {
+                                text: translateService.translateSync('updater.update', { scope: scope }),
+                                color: 'primary',
+                                onClick: async (e) => {
+                                    try {
+                                        document.location.reload();
+                                        dialog.close();
+                                    }
+                                    catch (error) {
+                                        console.error(error);
+                                    }
+                                },
+                            },
+                            {
+                                text: translateService.translateSync('updater.cancel', { scope: scope }),
+                                color: 'default',
+                                autofocus: true,
+                                onClick: (e) => {
+                                    dialog.close();
+                                },
+                            },
+                        ],
+                        closeButton: false,
+                    });
+                }
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXPUpdaterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXPUpdaterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXPUpdaterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+
+class AXMUpdaterModule {
+    constructor(updaterService) {
+        this.updaterService = updaterService;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMUpdaterModule, deps: [{ token: AXPUpdaterService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.3", ngImport: i0, type: AXMUpdaterModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMUpdaterModule, providers: [AXPUpdaterService] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMUpdaterModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [AXPUpdaterService],
+                }]
+        }], ctorParameters: () => [{ type: AXPUpdaterService }] });
+
+class AXMMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+        this.sessionService = inject(AXPSessionService);
+    }
+    async provide(context) {
+        const scope = RootConfig.config.i18n;
+        const appName = this.sessionService.application?.name;
+        const module = RootConfig.module;
+        //
+        context.addItems([
+            {
+                name: 'app-help',
+                text: `t('help',{scope: "${scope}"})`,
+                icon: 'fa-light  fa-circle-question',
+                priority: 100000,
+                data: {
+                    requiredPermission: 'platform',
+                },
+                children: [
+                    {
+                        name: 'app-help-center',
+                        text: `t('help-center',{scope: "${scope}"})`,
+                        icon: 'fa-light fa-book-open',
+                        priority: 100001,
+                    },
+                    {
+                        name: 'app-help-tutorials',
+                        text: `t('tutorials',{scope: "${scope}"})`,
+                        icon: 'fa-light fa-clapperboard-play',
+                        priority: 100002,
+                    },
+                    {
+                        name: 'app-release-notes',
+                        text: `t('release-notes',{scope: "${scope}"})`,
+                        icon: 'fa-light fa-memo-pad',
+                        command: {
+                            name: 'show-release-notes',
+                        },
+                        priority: 100003,
+                    },
+                    {
+                        text: 'break',
+                        type: 'break',
+                        priority: 100004,
+                    },
+                    {
+                        name: 'app-terms',
+                        text: `t('terms-conditions',{scope: "${scope}"})`,
+                        icon: 'fa-light fa-circle-info',
+                        path: `${appName}/terms`,
+                        priority: 100031,
+                    },
+                    {
+                        name: 'app-about',
+                        text: `t('about',{scope: "${scope}"})`,
+                        icon: 'fa-light fa-circle-info',
+                        priority: 100032,
+                    },
+                    {
+                        text: 'break',
+                        type: 'break',
+                        priority: 100030,
+                    },
+                ],
+            },
+        ]);
+        //
+        const isAuthorized = await firstValueFrom(this.sessionService.isAuthorized$);
+        if (!isAuthorized) {
+            return;
+        }
+        //
+        context.addItems([
+            {
+                name: 'administration-group',
+                priority: 2000,
+                text: `t('administration',{scope: "${scope}"})`,
+                type: 'group',
+                data: {
+                // requiredPermission: 'admin',
+                },
+            },
+            {
+                text: `t('root-menu', {scope: "${scope}"})`,
+                icon: 'fa-light fa-square-terminal',
+                type: 'menu',
+                name: 'platform-management',
+                priority: 9100,
+                data: {
+                    requiredPermission: 'platform',
+                },
+                children: [
+                    {
+                        priority: 9001,
+                        text: RootConfig.entities.globalVariable.title,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.globalVariable.name),
+                        icon: RootConfig.entities.globalVariable.icon,
+                        data: {
+                        // requiredPermission: '',
+                        },
+                    },
+                    {
+                        priority: 9002,
+                        text: RootConfig.entities.glossary.title,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.glossary.name),
+                        icon: RootConfig.entities.glossary.icon,
+                    },
+                    {
+                        priority: 9003,
+                        text: RootConfig.entities.appVersion.title,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.appVersion.name),
+                        icon: RootConfig.entities.appVersion.icon,
+                        data: {
+                        // requiredPermission: '',
+                        },
+                    },
+                    {
+                        priority: 9004,
+                        text: RootConfig.entities.appTerm.title,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.appTerm.name),
+                        icon: RootConfig.entities.appTerm.icon,
+                        data: {
+                        // requiredPermission: '',
+                        },
+                    },
+                    {
+                        priority: 9008,
+                        text: RootConfig.entities.metaDataDefinition.title,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.metaDataDefinition.name),
+                        icon: RootConfig.entities.metaDataDefinition.icon,
+                        data: {
+                        // requiredPermission: '',
+                        },
+                    },
+                    {
+                        priority: 9007,
+                        text: RootConfig.entities.metaDataDefinitionCategory.title,
+                        path: this.entityService.createPath(RootConfig.module.name, RootConfig.entities.metaDataDefinitionCategory.name),
+                        icon: RootConfig.entities.metaDataDefinitionCategory.icon,
+                    },
+                ],
+            },
+        ]);
+    }
+}
+
+class AXPTaskBoardTaskProvider extends AXPWorkflowTaskProvider {
+    constructor() {
+        super(...arguments);
+        this.calendarService = inject(AXCalendarService);
+        this.list = [
+            {
+                id: 3,
+                title: 'Deploy new security patch',
+                startDate: this.calendarService.create(new Date()).add('day', 2).date,
+                endDate: this.calendarService.create(new Date()).add('day', 3).date,
+                description: 'Apply critical security patch to all production servers.',
+                priority: 'highest',
+                allDay: true,
+                statusKey: 'todo',
+                data: {
+                    actions: [
+                        {
+                            name: 'edit',
+                            title: 'Edit',
+                            icon: 'fa-light fa-pencil',
+                            command: { name: 'edit', options: { taskId: 3 } },
+                        },
+                    ],
+                },
+            },
+            {
+                id: 4,
+                title: 'Monitor server performance',
+                startDate: this.calendarService.create(new Date()).set('hour', 9).date,
+                endDate: this.calendarService.create(new Date()).set('hour', 10).add('minute', -30).date,
+                description: 'Live monitoring of server load during peak hours.',
+                priority: 'high',
+                allDay: false,
+                statusKey: 'todo',
+                data: {
+                    actions: [
+                        {
+                            name: 'edit',
+                            title: 'Edit',
+                            icon: 'fa-light fa-pencil',
+                            command: { name: 'edit', options: { taskId: 4 } },
+                        },
+                        {
+                            name: 'view-logs',
+                            title: 'View Logs',
+                            icon: 'fa-light fa-file-waveform',
+                            command: { name: 'viewLogs', options: { taskId: 4 } },
+                        },
+                    ],
+                },
+            },
+            {
+                id: 5,
+                title: 'Weekly database backup',
+                startDate: this.calendarService.create(new Date()).set('hour', 2).date,
+                endDate: this.calendarService.create(new Date()).set('hour', 4).date,
+                description: 'Perform full backup of the main database. System will be in maintenance mode.',
+                priority: 'medium',
+                allDay: false,
+                statusKey: 'in-progress',
+                readonly: true,
+                data: {
+                    actions: [
+                        {
+                            name: 'view-status',
+                            title: 'View Status',
+                            icon: 'fa-light fa-circle-info',
+                            command: { name: 'viewStatus', options: { taskId: 5 } },
+                        },
+                    ],
+                },
+            },
+            {
+                id: 6,
+                title: 'Review user feedback logs',
+                startDate: this.calendarService.create(new Date()).add('day', 1).date,
+                endDate: this.calendarService.create(new Date()).add('day', 3).date,
+                description: 'Analyze logs from the past month to identify common issues.',
+                priority: 'low',
+                allDay: true,
+                statusKey: 'done',
+                data: {
+                    actions: [
+                        {
+                            name: 'edit',
+                            title: 'Edit',
+                            icon: 'fa-light fa-pencil',
+                            command: { name: 'edit', options: { taskId: 6 } },
+                        },
+                    ],
+                },
+            },
+            {
+                id: 7,
+                title: 'Renew SSL Certificates',
+                startDate: this.calendarService.create(new Date()).add('day', 10).date,
+                endDate: this.calendarService.create(new Date()).add('day', 11).date,
+                description: 'Renew expiring SSL certificates for *.acorex.com.',
+                priority: 'high',
+                allDay: true,
+                statusKey: 'done',
+                data: {
+                    actions: [
+                        {
+                            name: 'edit',
+                            title: 'Edit',
+                            icon: 'fa-light fa-pencil',
+                            command: { name: 'edit', options: { taskId: 7 } },
+                        },
+                    ],
+                },
+            },
+        ];
+    }
+    get name() {
+        return 'platform-tasks';
+    }
+    get title() {
+        return 'Platform Tasks';
+    }
+    get icon() {
+        return 'fa-square-terminal';
+    }
+    get statuses() {
+        return [
+            {
+                index: 0,
+                key: 'todo',
+                title: 'To Do',
+            },
+            {
+                index: 1,
+                key: 'in-progress',
+                title: 'In Progress',
+            },
+            {
+                index: 2,
+                key: 'done',
+                title: 'Done',
+            },
+        ];
+    }
+    async getTasks(options) {
+        return this.list;
+    }
+    async updateTaskDateRange(id, range) {
+        const item = this.list.find((t) => t.id === id);
+        if (!item) {
+            throw new Error('Item not found');
+        }
+        item.startDate = range.from;
+        item.endDate = range.end;
+        if (this.isDurationMoreThan24Hours(item.startDate, item.endDate)) {
+            item.allDay = true;
+        }
+        else {
+            item.allDay = false;
+        }
+        this.list = this.list.map((t) => (t.id === id ? item : t));
+        return item;
+    }
+    async updateMultipleTasks(tasks) {
+        this.list = tasks;
+        return this.list;
+    }
+    isDurationMoreThan24Hours(date1, date2) {
+        const millisecondsIn24Hours = 24 * 60 * 60 * 1000 - 1;
+        const differenceInMilliseconds = Math.abs(date1.getTime() - date2.getTime());
+        return differenceInMilliseconds >= millisecondsIn24Hours;
+    }
+    async executeCommand(command) {
+        return {
+            success: true,
+        };
+    }
+}
+
+/**
+ * Global variable that returns current ISO date-time string.
+ */
+class AXMGlobalVariableProvider {
+    constructor() {
+        this.name = 'now';
+        this.title = 'Now';
+        this.description = 'Current date and time in ISO format';
+    }
+    execute() {
+        return Promise.resolve(new Date().toISOString());
+    }
+}
+
+function routesFactory() {
+    const config = inject(AXP_ENTITY_CONFIG_TOKEN);
+    const routes = [
+        {
+            path: ':app/terms',
+            loadComponent: () => {
+                return config.viewers.root();
+            },
+            children: [
+                {
+                    path: '',
+                    loadComponent: () => Promise.resolve().then(function () { return listTerms_component; }).then((c) => c.AXMListTermsComponent),
+                },
+            ],
+        },
+    ];
+    return routes;
+}
+class AXMPlatformManagementModule {
+    /**
+     * @ignore
+     */
+    constructor(appVersionCheck, appTermsCheck) { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMPlatformManagementModule, deps: [{ token: AppVersionCheckService }, { token: AppTermsCheckService }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.1.3", ngImport: i0, type: AXMPlatformManagementModule, imports: [AXMUpdaterModule, i3$2.AXPWorkflowModule, i4$1.AXPComponentSlotModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMPlatformManagementModule, providers: [
+            {
+                provide: AXMGlossaryService,
+                useClass: AXMGlossaryServiceImpl,
+            },
+            {
+                provide: ROUTES,
+                multi: true,
+                useFactory: routesFactory,
+            },
+            {
+                provide: AXMGlobalVariablesService,
+                useClass: AXMGlobalVariablesServiceImpl,
+            },
+            {
+                provide: AXMAppVersionService,
+                useClass: AXMAppVersionServiceImpl,
+            },
+            {
+                provide: AXMAppTermService,
+                useClass: AXMAppTermServiceImpl,
+            },
+            {
+                provide: AXMMetaDataDefinitionService,
+                useClass: AXMPMetaDataDefinitionServiceImpl,
+            },
+            {
+                provide: AXMMetaDataDefinitionCategoryService,
+                useClass: AXMMetaDataDefinitionCategoryServiceImpl,
+            },
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMEntityLoader,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMMenuProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_SETTING_DEFINITION_PROVIDER,
+                useClass: AXPReleaseNotesSettingProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_WORKFLOW_TASK_PROVIDER,
+                useClass: AXPTaskBoardTaskProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER,
+                useClass: AXMGlobalVariableProvider,
+                multi: true,
+            },
+            AppVersionCheckService,
+            AppTermsCheckService,
+        ], imports: [AXMUpdaterModule,
+            AXPWorkflowModule.forChild({
+                actions: {
+                    AXMChangeLogPopupAction,
+                    AXMChangeLogUpdateSettingAction,
+                    //
+                    AXMNotifyNewTermPopupAction,
+                    AXMTermUpdateSettingAction,
+                    //
+                    AXMShowReleaseNotesPopupAction,
+                    AXMCheckNewVersionAction,
+                },
+                workflows: {
+                    'show-what-is-new': AXMWhatsNewWorkflow,
+                    'show-release-notes': AXMShowReleaseNotesWorkflow,
+                    'new-term': AXMNewTermWorkflow,
+                    'check-new-version': AXMCheckNewVersionWorkflow,
+                },
+            }),
+            AXPComponentSlotModule.forChild({
+                'side-menu-footer': [
+                // {
+                //   name: 'side-menu-footer',
+                //   component: AXMPromotionSlotComponent,
+                //   options: {
+                //     location: 'side-menu-footer',
+                //   },
+                // },
+                ],
+                'side-menu-header': [
+                // {
+                //   name: 'side-menu-header',
+                //   component: AXMPromotionSlotComponent,
+                //   priority: 2,
+                //   options: {
+                //     location: 'side-menu-header',
+                //   },
+                // },
+                ],
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.3", ngImport: i0, type: AXMPlatformManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXMUpdaterModule,
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                AXMChangeLogPopupAction,
+                                AXMChangeLogUpdateSettingAction,
+                                //
+                                AXMNotifyNewTermPopupAction,
+                                AXMTermUpdateSettingAction,
+                                //
+                                AXMShowReleaseNotesPopupAction,
+                                AXMCheckNewVersionAction,
+                            },
+                            workflows: {
+                                'show-what-is-new': AXMWhatsNewWorkflow,
+                                'show-release-notes': AXMShowReleaseNotesWorkflow,
+                                'new-term': AXMNewTermWorkflow,
+                                'check-new-version': AXMCheckNewVersionWorkflow,
+                            },
+                        }),
+                        AXPComponentSlotModule.forChild({
+                            'side-menu-footer': [
+                            // {
+                            //   name: 'side-menu-footer',
+                            //   component: AXMPromotionSlotComponent,
+                            //   options: {
+                            //     location: 'side-menu-footer',
+                            //   },
+                            // },
+                            ],
+                            'side-menu-header': [
+                            // {
+                            //   name: 'side-menu-header',
+                            //   component: AXMPromotionSlotComponent,
+                            //   priority: 2,
+                            //   options: {
+                            //     location: 'side-menu-header',
+                            //   },
+                            // },
+                            ],
+                        }),
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMGlossaryService,
+                            useClass: AXMGlossaryServiceImpl,
+                        },
+                        {
+                            provide: ROUTES,
+                            multi: true,
+                            useFactory: routesFactory,
+                        },
+                        {
+                            provide: AXMGlobalVariablesService,
+                            useClass: AXMGlobalVariablesServiceImpl,
+                        },
+                        {
+                            provide: AXMAppVersionService,
+                            useClass: AXMAppVersionServiceImpl,
+                        },
+                        {
+                            provide: AXMAppTermService,
+                            useClass: AXMAppTermServiceImpl,
+                        },
+                        {
+                            provide: AXMMetaDataDefinitionService,
+                            useClass: AXMPMetaDataDefinitionServiceImpl,
+                        },
+                        {
+                            provide: AXMMetaDataDefinitionCategoryService,
+                            useClass: AXMMetaDataDefinitionCategoryServiceImpl,
+                        },
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMEntityLoader,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMMenuProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_SETTING_DEFINITION_PROVIDER,
+                            useClass: AXPReleaseNotesSettingProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_WORKFLOW_TASK_PROVIDER,
+                            useClass: AXPTaskBoardTaskProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_GLOBAL_VARIABLE_DEFINITION_PROVIDER,
+                            useClass: AXMGlobalVariableProvider,
+                            multi: true,
+                        },
+                        AppVersionCheckService,
+                        AppTermsCheckService,
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: AppVersionCheckService }, { type: AppTermsCheckService }] });
+
+// export * from './lib/features';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMAppTermService, AXMAppTermServiceImpl, AXMAppVersionService, AXMAppVersionServiceImpl, AXMAppVersionSlotComponent, AXMChangeLogPopupAction, AXMChangeLogUpdateSettingAction, AXMCheckNewVersionAction, AXMCheckNewVersionWorkflow, AXMGlobalVariablesService, AXMGlobalVariablesServiceImpl, AXMGlossaryService, AXMGlossaryServiceImpl, AXMListTermsComponent, AXMMetaDataDefinitionCategoryService, AXMMetaDataDefinitionCategoryServiceImpl, AXMMetaDataDefinitionService, AXMNewTermWorkflow, AXMNotifyAppComponent, AXMNotifyNewTermPopupAction, AXMPMetaDataDefinitionServiceImpl, AXMPlatformManagementModule, AXMTermUpdateSettingAction, AXMWhatsNewWorkflow, RootConfig, appTermEntityEntityFactory, appVersionEntityEntityFactory, globalVariableEntityFactory, glossaryEntityFactory, metaDataDefinitionCategoryEntityFactory, metaDataDefinitionFactory };
 //# sourceMappingURL=acorex-modules-platform-management.mjs.map