@acorex/modules 21.0.0-next.74 → 21.0.0-next.76

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

@@ -1,16 +1,60 @@
 import * as i0 from '@angular/core';
 import { Injectable, inject, NgModule } from '@angular/core';
-import { AXPSystemActionType, AXP_MODULE_MANIFEST_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER } from '@acorex/platform/core';
-import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER, entityMasterCrudActions, entityMasterRecordActions, entityDetailsCrudActions, entityDetailsSimpleCondition } from '@acorex/platform/layout/entity';
-import { AXPSearchCommandProvider, createEntityCommandOptions, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, createAllQueryView } from '@acorex/platform/common';
+import { AXP_MODULE_MANIFEST_PROVIDER, AXP_FEATURE_DEFINITION_PROVIDER, AXP_DATASOURCE_DEFINITION_PROVIDER } from '@acorex/platform/core';
+import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import { entityDetailsCrudActions, AXPSystemActionType, createAllQueryView, entityMasterCrudActions, entityMasterRecordActions, AXPWidgetsCatalog as AXPWidgetsCatalog$1, entityDetailsSimpleCondition, AXPWidgetsList } from '@acorex/platform/contracts';
+import { AXPSearchCommandProvider, createEntityCommandOptions, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
 import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
 import { CommonModule } from '@angular/common';
 import { AXTranslationService } from '@acorex/core/translation';
-import { AXPCommonMenuKeys, AXPWidgetsList } from '@acorex/modules/common';
+import { AXPCommonMenuKeys } from '@acorex/modules/common';
 import { AXDataSource } from '@acorex/cdk/common';
 import { AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';
-import { AXPLocaleManagementDataSourceKeys } from '@acorex/modules/locale-management';
-import { RootConfig as RootConfig$1 } from '@acorex/modules/financial-core';
+import { AXPLocaleManagementDataSourceKeys } from '@acorex/modules/locale-management/contracts';
+
+//#region ---- Datasource keys ----
+/** Location Management datasource registry names. */
+const AXMLocationManagementDataSourceKeys = {
+    Countries: 'countries',
+    Provinces: 'provinces',
+    Cities: 'cities',
+};
+//#endregion
+
+// Management feature removed - module name is used directly as feature key
+const AXMLocationManagementFeatureKeys = {};
+
+//#region ---- Location contact related-entity actions ----
+/**
+ * Condition for LocationContact when shown as related entity of Location.
+ * @param locationIdContextPath - Context path for location ID (default: 'id' when parent is Location).
+ */
+function locationContactDetailsConditions(locationIdContextPath = 'id') {
+    return [
+        {
+            name: 'locationId',
+            operator: { type: 'equal' },
+            value: `{{context.eval("${locationIdContextPath}")}}`,
+        },
+    ];
+}
+/**
+ * CRUD actions for LocationContact when shown as related entity of Location.
+ * Injects locationId from context.eval("id").
+ */
+function locationContactDetailsCrudActions() {
+    return entityDetailsCrudActions('locationId');
+}
+//#endregion
+
+const AXPLocationManagementMenuKeys = {
+    Root: 'location-management:menu',
+    Locations: 'location-management:menu:locations',
+    Divider1: 'location-management:menu:divider-1',
+    LocationTypes: 'location-management:menu:location-types',
+    LocationRoles: 'location-management:menu:location-roles',
+    GeographicRegions: 'location-management:menu:geographic-regions',
+};
 
 const config = {
     i18n: 'location-management',
@@ -56,24 +100,6 @@ const RootConfig = {
     },
 };
 
-//#region ----   Imports   ----
-//#endregion
-//#region ----   Manifest Definition   ----
-/**
- * Location Management Module Manifest.
- * Defines module metadata, features, and provider references.
- */
-const LocationManagementManifest = {
-    name: RootConfig.module.name,
-    version: '1.0.0',
-    title: RootConfig.module.title,
-    icon: RootConfig.module.icon,
-    i18n: RootConfig.config.i18n,
-    required: true,
-    // Module dependencies (optional)
-};
-//#endregion
-
 const moduleKey = RootConfig.module.name;
 const entitiesKey = RootConfig.entities;
 const manageKey = AXPSystemActionType.Manage;
@@ -115,6 +141,27 @@ const AXMLocationManagementPermissionsKeys = {
     },
 };
 
+//#region ---- Contracts barrel ----
+//#endregion
+
+//#region ----   Imports   ----
+//#endregion
+//#region ----   Manifest Definition   ----
+/**
+ * Location Management Module Manifest.
+ * Defines module metadata, features, and provider references.
+ */
+const LocationManagementManifest = {
+    name: RootConfig.module.name,
+    version: '1.0.0',
+    title: RootConfig.module.title,
+    icon: RootConfig.module.icon,
+    i18n: RootConfig.config.i18n,
+    required: true,
+    // Module dependencies (optional)
+};
+//#endregion
+
 class AXMLocationManagementPermissionDefinitionProvider {
     constructor(injector) {
         this.injector = injector;
@@ -162,15 +209,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
             type: Injectable
         }], ctorParameters: () => [{ type: i0.Injector }] });
 
