@acorex/modules 18.2.0 → 18.2.2

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

@@ -1,35 +1,1043 @@
-import { AXMEntityCrudServiceImpl, AXPEntityDataProviderImpl, AXPDataGenerator, AXPEntityQueryType, AXPEntityCommandScope, AXP_MENU_PROVIDER } from '@acorex/platform/common';
+import { AXMEntityCrudServiceImpl, AXPEntityCommandScope, AXPEntityQueryType, AXPDataGenerator, AXP_MENU_PROVIDER } from '@acorex/platform/common';
+import { AXP_ENTITY_DEFINITION_LOADER, AXPEntityService } from '@acorex/platform/layout/entity';
 import * as i0 from '@angular/core';
 import { Injectable, inject, Injector, NgModule } from '@angular/core';
-import { AXMCommentService } from '@acorex/modules/conversation';
-import { AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
-import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
-import { AXTranslationService } from '@acorex/core/translation';
+import { AXPWidgetsCatalog, AXP_WIDGET_DATASOURCE_PROVIDER } from '@acorex/platform/layout/builder';
+import { AXDataSource } from '@acorex/components/common';
 
-class AXPCommentServiceImpl extends AXMEntityCrudServiceImpl {
+const CURRENCY_SOURCE_NAME = 'common.currency';
+const COUNTRY_SOURCE_NAME = 'common.country';
+const PROVINCE_SOURCE_NAME = 'common.province';
+const CITY_SOURCE_NAME = 'common.city';
+
+class AXMCountryService extends AXMEntityCrudServiceImpl {
+}
+class AXMCountryServiceImpl extends AXMCountryService {
+    constructor() {
+        super(COUNTRY_SOURCE_NAME);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCountryServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCountryServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCountryServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function countryEntityFactory(injector) {
+    const dataService = injector.get(AXMCountryService);
+    const entityDef = {
+        module: 'localization-management',
+        name: 'country',
+        source: 'localizationManagement.country',
+        title: 'Country',
+        formats: {
+            individual: 'Country',
+            plural: 'Countries',
+        },
+        relatedEntities: [
+            {
+                entity: 'common.province',
+                title: 't("provinces", { scope: "common" })',
+                columns: ['title'],
+                conditions: [
+                    {
+                        name: 'countryId',
+                        operator: {
+                            type: 'equal',
+                        },
+                        value: '${id}',
+                    },
+                ],
+            },
+        ],
+        groups: [
+            {
+                id: 'country',
+                title: 'Country',
+            },
+            {
+                id: 'extra',
+                title: 'Global',
+            },
+            {
+                id: 'geo',
+                title: 'Geo',
+            },
+        ],
+        properties: [
+            {
+                name: 'title',
+                title: 'Title',
+                groupId: 'country',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'iso3',
+                title: 'ISO3 Code',
+                groupId: 'country',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'iso2',
+                title: 'ISO2 Code',
+                groupId: 'country',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'numericCode',
+                title: 'Numeric Code',
+                groupId: 'country',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'nativeName',
+                title: 'Native Name',
+                groupId: 'geo',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'region',
+                title: 'Region',
+                groupId: 'geo',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'subregion',
+                title: 'SubRegion',
+                groupId: 'geo',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'nationality',
+                title: 'Nationality',
+                groupId: 'geo',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'geo.latitude',
+                title: 'Latitude',
+                groupId: 'geo',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'geo.longitude',
+                title: 'Longitude',
+                groupId: 'geo',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'capital',
+                title: 'Capital',
+                groupId: 'extra',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'tld',
+                title: 'Top Level Domain',
+                groupId: 'extra',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'title' }, { name: 'iso2' }, { name: 'nativeName' }, { name: 'region' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    return Promise.resolve({ id: await dataService.insertOne(data) });
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    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) => {
+                    return dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'country',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'nativeName',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'iso3',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'iso2',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'numericCode',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'region',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'subregion',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'Nationality',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'geo.latitude',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'geo.longitude',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'capital',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'tld',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'country',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'nativeName',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'iso3',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'iso2',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'numericCode',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'region',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'subregion',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'nationality',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'geo.latitude',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'geo.longitude',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'capital',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'tld',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'country',
+                        },
+                        {
+                            id: 'extra',
+                        },
+                        {
+                            id: 'geo',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'iso2',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'iso3',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'numericCode',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'nativeName',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'nationality',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'region',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'subRegion',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'geo.latitude',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    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: [
+                        {
+                            name: 'all',
+                            title: 'All Items',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var country_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    countryEntityFactory: countryEntityFactory
+});
+
+class AXMCurrencyService extends AXMEntityCrudServiceImpl {
+}
+class AXMCurrencyServiceImpl extends AXMCurrencyService {
     constructor() {
-        super('comments');
-        this.messageReactionDataProvider = new AXPEntityDataProviderImpl(super.storageService, 'messageReaction');
+        super(CURRENCY_SOURCE_NAME);
     }
-    async like(payload) {
-        return this.messageReactionDataProvider.insertOne(payload);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommentServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommentServiceImpl }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCurrencyServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCurrencyServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCurrencyServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+async function currencyEntityFactory(injector) {
+    const dataService = injector.get(AXMCurrencyService);
+    const entityDef = {
+        module: 'localization-management',
+        name: 'currency',
+        source: 'localizationManagement.currency',
+        title: 'Currency',
+        formats: {
+            individual: 'Currency',
+            plural: 'Currencies',
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'currency',
+                title: 'Currency',
+            },
+        ],
+        properties: [
+            {
+                name: 'title',
+                title: 'Title',
+                groupId: 'currency',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'code',
+                title: 'Code',
+                groupId: 'currency',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'symbol',
+                title: 'Symbol',
+                groupId: 'currency',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+        ],
+        columns: [{ name: 'title' }, { name: 'code' }, { name: 'symbol' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    return Promise.resolve({ id: await dataService.insertOne(data) });
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    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) => {
+                    return dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'currency',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'code',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'symbol',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'currency',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'code',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'symbol',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'currency',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'code',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'symbol',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    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: [
+                        {
+                            name: 'all',
+                            title: 'All Items',
+                            fixed: true,
+                            columns: [],
+                            conditions: [],
+                            sorts: [],
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXPCommentServiceImpl, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
 
-class AXMGlobalVariableModuleEntityLoader {
+var currency_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    currencyEntityFactory: currencyEntityFactory
+});
+
+class AXMCommonModuleEntityLoader {
     constructor() {
         this.injector = inject(Injector);
     }
     async get(moduleName, entityName) {
         return new Promise(async (resolve) => {
             switch (entityName) {
-                case 'globalVariable': {
-                    const entity = (await Promise.resolve().then(function () { return globalVariable_entity; })).globalVariableEntityFactory;
+                case 'country': {
+                    const entity = (await Promise.resolve().then(function () { return country_entity; })).countryEntityFactory;
+                    resolve(entity(this.injector));
+                    break;
+                }
+                case 'province': {
+                    const entity = (await Promise.resolve().then(function () { return province_entity; })).provinceEntityFactory;
+                    resolve(entity(this.injector));
+                    break;
+                }
+                case 'currency': {
+                    const entity = (await Promise.resolve().then(function () { return currency_entity; })).currencyEntityFactory;
                     resolve(entity(this.injector));
                     break;
                 }
@@ -38,62 +1046,75 @@ class AXMGlobalVariableModuleEntityLoader {
             }
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariableModuleEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariableModuleEntityLoader }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCommonModuleEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCommonModuleEntityLoader }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariableModuleEntityLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMCommonModuleEntityLoader, decorators: [{
             type: Injectable
         }] });
 
-class AXMGlobalVariablesService extends AXMEntityCrudServiceImpl {
-}
-class AXMGlobalVariablesServiceImpl extends AXMEntityCrudServiceImpl {
+class AXPPlatformCountryWidgetDataSourceProvider {
     constructor() {
-        super('globalVariable');
+        this.service = inject(AXMCountryService);
+    }
+    async items() {
+        return [
+            {
+                name: 'platform.countrues',
+                title: 'Countries',
+                columns: [],
+                source: () => new AXDataSource({
+                    pageSize: 10,
+                    load: (e) => {
+                        return this.service.query({ skip: e.skip, take: e.take });
+                    },
+                    byKey: (id) => {
+                        return this.service.getOne(id);
+                    },
+                }),
+            },
+        ];
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariablesServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariablesServiceImpl }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariablesServiceImpl, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
 
-class AXMLanguageService extends AXMEntityCrudServiceImpl {
+class AXMProvinceService extends AXMEntityCrudServiceImpl {
 }
-class AXMLanguageServiceImpl extends AXMEntityCrudServiceImpl {
+class AXMProvinceServiceImpl extends AXMProvinceService {
     constructor() {
-        super('language');
+        super(PROVINCE_SOURCE_NAME);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLanguageServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLanguageServiceImpl }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMProvinceServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMProvinceServiceImpl }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLanguageServiceImpl, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMProvinceServiceImpl, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
 
-async function languageEntityFactory(injector) {
-    const dataService = injector.get(AXMLanguageService);
+async function provinceEntityFactory(injector) {
+    const dataService = injector.get(AXMProvinceService);
+    const moduleName = 'common';
+    const scope = `#${moduleName}`;
     const entityDef = {
-        module: 'common',
-        name: 'language',
-        source: 'common.language',
-        title: 'Language',
+        module: moduleName,
+        name: 'province',
+        source: 'common.province',
+        title: `${scope}.province`,
         formats: {
-            individual: 'Language',
-            plural: 'Languages',
+            individual: `${scope}.province`,
+            plural: `${scope}.provinces`,
         },
         relatedEntities: [],
         groups: [
             {
-                id: 'language',
-                title: 'Language',
+                id: 'province',
+                title: `${scope}.province`,
             },
         ],
         properties: [
             {
                 name: 'title',
-                title: 'Title',
-                groupId: 'language',
+                title: 't("title", { scope: "common" })',
+                groupId: 'province',
                 schema: {
                     dataType: 'string',
                     interface: {
@@ -107,29 +1128,69 @@ async function languageEntityFactory(injector) {
                 ],
             },
             {
-                name: 'code',
-                title: 'Code',
-                groupId: 'language',
+                name: 'name',
+                title: 't("name", { scope: "common" })',
+                groupId: 'province',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'country.id',
+                title: `${scope}.country`,
+                groupId: 'province',
                 schema: {
                     dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: 'common.country',
+                            expose: 'country',
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'country.title',
+                title: `${scope}.country`,
+                groupId: 'province',
+                schema: {
+                    dataType: 'string',
+                    readonly: true,
                     interface: {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                },
             },
         ],
-        columns: [{ name: 'title' }, { name: 'code' }],
+        columns: [{ name: 'name' }, { name: 'title' }, { name: 'country.title' }],
         commands: {
             create: {
                 execute: async (data) => {
-                    const entity = Object.assign(data, { id: AXPDataGenerator.uuid() });
-                    dataService.insertOne(entity);
-                    return Promise.resolve(entity);
+                    return Promise.resolve({ id: await dataService.insertOne(data) });
                 },
             },
             delete: {
                 execute: async (id) => {
-                    await await dataService.deleteOne(id);
+                    await dataService.deleteOne(id);
                     return Promise.resolve();
                 },
             },
@@ -158,7 +1219,8 @@ async function languageEntityFactory(injector) {
             },
             list: {
                 execute: async (e) => {
-                    return dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                    let x = await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                    return Promise.resolve(x);
                 },
                 type: AXPEntityQueryType.List,
             },
@@ -168,10 +1230,20 @@ async function languageEntityFactory(injector) {
                 create: {
                     sections: [
                         {
-                            id: 'language',
+                            id: 'province',
                         },
                     ],
                     properties: [
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
                         {
                             name: 'title',
                             layout: {
@@ -183,7 +1255,26 @@ async function languageEntityFactory(injector) {
                             },
                         },
                         {
-                            name: 'code',
+                            name: 'country.id',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'province',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'name',
                             layout: {
                                 positions: {
                                     lg: {
@@ -192,15 +1283,6 @@ async function languageEntityFactory(injector) {
                                 },
                             },
                         },
-                    ],
-                },
-                update: {
-                    sections: [
-                        {
-                            id: 'language',
-                        },
-                    ],
-                    properties: [
                         {
                             name: 'title',
                             layout: {
@@ -212,11 +1294,11 @@ async function languageEntityFactory(injector) {
                             },
                         },
                         {
-                            name: 'code',
+                            name: 'country.id',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                     },
                                 },
                             },
@@ -227,12 +1309,12 @@ async function languageEntityFactory(injector) {
                     title: '{{title}}',
                     sections: [
                         {
-                            id: 'language',
+                            id: 'province',
                         },
                     ],
                     properties: [
                         {
-                            name: 'title',
+                            name: 'name',
                             layout: {
                                 positions: {
                                     lg: {
@@ -242,7 +1324,7 @@ async function languageEntityFactory(injector) {
                             },
                         },
                         {
-                            name: 'code',
+                            name: 'title',
                             layout: {
                                 positions: {
                                     lg: {
@@ -251,34 +1333,44 @@ async function languageEntityFactory(injector) {
                                 },
                             },
                         },
+                        {
+                            name: 'country.name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
                     ],
                     actions: [],
                 },
                 list: {
                     actions: [
                         {
-                            title: 'Create New',
+                            title: 't("create", { scope: "common" })',
                             command: 'create-entity',
                             priority: 'primary',
                             type: 'create',
                             scope: AXPEntityCommandScope.TypeLevel,
                         },
                         {
-                            title: 'Delete Items',
+                            title: 't("deleteItems", { scope: "common" })',
                             command: 'delete-entity',
                             priority: 'primary',
                             type: 'delete',
                             scope: AXPEntityCommandScope.Selected,
                         },
                         {
-                            title: 'Details',
+                            title: 't("detail", { scope: "common" })',
                             command: 'open-entity',
                             priority: 'secondary',
                             type: 'view',
                             scope: AXPEntityCommandScope.Individual,
                         },
                         {
-                            title: 'Delete',
+                            title: 't("delete", { scope: "common" })',
                             command: 'delete-entity',
                             priority: 'secondary',
                             type: 'delete',
@@ -288,7 +1380,7 @@ async function languageEntityFactory(injector) {
                     views: [
                         {
                             name: 'all',
-                            title: 'All Items',
+                            title: 't("allItem", { scope: "common" })',
                             fixed: true,
                             columns: [],
                             conditions: [],
@@ -302,162 +1394,99 @@ async function languageEntityFactory(injector) {
     return entityDef;
 }
 
-var language_entity = /*#__PURE__*/Object.freeze({
+var province_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    languageEntityFactory: languageEntityFactory
+    provinceEntityFactory: provinceEntityFactory
 });
 
-class AXMLanguageModuleEntityLoader {
-    constructor() {
-        this.injector = inject(Injector);
-    }
-    async get(moduleName, entityName) {
-        return new Promise(async (resolve) => {
-            switch (entityName) {
-                case 'language': {
-                    const entity = (await Promise.resolve().then(function () { return language_entity; })).languageEntityFactory;
-                    resolve(entity(this.injector));
-                    break;
-                }
-                default:
-                    resolve(null);
-            }
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLanguageModuleEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLanguageModuleEntityLoader }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMLanguageModuleEntityLoader, decorators: [{
-            type: Injectable
-        }] });
-
-class AXMPlatformManagmentModuleMenuProvider {
-    constructor() {
-        this.translateService = inject(AXTranslationService);
-    }
-    async items() {
-        const scope = "platform"; // The scope used for translation lookup
-        return [
-            {
-                items: [
-                    {
-                        text: await this.translateService.translateAsync('platformManagement', { scope }),
-                        icon: 'fa-solid fa-square-terminal',
-                        type: 'menu',
-                        priority: 9100,
-                        data: {
-                        // requiredPermission: 'demo.admin.settings',
-                        },
-                        children: [
-                            {
-                                priority: 9001,
-                                text: await this.translateService.translateAsync('globalVariables', { scope }),
-                                path: '/demo/m/common/e/globalVariable/list',
-                                icon: 'fa-solid fa-object-exclude',
-                                data: {
-                                // requiredPermission: '',
-                                },
-                            },
-                            {
-                                priority: 9002,
-                                text: await this.translateService.translateAsync('languageManagement', { scope }),
-                                icon: 'fa-solid fa-square-terminal',
-                                children: [
-                                    {
-                                        text: await this.translateService.translateAsync('languageDefinition', { scope }),
-                                        path: '/demo/m/common/e/language/list',
-                                        icon: 'fa-solid fa-globe',
-                                        data: {
-                                        // requiredPermission: '',
-                                        },
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            },
-        ];
-    }
-}
-
-class AXMPlatformManagementModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementModule, providers: [
+class AXMPlatformManagementCommonModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementCommonModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementCommonModule, providers: [
+            // Country
             {
-                provide: AXMGlobalVariablesService,
-                useClass: AXMGlobalVariablesServiceImpl,
-            },
-            {
-                provide: AXMLanguageService,
-                useClass: AXMLanguageServiceImpl,
+                provide: AXMCountryService,
+                useClass: AXMCountryServiceImpl,
             },
             {
-                provide: AXMCommentService,
-                useClass: AXPCommentServiceImpl,
-            },
-            {
-                provide: AXP_ENTITY_DEFINITION_LOADER,
-                useClass: AXMLanguageModuleEntityLoader,
+                provide: AXP_WIDGET_DATASOURCE_PROVIDER,
+                useClass: AXPPlatformCountryWidgetDataSourceProvider,
                 multi: true,
             },
+            // Province
             {
-                provide: AXP_ENTITY_DEFINITION_LOADER,
-                useClass: AXMGlobalVariableModuleEntityLoader,
-                multi: true,
+                provide: AXMProvinceService,
+                useClass: AXMProvinceServiceImpl,
             },
             {
-                provide: AXP_MENU_PROVIDER,
-                useClass: AXMPlatformManagmentModuleMenuProvider,
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMCommonModuleEntityLoader,
                 multi: true,
             },
         ] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementCommonModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [],
                     exports: [],
                     declarations: [],
                     providers: [
+                        // Country
                         {
-                            provide: AXMGlobalVariablesService,
-                            useClass: AXMGlobalVariablesServiceImpl,
-                        },
-                        {
-                            provide: AXMLanguageService,
-                            useClass: AXMLanguageServiceImpl,
-                        },
-                        {
-                            provide: AXMCommentService,
-                            useClass: AXPCommentServiceImpl,
+                            provide: AXMCountryService,
+                            useClass: AXMCountryServiceImpl,
                         },
                         {
-                            provide: AXP_ENTITY_DEFINITION_LOADER,
-                            useClass: AXMLanguageModuleEntityLoader,
+                            provide: AXP_WIDGET_DATASOURCE_PROVIDER,
+                            useClass: AXPPlatformCountryWidgetDataSourceProvider,
                             multi: true,
                         },
+                        // Province
                         {
-                            provide: AXP_ENTITY_DEFINITION_LOADER,
-                            useClass: AXMGlobalVariableModuleEntityLoader,
-                            multi: true,
+                            provide: AXMProvinceService,
+                            useClass: AXMProvinceServiceImpl,
                         },
                         {
-                            provide: AXP_MENU_PROVIDER,
-                            useClass: AXMPlatformManagmentModuleMenuProvider,
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMCommonModuleEntityLoader,
                             multi: true,
                         },
                     ],
                 }]
         }] });
 
+class AXMGlobalVariablesService extends AXMEntityCrudServiceImpl {
+}
+class AXMGlobalVariablesServiceImpl extends AXMEntityCrudServiceImpl {
+    constructor() {
+        super('globalVariable');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariablesServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariablesServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariablesServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+const AXMPlatformManagementModuleConst = {
+    moduleName: 'PlatformManagement',
+    moduleRoute: 'platform-management',
+    i18n: 'platform-management',
+    localizationManagement: 'localization-management',
+    globalVariableEntity: 'GlobalVariable',
+    currencyEntity: 'currency',
+    countryEntity: 'country',
+    provinceEntity: 'province',
+    cityEntity: 'city',
+};
+
 async function globalVariableEntityFactory(injector) {
     const dataService = injector.get(AXMGlobalVariablesService);
     const entityDef = {
-        module: 'common',
-        name: 'globalVariable',
-        source: 'common.globalVariable',
+        module: AXMPlatformManagementModuleConst.moduleName,
+        name: AXMPlatformManagementModuleConst.globalVariableEntity,
+        source: '',
         title: 'Global Variable',
         formats: {
             individual: 'Global Variable',
@@ -467,7 +1496,7 @@ async function globalVariableEntityFactory(injector) {
         groups: [
             {
                 id: 'section',
-                title: 'Section',
+                title: 'Global Variable',
             },
         ],
         properties: [
@@ -513,6 +1542,11 @@ async function globalVariableEntityFactory(injector) {
                         type: AXPWidgetsCatalog.text,
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
                 name: 'dataType',
@@ -538,6 +1572,11 @@ async function globalVariableEntityFactory(injector) {
                         },
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
         ],
         columns: [{ name: 'title' }, { name: 'dataValue' }, { name: 'dataType' }],
@@ -654,7 +1693,27 @@ async function globalVariableEntityFactory(injector) {
                             },
                         },
                         {
-                            name: 'code',
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'dataValue',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'dataType',
                             layout: {
                                 positions: {
                                     lg: {
@@ -684,7 +1743,27 @@ async function globalVariableEntityFactory(injector) {
                             },
                         },
                         {
-                            name: 'code',
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'dataValue',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'dataType',
                             layout: {
                                 positions: {
                                     lg: {
@@ -749,9 +1828,153 @@ var globalVariable_entity = /*#__PURE__*/Object.freeze({
     globalVariableEntityFactory: globalVariableEntityFactory
 });
 
+class AXMGlobalVariableModuleEntityLoader {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    async get(moduleName, entityName) {
+        switch (entityName) {
+            case AXMPlatformManagementModuleConst.globalVariableEntity: {
+                const entity = (await Promise.resolve().then(function () { return globalVariable_entity; })).globalVariableEntityFactory;
+                return entity(this.injector);
+            }
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariableModuleEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariableModuleEntityLoader }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMGlobalVariableModuleEntityLoader, decorators: [{
+            type: Injectable
+        }] });
+
+class AXMPlatformManagmentModuleMenuProvider {
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+    }
+    async provide(context) {
+        const scope = AXMPlatformManagementModuleConst.i18n;
+        context.addItems([
+            {
+                name: 'administration-group',
+                priority: 2000,
+                text: `t('administration',{scope:${scope}})`,
+                type: 'group',
+                data: {
+                    requiredPermission: 'admin',
+                },
+            },
+            {
+                text: `t('platformManagement', {scope: ${scope}})`,
+                icon: 'fa-solid fa-square-terminal',
+                type: 'menu',
+                priority: 9100,
+                data: {
+                // requiredPermission: 'demo.admin.settings',
+                },
+                children: [
+                    {
+                        priority: 9001,
+                        text: `t('globalVariables', {scope: ${scope}})`,
+                        path: this.entityService.createPath(AXMPlatformManagementModuleConst.moduleName, AXMPlatformManagementModuleConst.globalVariableEntity),
+                        icon: 'fa-solid fa-object-exclude',
+                        data: {
+                        // requiredPermission: '',
+                        },
+                    },
+                    {
+                        priority: 9002,
+                        icon: 'fa-solid fa-coins',
+                        text: `t("currency", { scope: "common" })`,
+                        path: this.entityService.createPath(AXMPlatformManagementModuleConst.localizationManagement, AXMPlatformManagementModuleConst.currencyEntity),
+                    },
+                    {
+                        priority: 9003,
+                        icon: 'fa-solid fa-globe-stand',
+                        text: `t("geo", { scope: "common" })`,
+                        children: [
+                            {
+                                priority: 9101,
+                                icon: 'fa-solid fa-earth-americas',
+                                text: 't("country", { scope: "common" })',
+                                path: this.entityService.createPath(AXMPlatformManagementModuleConst.localizationManagement, AXMPlatformManagementModuleConst.countryEntity),
+                            },
+                            {
+                                priority: 9102,
+                                icon: 'fa-solid fa-mountain-city',
+                                text: 't("province", { scope: "common" })',
+                                path: this.entityService.createPath(AXMPlatformManagementModuleConst.localizationManagement, AXMPlatformManagementModuleConst.provinceEntity),
+                            },
+                            {
+                                priority: 9103,
+                                icon: 'fa-solid fa-city',
+                                text: 't("city", { scope: "common" })',
+                                path: this.entityService.createPath(AXMPlatformManagementModuleConst.localizationManagement, AXMPlatformManagementModuleConst.cityEntity),
+                            },
+                        ],
+                    },
+                ],
+            },
+        ]);
+    }
+}
+
+class AXMPlatformManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementModule, imports: [AXMPlatformManagementCommonModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementModule, providers: [
+            {
+                provide: AXMGlobalVariablesService,
+                useClass: AXMGlobalVariablesServiceImpl,
+            },
+            {
+                provide: AXMCurrencyService,
+                useClass: AXMCurrencyServiceImpl,
+            },
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMGlobalVariableModuleEntityLoader,
+                multi: true,
+            },
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMPlatformManagmentModuleMenuProvider,
+                multi: true,
+            },
+        ], imports: [AXMPlatformManagementCommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: AXMPlatformManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [AXMPlatformManagementCommonModule],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMGlobalVariablesService,
+                            useClass: AXMGlobalVariablesServiceImpl,
+                        },
+                        {
+                            provide: AXMCurrencyService,
+                            useClass: AXMCurrencyServiceImpl,
+                        },
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMGlobalVariableModuleEntityLoader,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMPlatformManagmentModuleMenuProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AXMGlobalVariableModuleEntityLoader, AXMGlobalVariablesService, AXMGlobalVariablesServiceImpl, AXMLanguageModuleEntityLoader, AXMLanguageService, AXMLanguageServiceImpl, AXMPlatformManagementModule, AXPCommentServiceImpl, globalVariableEntityFactory, languageEntityFactory };
+export { AXMCommonModuleEntityLoader, AXMCountryService, AXMCountryServiceImpl, AXMCurrencyService, AXMCurrencyServiceImpl, AXMGlobalVariableModuleEntityLoader, AXMGlobalVariablesService, AXMGlobalVariablesServiceImpl, AXMPlatformManagementModule, CITY_SOURCE_NAME, COUNTRY_SOURCE_NAME, CURRENCY_SOURCE_NAME, PROVINCE_SOURCE_NAME, countryEntityFactory, currencyEntityFactory, globalVariableEntityFactory };
 //# sourceMappingURL=acorex-modules-platform-management.mjs.map