-const AXPLocationManagementMenuKeys = {
-    Root: 'location-management:menu',
-    Locations: 'location-management:menu:locations',
-    Divider1: 'location-management:menu:divider-1',
-    LocationTypes: 'location-management:menu:location-types',
-    LocationRoles: 'location-management:menu:location-roles',
-    GeographicRegions: 'location-management:menu:geographic-regions',
-};
-
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Menu Provider   ----
@@ -264,15 +302,15 @@ class AXMLocationManagementEntityProvider {
         if (moduleName == RootConfig.module.name) {
             switch (entityName) {
                 case RootConfig.entities.location.name:
-                    return (await Promise.resolve().then(function () { return location_entity; })).locationFactory();
+                    return (await Promise.resolve().then(function () { return index$3; })).locationFactory();
                 case RootConfig.entities.locationType.name:
-                    return (await Promise.resolve().then(function () { return locationType_entity; })).locationTypeFactory();
+                    return (await Promise.resolve().then(function () { return index; })).locationTypeFactory();
                 case RootConfig.entities.locationRole.name:
-                    return (await Promise.resolve().then(function () { return locationRole_entity; })).locationRoleFactory();
+                    return (await Promise.resolve().then(function () { return index$1; })).locationRoleFactory();
                 case RootConfig.entities.geographicRegion.name:
-                    return (await Promise.resolve().then(function () { return geographicRegion_entity; })).geographicRegionFactory();
+                    return (await Promise.resolve().then(function () { return index$4; })).geographicRegionFactory();
                 case RootConfig.entities.locationContact.name:
-                    return (await Promise.resolve().then(function () { return locationContact_entity; })).locationContactFactory();
+                    return (await Promise.resolve().then(function () { return index$2; })).locationContactFactory();
             }
         }
         return null;
@@ -383,15 +421,6 @@ class AXMLocationManagementFeatureDefinitionProvider {
 }
 //#endregion
 
-//#region ---- Datasource keys ----
-/** Location Management datasource registry names. */
-const AXMLocationManagementDataSourceKeys = {
-    Countries: 'countries',
-    Provinces: 'provinces',
-    Cities: 'cities',
-};
-//#endregion
-
 class AXMGeographicRegionDataSourceDefinition {
     constructor() {
         this.entityService = inject(AXPEntityService);
@@ -694,51 +723,44 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
-// Management feature removed - module name is used directly as feature key
-const AXMLocationManagementFeatureKeys = {};
-
-//#region ---- Contracts barrel ----
-//#endregion
-
-async function locationFactory() {
+async function geographicRegionFactory() {
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.location.name,
-        icon: 'fa-solid fa-location-dot',
-        title: RootConfig.entities.location.title,
+        name: RootConfig.entities.geographicRegion.name,
+        parentKey: 'parentId',
+        title: RootConfig.entities.geographicRegion.title,
+        icon: RootConfig.entities.geographicRegion.icon,
         formats: {
-            individual: RootConfig.entities.location.title,
-            plural: RootConfig.entities.location.titlePlural,
+            individual: RootConfig.entities.geographicRegion.title,
+            plural: RootConfig.entities.geographicRegion.titlePlural,
             searchResult: {
-                title: '{{ title }}',
-                description: '{{ context.eval("street1") + ", " + context.eval("city.title") + ", " + context.eval("state.title") }}',
+                title: '{{ name }}',
+                description: '{{ context.eval("type") + (context.eval("parentId") ? " (Child)" : "") }}',
             },
         },
-        plugins: [
-            { name: 'archive' },
-        ],
+        plugins: [{ name: 'archive' }],
         groups: [
             {
                 id: 'basic-info',
                 title: '@general:terms.interface.basic-info',
             },
             {
-                id: 'address',
-                title: '@location-management:locations.entities.location.groups.address-details',
-            },
-            {
-                id: 'geographic',
+                id: 'geographic-data',
                 title: '@general:terms.interface.geographic-details',
             },
             {
-                id: 'additional',
+                id: 'additional-info',
                 title: '@general:terms.interface.additional-info',
             },
+            {
+                id: 'settings',
+                title: '@general:terms.interface.settings',
+            },
         ],
         properties: [
             {
-                name: 'code',
-                title: '@location-management:locations.entities.location.fields.code',
+                name: 'title',
+                title: '@general:terms.common.title',
                 groupId: 'basic-info',
                 options: {
                     sort: {
@@ -756,16 +778,21 @@ async function locationFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
-                            placeholder: 'Optional location code',
+                            placeholder: 'Enter region title',
                         },
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
-                name: 'title',
-                title: '@general:terms.common.title',
+                name: 'code',
+                title: '@general:terms.common.code',
                 groupId: 'basic-info',
                 options: {
                     sort: {
@@ -783,21 +810,16 @@ async function locationFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
-                            placeholder: 'Enter location name',
+                            placeholder: 'Region code (e.g., CA, US)',
                         },
                     },
                 },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
             },
             {
-                name: 'locationTypeId',
-                title: '@location-management:locations.entities.location.fields.location-type',
+                name: 'type',
+                title: '@location-management:geographic-regions.entities.geographic-region.fields.type',
                 groupId: 'basic-info',
                 options: {
                     sort: {
@@ -813,15 +835,19 @@ async function locationFactory() {
                     },
                 },
                 schema: {
-                    dataType: 'object',
+                    dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.locationType.name}`,
-                            look: 'select',
-                            expose: [
-                                { source: 'id', target: 'locationType.id' },
-                                { source: 'title', target: 'locationType.title' },
+                            valueField: 'code',
+                            textField: 'title',
+                            dataSource: [
+                                { code: 'country', title: 'Country' },
+                                { code: 'state', title: 'State/Province' },
+                                { code: 'city', title: 'City' },
+                                { code: 'district', title: 'District' },
+                                { code: 'subdistrict', title: 'Subdistrict' },
+                                { code: 'territory', title: 'Territory' },
                             ],
                         },
                     },
@@ -833,13 +859,10 @@ async function locationFactory() {
                 ],
             },
             {
-                name: 'street1',
-                title: '@location-management:locations.entities.location.fields.street1',
-                groupId: 'address',
+                name: 'parentId',
+                title: '@location-management:geographic-regions.entities.geographic-region.fields.parent-region',
+                groupId: 'basic-info',
                 options: {
-                    sort: {
-                        enabled: true,
-                    },
                     filter: {
                         advance: {
                             enabled: true,
@@ -850,347 +873,149 @@ async function locationFactory() {
                     },
                 },
                 schema: {
-                    dataType: 'string',
+                    dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
-                            placeholder: 'Enter street address',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.geographicRegion.name}`,
+                            expose: [
+                                { source: 'id', target: 'parentRegion.id' },
+                                { source: 'name', target: 'parentRegion.name' },
+                                { source: 'type', target: 'parentRegion.type' },
+                            ],
                         },
                     },
                 },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
             },
             {
-                name: 'street2',
-                title: '@location-management:locations.entities.location.fields.street2',
-                groupId: 'address',
+                name: 'coordinates',
+                title: '@location-management:geographic-regions.entities.geographic-region.fields.coordinates',
+                groupId: 'geographic-data',
                 options: {
                     filter: {
                         advance: {
-                            enabled: true,
+                            enabled: false,
                         },
                     },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.map,
                         options: {
-                            placeholder: 'Apartment, suite, etc.',
+                            hasDraw: true,
+                            maxPolygon: 0,
+                            fitToDraw: true,
                         },
                     },
                 },
             },
             {
-                name: 'countryId',
-                title: '@location-management:locations.entities.location.fields.country',
-                groupId: 'address',
+                name: 'timezone',
+                title: '@location-management:geographic-regions.entities.geographic-region.fields.timezone',
+                groupId: 'geographic-data',
                 options: {
-                    sort: {
-                        enabled: true,
-                    },
                     filter: {
                         advance: {
                             enabled: true,
                         },
-                        inline: {
-                            enabled: true,
-                        },
                     },
                 },
                 schema: {
-                    dataType: 'object',
+                    dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.geographicRegion.name}`,
-                            look: 'select',
-                            expose: [
-                                { source: 'id', target: 'country.id' },
-                                { source: 'title', target: 'country.title' },
-                            ],
-                            filter: {
-                                logic: 'and',
-                                filters: [
-                                    { field: 'type.code', operator: { type: 'equal' }, value: 'country' },
-                                ],
-                            },
+                            allowSearch: true,
+                            valueField: 'code',
+                            placeholder: 'e.g., America/New_York',
+                            dataSource: AXPLocaleManagementDataSourceKeys.Timezones,
                         },
                     },
                 },
             },
             {
-                name: 'stateId',
-                title: '@location-management:locations.entities.location.fields.state',
-                groupId: 'address',
+                name: 'population',
+                title: '@location-management:geographic-regions.entities.geographic-region.fields.population',
+                groupId: 'additional-info',
                 options: {
                     filter: {
                         advance: {
                             enabled: true,
                         },
-                        inline: {
-                            enabled: true,
-                        },
                     },
                 },
                 schema: {
-                    dataType: 'object',
+                    dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
-                            look: 'select',
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.geographicRegion.name}`,
-                            expose: [
-                                { source: 'id', target: 'state.id' },
-                                { source: 'title', target: 'state.title' },
-                            ],
-                            filter: {
-                                logic: 'and',
-                                filters: [
-                                    {
-                                        field: 'parentId',
-                                        operator: {
-                                            type: 'equal',
-                                        },
-                                        value: '{{ context.eval("countryId") }}',
-                                    },
-                                    {
-                                        field: 'type.code',
-                                        operator: {
-                                            type: 'equal',
-                                        },
-                                        value: 'state',
-                                    },
-                                ],
-                            },
-                        },
-                        triggers: [
-                            {
-                                event: "{{ events.context('countryId') }}",
-                                action: `{{ widget.refresh() }}`,
-                            },
-                        ],
-                    },
-                },
-            },
-            {
-                name: 'cityId',
-                title: '@location-management:locations.entities.location.fields.city',
-                groupId: 'address',
-                options: {
-                    filter: {
-                        advance: {
-                            enabled: true,
-                        },
-                        inline: {
-                            enabled: true,
-                        },
-                    },
-                },
-                schema: {
-                    dataType: 'object',
-                    interface: {
-                        type: AXPWidgetsCatalog.lookup,
-                        options: {
-                            look: 'select',
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.geographicRegion.name}`,
-                            expose: [
-                                { source: 'id', target: 'city.id' },
-                                { source: 'title', target: 'city.title' },
-                            ],
-                            filter: {
-                                logic: 'and',
-                                filters: [
-                                    {
-                                        field: 'parentId',
-                                        operator: {
-                                            type: 'equal',
-                                        },
-                                        value: '{{ context.eval("stateId") }}',
-                                    },
-                                    {
-                                        field: 'type.code',
-                                        operator: {
-                                            type: 'equal',
-                                        },
-                                        value: 'city',
-                                    },
-                                ],
-                            },
+                            minValue: 0,
                         },
-                        triggers: [
-                            {
-                                event: "{{ events.context('stateId') }}",
-                                action: `{{ widget.refresh() }}`,
-                            },
-                        ],
                     },
                 },
             },
             {
-                name: 'postalCode',
-                title: '@location-management:locations.entities.location.fields.postal-code',
-                groupId: 'address',
+                name: 'area',
+                title: '@location-management:geographic-regions.entities.geographic-region.fields.area',
+                groupId: 'additional-info',
                 options: {
                     filter: {
                         advance: {
                             enabled: true,
                         },
-                        inline: {
-                            enabled: true,
-                        },
-                    },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.text,
-                        options: {
-                            placeholder: 'Postal/ZIP code',
-                        },
-                    },
-                },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
-            },
-            {
-                name: 'hasCoordinates',
-                title: '@location-management:locations.entities.location.fields.coordinates',
-                groupId: 'geographic',
-                schema: {
-                    dataType: 'boolean',
-                    // defaultValue: '{{ context.eval("coordinates") !== null }}',
-                    defaultValue: false,
-                    interface: {
-                        type: AXPWidgetsCatalog.toggle,
                     },
                 },
-            },
-            {
-                name: 'coordinates',
-                title: '@location-management:locations.entities.location.fields.coordinates',
-                groupId: 'geographic',
                 schema: {
-                    dataType: 'string',
+                    dataType: 'number',
                     interface: {
-                        type: AXPWidgetsCatalog.map,
+                        type: AXPWidgetsCatalog$1.number,
                         options: {
-                            hasDraw: true,
-                            maxPolygon: 0,
-                            fitToDraw: true,
-                            visibility: '{{ context.eval("hasCoordinates") == true }}',
+                            minValue: 0,
+                            placeholder: 'Area in square kilometers',
                         },
-                        triggers: [
-                            {
-                                event: "{{ events.context('hasCoordinates') }}",
-                                action: `{{ widget.clear() }}`,
-                            },
-                        ],
                     },
                 },
             },
             {
-                name: 'timezone',
-                title: '@location-management:locations.entities.location.fields.timezone',
-                groupId: 'geographic',
+                name: 'currencyId',
+                title: '@location-management:geographic-regions.entities.geographic-region.fields.currency',
+                groupId: 'additional-info',
                 options: {
+                    sort: { enabled: false },
                     filter: {
                         advance: {
                             enabled: true,
                         },
+                        inline: { enabled: false },
                     },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
-                        options: {
-                            allowSearch: true,
-                            valueField: 'code',
-                            placeholder: 'e.g., America/New_York',
-                            dataSource: AXPLocaleManagementDataSourceKeys.Timezones,
-                        },
-                    },
-                },
-            },
-            {
-                name: 'parentLocationId',
-                title: '@location-management:locations.entities.location.fields.parent-location',
-                groupId: 'basic-info',
-                options: {
-                    filter: {
-                        advance: {
-                            enabled: true,
-                        },
-                        inline: {
-                            enabled: true,
-                        },
-                    },
-                },
-                schema: {
-                    dataType: 'object',
-                    interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.location.name}`,
+                            entity: `${"FinancialCore"}.${"Currency"}`,
+                            multiple: false,
+                            look: 'select',
+                            textField: 'code',
+                            valueField: 'id',
                             expose: [
-                                { source: 'id', target: 'parentLocation.id' },
-                                { source: 'title', target: 'parentLocation.title' },
+                                { source: 'id', target: 'currency.id' },
+                                { source: 'code', target: 'currency.code' },
+                                { source: 'title', target: 'currency.title' },
+                                { source: 'symbol', target: 'currency.symbol' },
                             ],
                         },
                     },
                 },
             },
-            {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'basic-info',
-                options: {
-                    filter: {
-                        advance: {
-                            enabled: true,
-                        },
-                    },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.largeText,
-                        options: {
-                            rows: 3,
-                        },
-                    },
-                },
-            },
         ],
         columns: [
-            { name: 'code' },
-            { name: 'title' },
-            { name: 'locationTypeId', options: { dataPath: 'locationType.title' } },
-            { name: 'street1' },
-            { name: 'postalCode' },
-            { name: 'cityId', options: { dataPath: 'city.title' } },
-            { name: 'stateId', options: { dataPath: 'state.title' } },
-            { name: 'countryId', options: { dataPath: 'country.title' } },
-        ],
-        relatedEntities: [
-            {
-                entity: `${RootConfig.module.name}.${RootConfig.entities.locationContact.name}`,
-                title: '@location-management:locations.entities.location.related-entities.contacts.title',
-                icon: RootConfig.entities.locationContact.icon,
-                columns: ['personId', 'roleId', 'person.phones', 'person.emails'],
-                conditions: [entityDetailsSimpleCondition('locationId')],
-                actions: [...entityDetailsCrudActions('locationId')],
-                excludeProperties: ['locationId'],
-                layout: { type: 'page-list', position: 'after', order: 1 },
-            },
+            { name: 'title', options: { width: '400px', order: 1 } },
+            { name: 'code', options: { width: '150px', order: 2 } },
+            { name: 'type', options: { width: '150px', dataPath: 'type.title', order: 3 } },
+            { name: 'currencyId', options: { width: '150px', dataPath: 'currency.code', order: 4 } },
         ],
         interfaces: {
             master: {
@@ -1200,24 +1025,18 @@ async function locationFactory() {
                             id: 'basic-info',
                         },
                         {
-                            id: 'address',
+                            id: 'geographic-data',
                         },
                         {
-                            id: 'geographic',
+                            id: 'additional-info',
                         },
                         {
-                            id: 'additional',
+                            id: 'settings',
                         },
                     ],
                     properties: [
-                        {
-                            name: 'code',
-                        },
                         {
                             name: 'title',
-                        },
-                        {
-                            name: 'locationTypeId',
                             layout: {
                                 positions: {
                                     sm: {
@@ -1230,53 +1049,56 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'street1',
+                            name: 'code',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
+                                    md: {
+                                        colSpan: 6,
+                                    },
                                 },
                             },
                         },
                         {
-                            name: 'street2',
+                            name: 'type',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
+                                    md: {
+                                        colSpan: 6,
+                                    },
                                 },
                             },
                         },
                         {
-                            name: 'countryId',
+                            name: 'parentId',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
                                     md: {
-                                        colSpan: 4,
+                                        colSpan: 6,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'stateId',
+                            name: 'coordinates',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
-                                    md: {
-                                        colSpan: 4,
-                                    },
                                 },
                             },
                         },
                         {
-                            name: 'cityId',
+                            name: 'timezone',
                             layout: {
                                 positions: {
                                     sm: {
@@ -1289,7 +1111,7 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'postalCode',
+                            name: 'population',
                             layout: {
                                 positions: {
                                     sm: {
@@ -1302,30 +1124,7 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'hasCoordinates',
-                            layout: {
-                                positions: {
-                                    sm: {
-                                        colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'coordinates',
-                            layout: {
-                                label: {
-                                    visible: false,
-                                },
-                                positions: {
-                                    sm: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'timezone',
+                            name: 'area',
                             layout: {
                                 positions: {
                                     sm: {
@@ -1338,21 +1137,18 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'parentLocationId',
+                            name: 'currencyId',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
                                     md: {
-                                        colSpan: 6,
+                                        colSpan: 4,
                                     },
                                 },
                             },
                         },
-                        {
-                            name: 'description',
-                        },
                     ],
                 },
                 update: {
@@ -1361,27 +1157,18 @@ async function locationFactory() {
                             id: 'basic-info',
                         },
                         {
-                            id: 'address',
-                        },
-                        {
-                            id: 'geographic',
+                            id: 'geographic-data',
                         },
                         {
-                            id: 'additional',
+                            id: 'additional-info',
                         },
                         {
                             id: 'settings',
                         },
                     ],
                     properties: [
-                        {
-                            name: 'code',
-                        },
                         {
                             name: 'title',
-                        },
-                        {
-                            name: 'locationTypeId',
                             layout: {
                                 positions: {
                                     sm: {
@@ -1394,10 +1181,7 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'description',
-                        },
-                        {
-                            name: 'parentLocationId',
+                            name: 'code',
                             layout: {
                                 positions: {
                                     sm: {
@@ -1410,53 +1194,43 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'street1',
+                            name: 'type',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
-                                },
-                            },
-                        },
-                        {
-                            name: 'street2',
-                            layout: {
-                                positions: {
-                                    sm: {
-                                        colSpan: 12,
+                                    md: {
+                                        colSpan: 6,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'cityId',
+                            name: 'parentId',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
                                     md: {
-                                        colSpan: 4,
+                                        colSpan: 6,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'stateId',
+                            name: 'coordinates',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
-                                    md: {
-                                        colSpan: 4,
-                                    },
                                 },
                             },
                         },
                         {
-                            name: 'countryId',
+                            name: 'timezone',
                             layout: {
                                 positions: {
                                     sm: {
@@ -1469,7 +1243,7 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'postalCode',
+                            name: 'population',
                             layout: {
                                 positions: {
                                     sm: {
@@ -1482,30 +1256,20 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'hasCoordinates',
-                            layout: {
-                                positions: {
-                                    sm: {
-                                        colSpan: 6,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'coordinates',
+                            name: 'area',
                             layout: {
-                                label: {
-                                    visible: false,
-                                },
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
+                                    md: {
+                                        colSpan: 4,
+                                    },
                                 },
                             },
                         },
                         {
-                            name: 'timezone',
+                            name: 'currencyId',
                             layout: {
                                 positions: {
                                     sm: {
@@ -1533,7 +1297,7 @@ async function locationFactory() {
                             },
                         },
                         {
-                            id: 'address',
+                            id: 'geographic-data',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1543,7 +1307,7 @@ async function locationFactory() {
                             },
                         },
                         {
-                            id: 'geographic',
+                            id: 'additional-info',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1553,7 +1317,7 @@ async function locationFactory() {
                             },
                         },
                         {
-                            id: 'additional',
+                            id: 'settings',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1564,50 +1328,52 @@ async function locationFactory() {
                         },
                     ],
                     properties: [
-                        {
-                            name: 'code',
-                        },
                         {
                             name: 'title',
-                        },
-                        {
-                            name: 'locationTypeId',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
-                                        order: 3,
+                                        order: 1,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'description',
+                            name: 'code',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
                         },
                         {
-                            name: 'parentLocationId',
+                            name: 'type',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
-                                        order: 11,
+                                        order: 3,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'street1',
+                            name: 'parentId',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 12,
+                                        colSpan: 6,
                                         order: 4,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'street2',
+                            name: 'coordinates',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1618,7 +1384,7 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'cityId',
+                            name: 'timezone',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1629,7 +1395,7 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'stateId',
+                            name: 'population',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1640,7 +1406,7 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'countryId',
+                            name: 'area',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1651,7 +1417,7 @@ async function locationFactory() {
                             },
                         },
                         {
-                            name: 'postalCode',
+                            name: 'currencyId',
                             layout: {
                                 positions: {
                                     lg: {
@@ -1661,28 +1427,6 @@ async function locationFactory() {
                                 },
                             },
                         },
-                        {
-                            name: 'coordinates',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 10,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'timezone',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 4,
-                                        order: 11,
-                                    },
-                                },
-                            },
-                        },
                     ],
                     actions: [...entityMasterRecordActions()],
                 },
@@ -1700,45 +1444,74 @@ async function locationFactory() {
     return entityDef;
 }
 
-var location_entity = /*#__PURE__*/Object.freeze({
+var index$4 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    locationFactory: locationFactory
+    geographicRegionFactory: geographicRegionFactory
 });
 
-async function locationTypeFactory() {
-    const i18n = RootConfig.config.i18n;
+async function locationFactory() {
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.locationType.name,
-        title: RootConfig.entities.locationType.title,
+        name: RootConfig.entities.location.name,
+        icon: 'fa-solid fa-location-dot',
+        title: RootConfig.entities.location.title,
         formats: {
-            individual: RootConfig.entities.locationType.title,
-            plural: RootConfig.entities.locationType.titlePlural,
+            individual: RootConfig.entities.location.title,
+            plural: RootConfig.entities.location.titlePlural,
             searchResult: {
                 title: '{{ title }}',
-                description: '{{ description }}',
+                description: '{{ context.eval("street1") + ", " + context.eval("city.title", { pipes: ["translate"] }) + ", " + context.eval("state.title", { pipes: ["translate"] }) }}',
             },
         },
+        plugins: [
+            { name: 'archive' },
+        ],
         groups: [
             {
                 id: 'basic-info',
                 title: '@general:terms.interface.basic-info',
             },
             {
-                id: 'appearance',
-                title: '@general:terms.interface.appearance',
+                id: 'address',
+                title: '@location-management:locations.entities.location.groups.address-details',
             },
             {
-                id: 'settings',
-                title: '@general:terms.interface.settings',
+                id: 'geographic',
+                title: '@general:terms.interface.geographic-details',
+            },
+            {
+                id: 'additional',
+                title: '@general:terms.interface.additional-info',
             },
-        ],
-        plugins: [
-            { name: 'archive' },
-            { name: 'color' },
-            { name: 'icon' },
         ],
         properties: [
+            {
+                name: 'code',
+                title: '@location-management:locations.entities.location.fields.code',
+                groupId: 'basic-info',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.text,
+                        options: {
+                            placeholder: 'Optional location code',
+                        },
+                    },
+                },
+            },
             {
                 name: 'title',
                 title: '@general:terms.common.title',
@@ -1759,9 +1532,9 @@ async function locationTypeFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
-                            placeholder: 'Enter location type name',
+                            placeholder: 'Enter location name',
                         },
                     },
                 },
@@ -1772,377 +1545,99 @@ async function locationTypeFactory() {
                 ],
             },
             {
-                name: 'description',
-                title: '@general:terms.common.description',
+                name: 'locationTypeId',
+                title: '@location-management:locations.entities.location.fields.location-type',
                 groupId: 'basic-info',
                 options: {
+                    sort: {
+                        enabled: true,
+                    },
                     filter: {
                         advance: {
                             enabled: true,
                         },
+                        inline: {
+                            enabled: true,
+                        },
                     },
                 },
                 schema: {
-                    dataType: 'string',
+                    dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
-                            rows: 3,
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.locationType.name}`,
+                            look: 'select',
+                            expose: [
+                                { source: 'id', target: 'locationType.id' },
+                                { source: 'title', target: 'locationType.title' },
+                            ],
                         },
                     },
                 },
-            },
-        ],
-        columns: [{ name: 'title' }, { name: 'description' }],
-        interfaces: {
-            master: {
-                create: {
-                    sections: [
-                        {
-                            id: 'basic-info',
-                        },
-                        {
-                            id: 'appearance',
-                        },
-                        {
-                            id: 'settings',
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    sm: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'description',
-                            layout: {
-                                positions: {
-                                    sm: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                },
-                update: {
-                    sections: [
-                        {
-                            id: 'basic-info',
-                        },
-                        {
-                            id: 'appearance',
-                        },
-                        {
-                            id: 'settings',
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    sm: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'description',
-                            layout: {
-                                positions: {
-                                    sm: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                },
-                single: {
-                    title: '{{title}}',
-                    sections: [
-                        {
-                            id: 'basic-info',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            id: 'appearance',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            id: 'settings',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                    properties: [
-                        {
-                            name: 'title',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 1,
-                                    },
-                                },
-                            },
-                        },
-                        {
-                            name: 'description',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 2,
-                                    },
-                                },
-                            },
-                        },
-                    ],
-                    actions: [...entityMasterRecordActions()],
-                },
-                list: {
-                    actions: [...entityMasterCrudActions()],
-                    views: [
-                        createAllQueryView({
-                            sorts: [{ name: 'title', dir: 'asc' }],
-                        }),
-                    ],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-
-var locationType_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    locationTypeFactory: locationTypeFactory
-});
-
-//#region ----   Imports   ----
-//#endregion
-//#region ----   Entity Factory   ----
-async function locationRoleFactory() {
-    //TODO better implementation of this
-    const sections = [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }];
-    const propertyLayouts = [
-        { name: 'type', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
-        { name: 'name', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
-        { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
-    ];
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.locationRole.name,
-        title: RootConfig.entities.locationRole.title,
-        icon: RootConfig.entities.locationRole.icon,
-        formats: {
-            individual: RootConfig.entities.locationRole.title,
-            plural: RootConfig.entities.locationRole.titlePlural,
-            searchResult: {
-                title: '{{ title }}',
-                description: '@location-management:location-roles.entities.location-role.search-result-description',
-            },
-        },
-        plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'clone' }],
-        groups: [{ id: 'basic-info', title: '@general:terms.interface.basic-info' }],
-        properties: [
-            {
-                name: 'id',
-                title: '@general:terms.common.id',
-                groupId: 'basic-info',
-                schema: {
-                    dataType: 'uuid',
-                    visible: false,
-                    readonly: true,
-                    unique: { enabled: true },
-                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
-                name: 'type',
-                title: '@location-management:location-roles.entities.location-role.fields.type.title',
-                groupId: 'basic-info',
+                name: 'street1',
+                title: '@location-management:locations.entities.location.fields.street1',
+                groupId: 'address',
                 options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'array',
-                    defaultValue: ['party-location'],
-                    interface: {
-                        type: AXPWidgetsList.Editors.SelectBox,
-                        options: {
-                            valueField: 'id',
-                            textField: 'title',
-                            multiple: true,
-                            dataSource: [{ id: 'party-location', title: '@location-management:location-roles.entities.location-role.fields.type.options.party-location' }],
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
                         },
                     },
                 },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'name',
-                title: '@location-management:location-roles.entities.location-role.fields.name.title',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
-                            placeholder: '@location-management:location-roles.entities.location-role.fields.name.placeholder',
+                            placeholder: 'Enter street address',
                         },
                     },
                 },
-                validations: [{ rule: 'required' }],
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
+                name: 'street2',
+                title: '@location-management:locations.entities.location.fields.street2',
+                groupId: 'address',
                 options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                    },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
-                            placeholder: '@location-management:location-roles.entities.location-role.fields.title.placeholder',
+                            placeholder: 'Apartment, suite, etc.',
                         },
                     },
                 },
-                validations: [{ rule: 'required' }],
             },
             {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: false },
-                    filter: { advance: { enabled: true }, inline: { enabled: false } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LargeTextBox,
-                        options: {
-                            rows: 3,
-                            placeholder: '@location-management:location-roles.entities.location-role.fields.description.placeholder',
-                        },
-                    },
-                },
-            },
-        ],
-        columns: [
-            { name: 'name', options: { width: '140px', order: 1 } },
-            { name: 'title', options: { width: '220px', order: 2 } },
-            { name: 'type', options: { width: '180px', order: 3 } },
-        ],
-        interfaces: {
-            master: {
-                create: { sections, properties: propertyLayouts },
-                update: { sections, properties: propertyLayouts },
-                single: {
-                    title: '{{ title }}',
-                    sections,
-                    properties: propertyLayouts,
-                    actions: [...entityMasterRecordActions()],
-                },
-                list: {
-                    actions: [...entityMasterCrudActions()],
-                    views: [
-                        createAllQueryView({
-                            sorts: [{ name: 'title', dir: 'asc' }],
-                        }),
-                    ],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var locationRole_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    locationRoleFactory: locationRoleFactory
-});
-
-const AXMLocationRoleType = {
-    PartyLocation: 'party-location',
-};
-
-async function geographicRegionFactory() {
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.geographicRegion.name,
-        parentKey: 'parentId',
-        title: RootConfig.entities.geographicRegion.title,
-        icon: RootConfig.entities.geographicRegion.icon,
-        formats: {
-            individual: RootConfig.entities.geographicRegion.title,
-            plural: RootConfig.entities.geographicRegion.titlePlural,
-            searchResult: {
-                title: '{{ name }}',
-                description: '{{ context.eval("type") + (context.eval("parentId") ? " (Child)" : "") }}',
-            },
-        },
-        plugins: [{ name: 'archive' }],
-        groups: [
-            {
-                id: 'basic-info',
-                title: '@general:terms.interface.basic-info',
-            },
-            {
-                id: 'geographic-data',
-                title: '@general:terms.interface.geographic-details',
-            },
-            {
-                id: 'additional-info',
-                title: '@general:terms.interface.additional-info',
-            },
-            {
-                id: 'settings',
-                title: '@general:terms.interface.settings',
-            },
-        ],
-        properties: [
-            {
-                name: 'title',
-                title: '@general:terms.common.title',
-                groupId: 'basic-info',
+                name: 'countryId',
+                title: '@location-management:locations.entities.location.fields.country',
+                groupId: 'address',
                 options: {
                     sort: {
                         enabled: true,
@@ -2157,28 +1652,31 @@ async function geographicRegionFactory() {
                     },
                 },
                 schema: {
-                    dataType: 'string',
+                    dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
-                            placeholder: 'Enter region title',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.geographicRegion.name}`,
+                            look: 'select',
+                            expose: [
+                                { source: 'id', target: 'country.id' },
+                                { source: 'title', target: 'country.title' },
+                            ],
+                            filter: {
+                                logic: 'and',
+                                filters: [
+                                    { field: 'type.code', operator: { type: 'equal' }, value: 'country' },
+                                ],
+                            },
                         },
                     },
                 },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
             },
             {
-                name: 'code',
-                title: '@general:terms.common.code',
-                groupId: 'basic-info',
+                name: 'stateId',
+                title: '@location-management:locations.entities.location.fields.state',
+                groupId: 'address',
                 options: {
-                    sort: {
-                        enabled: true,
-                    },
                     filter: {
                         advance: {
                             enabled: true,
@@ -2189,23 +1687,50 @@ async function geographicRegionFactory() {
                     },
                 },
                 schema: {
-                    dataType: 'string',
+                    dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.text,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
-                            placeholder: 'Region code (e.g., CA, US)',
+                            look: 'select',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.geographicRegion.name}`,
+                            expose: [
+                                { source: 'id', target: 'state.id' },
+                                { source: 'title', target: 'state.title' },
+                            ],
+                            filter: {
+                                logic: 'and',
+                                filters: [
+                                    {
+                                        field: 'parentId',
+                                        operator: {
+                                            type: 'equal',
+                                        },
+                                        value: '{{ context.eval("countryId") }}',
+                                    },
+                                    {
+                                        field: 'type.code',
+                                        operator: {
+                                            type: 'equal',
+                                        },
+                                        value: 'state',
+                                    },
+                                ],
+                            },
                         },
+                        triggers: [
+                            {
+                                event: "{{ events.context('countryId') }}",
+                                action: `{{ widget.refresh() }}`,
+                            },
+                        ],
                     },
                 },
             },
             {
-                name: 'type',
-                title: '@location-management:geographic-regions.entities.geographic-region.fields.type',
-                groupId: 'basic-info',
+                name: 'cityId',
+                title: '@location-management:locations.entities.location.fields.city',
+                groupId: 'address',
                 options: {
-                    sort: {
-                        enabled: true,
-                    },
                     filter: {
                         advance: {
                             enabled: true,
@@ -2216,33 +1741,49 @@ async function geographicRegionFactory() {
                     },
                 },
                 schema: {
-                    dataType: 'string',
+                    dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
-                            valueField: 'code',
-                            textField: 'title',
-                            dataSource: [
-                                { code: 'country', title: 'Country' },
-                                { code: 'state', title: 'State/Province' },
-                                { code: 'city', title: 'City' },
-                                { code: 'district', title: 'District' },
-                                { code: 'subdistrict', title: 'Subdistrict' },
-                                { code: 'territory', title: 'Territory' },
+                            look: 'select',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.geographicRegion.name}`,
+                            expose: [
+                                { source: 'id', target: 'city.id' },
+                                { source: 'title', target: 'city.title' },
                             ],
+                            filter: {
+                                logic: 'and',
+                                filters: [
+                                    {
+                                        field: 'parentId',
+                                        operator: {
+                                            type: 'equal',
+                                        },
+                                        value: '{{ context.eval("stateId") }}',
+                                    },
+                                    {
+                                        field: 'type.code',
+                                        operator: {
+                                            type: 'equal',
+                                        },
+                                        value: 'city',
+                                    },
+                                ],
+                            },
                         },
+                        triggers: [
+                            {
+                                event: "{{ events.context('stateId') }}",
+                                action: `{{ widget.refresh() }}`,
+                            },
+                        ],
                     },
                 },
-                validations: [
-                    {
-                        rule: 'required',
-                    },
-                ],
             },
             {
-                name: 'parentId',
-                title: '@location-management:geographic-regions.entities.geographic-region.fields.parent-region',
-                groupId: 'basic-info',
+                name: 'postalCode',
+                title: '@location-management:locations.entities.location.fields.postal-code',
+                groupId: 'address',
                 options: {
                     filter: {
                         advance: {
@@ -2254,47 +1795,60 @@ async function geographicRegionFactory() {
                     },
                 },
                 schema: {
-                    dataType: 'object',
+                    dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.text,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.geographicRegion.name}`,
-                            expose: [
-                                { source: 'id', target: 'parentRegion.id' },
-                                { source: 'name', target: 'parentRegion.name' },
-                                { source: 'type', target: 'parentRegion.type' },
-                            ],
+                            placeholder: 'Postal/ZIP code',
                         },
                     },
                 },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
             },
             {
-                name: 'coordinates',
-                title: '@location-management:geographic-regions.entities.geographic-region.fields.coordinates',
-                groupId: 'geographic-data',
-                options: {
-                    filter: {
-                        advance: {
-                            enabled: false,
-                        },
+                name: 'hasCoordinates',
+                title: '@location-management:locations.entities.location.fields.coordinates',
+                groupId: 'geographic',
+                schema: {
+                    dataType: 'boolean',
+                    // defaultValue: '{{ context.eval("coordinates") !== null }}',
+                    defaultValue: false,
+                    interface: {
+                        type: AXPWidgetsCatalog$1.toggle,
                     },
                 },
+            },
+            {
+                name: 'coordinates',
+                title: '@location-management:locations.entities.location.fields.coordinates',
+                groupId: 'geographic',
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.map,
+                        type: AXPWidgetsCatalog$1.map,
                         options: {
                             hasDraw: true,
                             maxPolygon: 0,
                             fitToDraw: true,
+                            visibility: '{{ context.eval("hasCoordinates") == true }}',
                         },
-                    },
+                        triggers: [
+                            {
+                                event: "{{ events.context('hasCoordinates') }}",
+                                action: `{{ widget.clear() }}`,
+                            },
+                        ],
+                    },
                 },
             },
             {
                 name: 'timezone',
-                title: '@location-management:geographic-regions.entities.geographic-region.fields.timezone',
-                groupId: 'geographic-data',
+                title: '@location-management:locations.entities.location.fields.timezone',
+                groupId: 'geographic',
                 options: {
                     filter: {
                         advance: {
@@ -2305,7 +1859,7 @@ async function geographicRegionFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.select,
+                        type: AXPWidgetsCatalog$1.select,
                         options: {
                             allowSearch: true,
                             valueField: 'code',
@@ -2316,87 +1870,76 @@ async function geographicRegionFactory() {
                 },
             },
             {
-                name: 'population',
-                title: '@location-management:geographic-regions.entities.geographic-region.fields.population',
-                groupId: 'additional-info',
+                name: 'parentLocationId',
+                title: '@location-management:locations.entities.location.fields.parent-location',
+                groupId: 'basic-info',
                 options: {
                     filter: {
                         advance: {
                             enabled: true,
                         },
-                    },
-                },
-                schema: {
-                    dataType: 'number',
-                    interface: {
-                        type: AXPWidgetsCatalog.number,
-                        options: {
-                            minValue: 0,
-                        },
-                    },
-                },
-            },
-            {
-                name: 'area',
-                title: '@location-management:geographic-regions.entities.geographic-region.fields.area',
-                groupId: 'additional-info',
-                options: {
-                    filter: {
-                        advance: {
+                        inline: {
                             enabled: true,
                         },
                     },
                 },
                 schema: {
-                    dataType: 'number',
+                    dataType: 'object',
                     interface: {
-                        type: AXPWidgetsCatalog.number,
+                        type: AXPWidgetsCatalog$1.lookup,
                         options: {
-                            minValue: 0,
-                            placeholder: 'Area in square kilometers',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.location.name}`,
+                            expose: [
+                                { source: 'id', target: 'parentLocation.id' },
+                                { source: 'title', target: 'parentLocation.title' },
+                            ],
                         },
                     },
                 },
             },
             {
-                name: 'currencyId',
-                title: '@location-management:geographic-regions.entities.geographic-region.fields.currency',
-                groupId: 'additional-info',
+                name: 'description',
+                title: '@general:terms.common.description',
+                groupId: 'basic-info',
                 options: {
-                    sort: { enabled: false },
                     filter: {
                         advance: {
                             enabled: true,
                         },
-                        inline: { enabled: false },
                     },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsCatalog.lookup,
+                        type: AXPWidgetsCatalog$1.largeText,
                         options: {
-                            entity: `${RootConfig$1.module.name}.${RootConfig$1.entities.currency.name}`,
-                            multiple: false,
-                            look: 'select',
-                            textField: 'code',
-                            valueField: 'id',
-                            expose: [
-                                { source: 'id', target: 'currency.id' },
-                                { source: 'code', target: 'currency.code' },
-                                { source: 'title', target: 'currency.title' },
-                                { source: 'symbol', target: 'currency.symbol' },
-                            ],
+                            rows: 3,
                         },
                     },
                 },
             },
         ],
         columns: [
-            { name: 'title', options: { width: '400px', order: 1 } },
-            { name: 'code', options: { width: '150px', order: 2 } },
-            { name: 'type', options: { width: '150px', dataPath: 'type.title', order: 3 } },
-            { name: 'currencyId', options: { width: '150px', dataPath: 'currency.code', order: 4 } },
+            { name: 'code' },
+            { name: 'title' },
+            { name: 'locationTypeId', options: { dataPath: 'locationType.title' } },
+            { name: 'street1' },
+            { name: 'postalCode' },
+            { name: 'cityId', options: { dataPath: 'city.title' } },
+            { name: 'stateId', options: { dataPath: 'state.title' } },
+            { name: 'countryId', options: { dataPath: 'country.title' } },
+        ],
+        relatedEntities: [
+            {
+                entity: `${RootConfig.module.name}.${RootConfig.entities.locationContact.name}`,
+                title: '@location-management:locations.entities.location.related-entities.contacts.title',
+                icon: RootConfig.entities.locationContact.icon,
+                columns: ['personId', 'roleId', 'person.phones', 'person.emails'],
+                conditions: [entityDetailsSimpleCondition('locationId')],
+                actions: [...entityDetailsCrudActions('locationId')],
+                excludeProperties: ['locationId'],
+                layout: { type: 'page-list', position: 'after', order: 1 },
+            },
         ],
         interfaces: {
             master: {
@@ -2406,18 +1949,24 @@ async function geographicRegionFactory() {
                             id: 'basic-info',
                         },
                         {
-                            id: 'geographic-data',
+                            id: 'address',
                         },
                         {
-                            id: 'additional-info',
+                            id: 'geographic',
                         },
                         {
-                            id: 'settings',
+                            id: 'additional',
                         },
                     ],
                     properties: [
+                        {
+                            name: 'code',
+                        },
                         {
                             name: 'title',
+                        },
+                        {
+                            name: 'locationTypeId',
                             layout: {
                                 positions: {
                                     sm: {
@@ -2430,56 +1979,53 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            name: 'code',
+                            name: 'street1',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
-                                    md: {
-                                        colSpan: 6,
-                                    },
                                 },
                             },
                         },
                         {
-                            name: 'type',
+                            name: 'street2',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
-                                    md: {
-                                        colSpan: 6,
-                                    },
                                 },
                             },
                         },
                         {
-                            name: 'parentId',
+                            name: 'countryId',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
                                     md: {
-                                        colSpan: 6,
+                                        colSpan: 4,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'coordinates',
+                            name: 'stateId',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
+                                    md: {
+                                        colSpan: 4,
+                                    },
                                 },
                             },
                         },
                         {
-                            name: 'timezone',
+                            name: 'cityId',
                             layout: {
                                 positions: {
                                     sm: {
@@ -2492,7 +2038,7 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            name: 'population',
+                            name: 'postalCode',
                             layout: {
                                 positions: {
                                     sm: {
@@ -2505,7 +2051,30 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            name: 'area',
+                            name: 'hasCoordinates',
+                            layout: {
+                                positions: {
+                                    sm: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'coordinates',
+                            layout: {
+                                label: {
+                                    visible: false,
+                                },
+                                positions: {
+                                    sm: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'timezone',
                             layout: {
                                 positions: {
                                     sm: {
@@ -2518,18 +2087,21 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            name: 'currencyId',
+                            name: 'parentLocationId',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
                                     md: {
-                                        colSpan: 4,
+                                        colSpan: 6,
                                     },
                                 },
                             },
                         },
+                        {
+                            name: 'description',
+                        },
                     ],
                 },
                 update: {
@@ -2538,18 +2110,27 @@ async function geographicRegionFactory() {
                             id: 'basic-info',
                         },
                         {
-                            id: 'geographic-data',
+                            id: 'address',
                         },
                         {
-                            id: 'additional-info',
+                            id: 'geographic',
+                        },
+                        {
+                            id: 'additional',
                         },
                         {
                             id: 'settings',
                         },
                     ],
                     properties: [
+                        {
+                            name: 'code',
+                        },
                         {
                             name: 'title',
+                        },
+                        {
+                            name: 'locationTypeId',
                             layout: {
                                 positions: {
                                     sm: {
@@ -2562,7 +2143,10 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            name: 'code',
+                            name: 'description',
+                        },
+                        {
+                            name: 'parentLocationId',
                             layout: {
                                 positions: {
                                     sm: {
@@ -2575,43 +2159,40 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            name: 'type',
+                            name: 'street1',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
-                                    md: {
-                                        colSpan: 6,
-                                    },
                                 },
                             },
                         },
                         {
-                            name: 'parentId',
+                            name: 'street2',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
-                                    md: {
-                                        colSpan: 6,
-                                    },
                                 },
                             },
                         },
                         {
-                            name: 'coordinates',
+                            name: 'cityId',
                             layout: {
                                 positions: {
                                     sm: {
                                         colSpan: 12,
                                     },
+                                    md: {
+                                        colSpan: 4,
+                                    },
                                 },
                             },
                         },
                         {
-                            name: 'timezone',
+                            name: 'stateId',
                             layout: {
                                 positions: {
                                     sm: {
@@ -2624,7 +2205,7 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            name: 'population',
+                            name: 'countryId',
                             layout: {
                                 positions: {
                                     sm: {
@@ -2637,7 +2218,7 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            name: 'area',
+                            name: 'postalCode',
                             layout: {
                                 positions: {
                                     sm: {
@@ -2650,7 +2231,30 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            name: 'currencyId',
+                            name: 'hasCoordinates',
+                            layout: {
+                                positions: {
+                                    sm: {
+                                        colSpan: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'coordinates',
+                            layout: {
+                                label: {
+                                    visible: false,
+                                },
+                                positions: {
+                                    sm: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'timezone',
                             layout: {
                                 positions: {
                                     sm: {
@@ -2678,7 +2282,7 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            id: 'geographic-data',
+                            id: 'address',
                             layout: {
                                 positions: {
                                     lg: {
@@ -2688,7 +2292,7 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            id: 'additional-info',
+                            id: 'geographic',
                             layout: {
                                 positions: {
                                     lg: {
@@ -2698,7 +2302,7 @@ async function geographicRegionFactory() {
                             },
                         },
                         {
-                            id: 'settings',
+                            id: 'additional',
                             layout: {
                                 positions: {
                                     lg: {
@@ -2709,101 +2313,685 @@ async function geographicRegionFactory() {
                         },
                     ],
                     properties: [
+                        {
+                            name: 'code',
+                        },
                         {
                             name: 'title',
+                        },
+                        {
+                            name: 'locationTypeId',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 6,
-                                        order: 1,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'description',
+                        },
+                        {
+                            name: 'parentLocationId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 11,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'street1',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'street2',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'cityId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 6,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'stateId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 7,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'countryId',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 8,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'postalCode',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 9,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'coordinates',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 10,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'timezone',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 4,
+                                        order: 11,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var index$3 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    locationFactory: locationFactory
+});
+
+//#endregion
+//#region ----   Entity Factory   ----
+async function locationContactFactory() {
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.locationContact.name,
+        title: RootConfig.entities.locationContact.title,
+        icon: RootConfig.entities.locationContact.icon,
+        formats: {
+            individual: RootConfig.entities.locationContact.title,
+            plural: RootConfig.entities.locationContact.titlePlural,
+            searchResult: {
+                title: '{{ context.eval("person.fullName") + " (" + context.eval("role.title", { pipes: ["translate"] }) + ")" }}',
+                description: '@location-management:location-contacts.entities.location-contact.search-result-description',
+            },
+        },
+        plugins: [{ name: 'notes' }],
+        groups: [{ id: 'basic-info', title: '@general:terms.interface.basic-info' }],
+        properties: [
+            {
+                name: 'locationId',
+                title: '@location-management:location-contacts.entities.location-contact.fields.location.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.location.name}`,
+                            multiple: false,
+                            textField: 'title',
+                            columns: ['title', 'code'],
+                            expose: [
+                                { source: 'id', target: 'location.id' },
+                                { source: 'title', target: 'location.title' },
+                            ],
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'personId',
+                title: '@location-management:location-contacts.entities.location-contact.fields.person.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.lookup,
+                        options: {
+                            entity: 'PersonCore.Person',
+                            multiple: false,
+                            textField: 'fullName',
+                            columns: ['fullName', 'phones', 'emails'],
+                            allowCreate: 'quick',
+                            expose: [
+                                { source: 'id', target: 'person.id' },
+                                { source: 'fullName', target: 'person.fullName' },
+                                { source: 'phones', target: 'person.phones' },
+                                { source: 'emails', target: 'person.emails' },
+                            ],
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'roleId',
+                title: '@location-management:location-contacts.entities.location-contact.fields.role.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.lookup,
+                        options: {
+                            look: 'select',
+                            entity: 'PersonCore.ContactRole',
+                            multiple: false,
+                            expose: [
+                                { source: 'id', target: 'role.id' },
+                                { source: 'title', target: 'role.title' },
+                            ],
+                            filter: {
+                                logic: 'and',
+                                filters: [
+                                    {
+                                        field: 'type',
+                                        operator: { type: 'contains' },
+                                        value: 'location-contact',
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+        ],
+        columns: [
+            { name: 'locationId', options: { dataPath: 'location.title' } },
+            { name: 'personId', options: { dataPath: 'person.fullName' } },
+            { name: 'roleId', options: { dataPath: 'role.title' } },
+            { name: 'person.phones', options: { width: '200px' } },
+            { name: 'person.emails', options: { width: '200px' } },
+        ],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [{ id: 'basic-info' }],
+                    properties: [
+                        { name: 'locationId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
+                        { name: 'personId', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
+                        { name: 'roleId', layout: { positions: { lg: { colSpan: 6, order: 3 } } } },
+                    ],
+                },
+                update: {
+                    sections: [{ id: 'basic-info' }],
+                    properties: [
+                        { name: 'locationId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
+                        { name: 'personId', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
+                        { name: 'roleId', layout: { positions: { lg: { colSpan: 6, order: 3 } } } },
+                    ],
+                },
+                single: {
+                    title: '{{ context.eval("person.fullName") + " - " + context.eval("role.title", { pipes: ["translate"] }) }}',
+                    sections: [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }],
+                    properties: [
+                        { name: 'locationId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
+                        { name: 'personId', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
+                        { name: 'roleId', layout: { positions: { lg: { colSpan: 6, order: 3 } } } },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'roleId', dir: 'asc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+//#endregion
+
+var index$2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    locationContactFactory: locationContactFactory
+});
+
+//#endregion
+//#region ----   Entity Factory   ----
+async function locationRoleFactory() {
+    //TODO better implementation of this
+    const sections = [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }];
+    const propertyLayouts = [
+        { name: 'type', layout: { positions: { lg: { colSpan: 6, order: 1 } } } },
+        { name: 'name', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
+        { name: 'title', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
+    ];
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.locationRole.name,
+        title: RootConfig.entities.locationRole.title,
+        icon: RootConfig.entities.locationRole.icon,
+        formats: {
+            individual: RootConfig.entities.locationRole.title,
+            plural: RootConfig.entities.locationRole.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: '@location-management:location-roles.entities.location-role.search-result-description',
+            },
+        },
+        plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'clone' }],
+        groups: [{ id: 'basic-info', title: '@general:terms.interface.basic-info' }],
+        properties: [
+            {
+                name: 'id',
+                title: '@general:terms.common.id',
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'uuid',
+                    visible: false,
+                    readonly: true,
+                    unique: { enabled: true },
+                },
+            },
+            {
+                name: 'type',
+                title: '@location-management:location-roles.entities.location-role.fields.type.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'array',
+                    defaultValue: ['party-location'],
+                    interface: {
+                        type: AXPWidgetsList.Editors.SelectBox,
+                        options: {
+                            valueField: 'id',
+                            textField: 'title',
+                            multiple: true,
+                            dataSource: [{ id: 'party-location', title: '@location-management:location-roles.entities.location-role.fields.type.options.party-location' }],
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'name',
+                title: '@location-management:location-roles.entities.location-role.fields.name.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            placeholder: '@location-management:location-roles.entities.location-role.fields.name.placeholder',
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            placeholder: '@location-management:location-roles.entities.location-role.fields.title.placeholder',
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'description',
+                title: '@general:terms.common.description',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: false },
+                    filter: { advance: { enabled: true }, inline: { enabled: false } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.LargeTextBox,
+                        options: {
+                            rows: 3,
+                            placeholder: '@location-management:location-roles.entities.location-role.fields.description.placeholder',
+                        },
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'name', options: { width: '140px', order: 1 } },
+            { name: 'title', options: { width: '220px', order: 2 } },
+            { name: 'type', options: { width: '180px', order: 3 } },
+        ],
+        interfaces: {
+            master: {
+                create: { sections, properties: propertyLayouts },
+                update: { sections, properties: propertyLayouts },
+                single: {
+                    title: '{{ title }}',
+                    sections,
+                    properties: propertyLayouts,
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'title', dir: 'asc' }],
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+//#endregion
+
+const AXMLocationRoleType = {
+    PartyLocation: 'party-location',
+};
+
+var index$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AXMLocationRoleType: AXMLocationRoleType,
+    locationRoleFactory: locationRoleFactory
+});
+
+async function locationTypeFactory() {
+    const i18n = RootConfig.config.i18n;
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.locationType.name,
+        title: RootConfig.entities.locationType.title,
+        formats: {
+            individual: RootConfig.entities.locationType.title,
+            plural: RootConfig.entities.locationType.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: '{{ description }}',
+            },
+        },
+        groups: [
+            {
+                id: 'basic-info',
+                title: '@general:terms.interface.basic-info',
+            },
+            {
+                id: 'appearance',
+                title: '@general:terms.interface.appearance',
+            },
+            {
+                id: 'settings',
+                title: '@general:terms.interface.settings',
+            },
+        ],
+        plugins: [
+            { name: 'archive' },
+            { name: 'color' },
+            { name: 'icon' },
+        ],
+        properties: [
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.text,
+                        options: {
+                            placeholder: 'Enter location type name',
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'description',
+                title: '@general:terms.common.description',
+                groupId: 'basic-info',
+                options: {
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog$1.largeText,
+                        options: {
+                            rows: 3,
+                        },
+                    },
+                },
+            },
+        ],
+        columns: [{ name: 'title' }, { name: 'description' }],
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'basic-info',
+                        },
+                        {
+                            id: 'appearance',
+                        },
+                        {
+                            id: 'settings',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    sm: {
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'code',
+                            name: 'description',
                             layout: {
                                 positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 2,
+                                    sm: {
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
+                    ],
+                },
+                update: {
+                    sections: [
                         {
-                            name: 'type',
+                            id: 'basic-info',
+                        },
+                        {
+                            id: 'appearance',
+                        },
+                        {
+                            id: 'settings',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'title',
                             layout: {
                                 positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 3,
+                                    sm: {
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'parentId',
+                            name: 'description',
                             layout: {
                                 positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 4,
+                                    sm: {
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
                         {
-                            name: 'coordinates',
+                            id: 'basic-info',
                             layout: {
                                 positions: {
                                     lg: {
                                         colSpan: 12,
-                                        order: 5,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'timezone',
+                            id: 'appearance',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 4,
-                                        order: 6,
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'population',
+                            id: 'settings',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 4,
-                                        order: 7,
+                                        colSpan: 12,
                                     },
                                 },
                             },
                         },
+                    ],
+                    properties: [
                         {
-                            name: 'area',
+                            name: 'title',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 4,
-                                        order: 8,
+                                        colSpan: 12,
+                                        order: 1,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'currencyId',
+                            name: 'description',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 4,
-                                        order: 9,
+                                        colSpan: 12,
+                                        order: 2,
                                     },
                                 },
                             },
@@ -2825,200 +3013,11 @@ async function geographicRegionFactory() {
     return entityDef;
 }
 
-var geographicRegion_entity = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    geographicRegionFactory: geographicRegionFactory
-});
-
-//#region ----   Imports   ----
-//#endregion
-//#region ----   Entity Factory   ----
-async function locationContactFactory() {
-    const entityDef = {
-        module: RootConfig.module.name,
-        name: RootConfig.entities.locationContact.name,
-        title: RootConfig.entities.locationContact.title,
-        icon: RootConfig.entities.locationContact.icon,
-        formats: {
-            individual: RootConfig.entities.locationContact.title,
-            plural: RootConfig.entities.locationContact.titlePlural,
-            searchResult: {
-                title: '{{ context.eval("person.fullName") + " (" + context.eval("role.title") + ")" }}',
-                description: '@location-management:location-contacts.entities.location-contact.search-result-description',
-            },
-        },
-        plugins: [{ name: 'notes' }],
-        groups: [{ id: 'basic-info', title: '@general:terms.interface.basic-info' }],
-        properties: [
-            {
-                name: 'locationId',
-                title: '@location-management:location-contacts.entities.location-contact.fields.location.title',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.lookup,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.location.name}`,
-                            multiple: false,
-                            textField: 'title',
-                            columns: ['title', 'code'],
-                            expose: [
-                                { source: 'id', target: 'location.id' },
-                                { source: 'title', target: 'location.title' },
-                            ],
-                        },
-                    },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'personId',
-                title: '@location-management:location-contacts.entities.location-contact.fields.person.title',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.lookup,
-                        options: {
-                            entity: 'PersonCore.Person',
-                            multiple: false,
-                            textField: 'fullName',
-                            columns: ['fullName', 'phones', 'emails'],
-                            allowCreate: 'quick',
-                            expose: [
-                                { source: 'id', target: 'person.id' },
-                                { source: 'fullName', target: 'person.fullName' },
-                                { source: 'phones', target: 'person.phones' },
-                                { source: 'emails', target: 'person.emails' },
-                            ],
-                        },
-                    },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'roleId',
-                title: '@location-management:location-contacts.entities.location-contact.fields.role.title',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsCatalog.lookup,
-                        options: {
-                            look: 'select',
-                            entity: 'PersonCore.ContactRole',
-                            multiple: false,
-                            expose: [
-                                { source: 'id', target: 'role.id' },
-                                { source: 'title', target: 'role.title' },
-                            ],
-                            filter: {
-                                logic: 'and',
-                                filters: [
-                                    {
-                                        field: 'type',
-                                        operator: { type: 'contains' },
-                                        value: 'location-contact',
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                },
-                validations: [{ rule: 'required' }],
-            },
-        ],
-        columns: [
-            { name: 'locationId', options: { dataPath: 'location.title' } },
-            { name: 'personId', options: { dataPath: 'person.fullName' } },
-            { name: 'roleId', options: { dataPath: 'role.title' } },
-            { name: 'person.phones', options: { width: '200px' } },
-            { name: 'person.emails', options: { width: '200px' } },
-        ],
-        interfaces: {
-            master: {
-                create: {
-                    sections: [{ id: 'basic-info' }],
-                    properties: [
-                        { name: 'locationId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-                        { name: 'personId', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
-                        { name: 'roleId', layout: { positions: { lg: { colSpan: 6, order: 3 } } } },
-                    ],
-                },
-                update: {
-                    sections: [{ id: 'basic-info' }],
-                    properties: [
-                        { name: 'locationId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-                        { name: 'personId', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
-                        { name: 'roleId', layout: { positions: { lg: { colSpan: 6, order: 3 } } } },
-                    ],
-                },
-                single: {
-                    title: '{{ context.eval("person.fullName") + " - " + context.eval("role.title") }}',
-                    sections: [{ id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } }],
-                    properties: [
-                        { name: 'locationId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-                        { name: 'personId', layout: { positions: { lg: { colSpan: 6, order: 2 } } } },
-                        { name: 'roleId', layout: { positions: { lg: { colSpan: 6, order: 3 } } } },
-                    ],
-                    actions: [...entityMasterRecordActions()],
-                },
-                list: {
-                    actions: [...entityMasterCrudActions()],
-                    views: [
-                        createAllQueryView({
-                            sorts: [{ name: 'roleId', dir: 'asc' }],
-                        }),
-                    ],
-                },
-            },
-        },
-    };
-    return entityDef;
-}
-//#endregion
-
-var locationContact_entity = /*#__PURE__*/Object.freeze({
+var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    locationContactFactory: locationContactFactory
+    locationTypeFactory: locationTypeFactory
 });
 
-//#region ----   Imports   ----
-//#endregion
-/**
- * Condition for LocationContact when shown as related entity of Location.
- * @param locationIdContextPath - Context path for location ID (default: 'id' when parent is Location).
- */
-function locationContactDetailsConditions(locationIdContextPath = 'id') {
-    return [
-        {
-            name: 'locationId',
-            operator: { type: 'equal' },
-            value: `{{context.eval("${locationIdContextPath}")}}`,
-        },
-    ];
-}
-/**
- * CRUD actions for LocationContact when shown as related entity of Location.
- * Injects locationId from context.eval("id").
- */
-function locationContactDetailsCrudActions() {
-    return entityDetailsCrudActions('locationId');
-}
-
 // Entity Types
 
 class AXMLocationManagementService {