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

package/fesm2022/acorex-modules-measurement-core.mjs

@@ -1,53 +1,10 @@
 import * as i0 from '@angular/core';
 import { Injectable, inject, NgModule } from '@angular/core';
 import { AXP_MODULE_MANIFEST_PROVIDER } from '@acorex/platform/core';
-import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
-import { createEntityCommandOptions, AXPSearchCommandProvider, AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER } from '@acorex/platform/common';
+import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER, entityMasterCrudActions, entityMasterRecordActions, entityDetailsCrudActions, entityDetailsSimpleCondition } from '@acorex/platform/layout/entity';
+import { createEntityCommandOptions, AXPSearchCommandProvider, AXP_MENU_PROVIDER, AXP_SEARCH_PROVIDER, createAllQueryView } from '@acorex/platform/common';
 import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
-import { AXPCommonMenuKeys } from '@acorex/modules/common';
-import { createAllQueryView, entityMasterCrudActions, entityMasterRecordActions, AXPWidgetsList, entityDetailsCrudActions, entityDetailsSimpleCondition } from '@acorex/platform/contracts';
-
-const AXMMeasurementCoreMenuKeys = {
-    Root: 'measurement-core',
-    QuantityTypes: 'measurement-core.quantity-types',
-    UnitsOfMeasure: 'measurement-core.units-of-measure',
-    UnitConversions: 'measurement-core.unit-conversions',
-    MeasurementDimensions: 'measurement-core.measurement-dimensions',
-    SizingProfiles: 'measurement-core.sizing-profiles',
-};
-
-const AXMMeasurementCorePermissionKeys = {
-    MeasurementCore: {
-        Group: 'MeasurementCore:Permission:Group',
-        QuantityType: {
-            Management: 'MeasurementCore:Permission:QuantityType.Management',
-        },
-        UnitOfMeasure: {
-            Management: 'MeasurementCore:Permission:UnitOfMeasure.Management',
-        },
-        UnitConversion: {
-            Management: 'MeasurementCore:Permission:UnitConversion.Management',
-        },
-        MeasurementDimension: {
-            Management: 'MeasurementCore:Permission:MeasurementDimension.Management',
-        },
-        MeasurementRange: {
-            Management: 'MeasurementCore:Permission:MeasurementRange.Management',
-        },
-        SizingProfile: {
-            Management: 'MeasurementCore:Permission:SizingProfile.Management',
-        },
-        SizingDimensionUsage: {
-            Management: 'MeasurementCore:Permission:SizingDimensionUsage.Management',
-        },
-        SizeItem: {
-            Management: 'MeasurementCore:Permission:SizeItem.Management',
-        },
-        SizeRule: {
-            Management: 'MeasurementCore:Permission:SizeRule.Management',
-        },
-    },
-};
+import { AXPCommonMenuKeys, AXPWidgetsList } from '@acorex/modules/common';
 
 const config = {
     i18n: 'measurement-core',
@@ -118,9 +75,6 @@ const RootConfig = {
     },
 };
 
-//#region ---- Contracts barrel ----
-//#endregion
-
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Manifest Definition   ----
@@ -138,6 +92,39 @@ const MeasurementCoreManifest = {
 };
 //#endregion
 
+const AXMMeasurementCorePermissionKeys = {
+    MeasurementCore: {
+        Group: 'MeasurementCore:Permission:Group',
+        QuantityType: {
+            Management: 'MeasurementCore:Permission:QuantityType.Management',
+        },
+        UnitOfMeasure: {
+            Management: 'MeasurementCore:Permission:UnitOfMeasure.Management',
+        },
+        UnitConversion: {
+            Management: 'MeasurementCore:Permission:UnitConversion.Management',
+        },
+        MeasurementDimension: {
+            Management: 'MeasurementCore:Permission:MeasurementDimension.Management',
+        },
+        MeasurementRange: {
+            Management: 'MeasurementCore:Permission:MeasurementRange.Management',
+        },
+        SizingProfile: {
+            Management: 'MeasurementCore:Permission:SizingProfile.Management',
+        },
+        SizingDimensionUsage: {
+            Management: 'MeasurementCore:Permission:SizingDimensionUsage.Management',
+        },
+        SizeItem: {
+            Management: 'MeasurementCore:Permission:SizeItem.Management',
+        },
+        SizeRule: {
+            Management: 'MeasurementCore:Permission:SizeRule.Management',
+        },
+    },
+};
+
 //#endregion
 //#region ----   Permission Definition Provider   ----
 const PERM_QT = '@measurement-core:quantity-types.permissions.quantity-type';
@@ -182,6 +169,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
             type: Injectable
         }] });
 
+const AXMMeasurementCoreMenuKeys = {
+    Root: 'measurement-core',
+    QuantityTypes: 'measurement-core.quantity-types',
+    UnitsOfMeasure: 'measurement-core.units-of-measure',
+    UnitConversions: 'measurement-core.unit-conversions',
+    MeasurementDimensions: 'measurement-core.measurement-dimensions',
+    SizingProfiles: 'measurement-core.sizing-profiles',
+};
+
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Menu Provider   ----
@@ -256,23 +252,23 @@ class AXMMeasurementCoreEntityProvider {
         }
         switch (entityName) {
             case RootConfig.entities.quantityType.name:
-                return (await Promise.resolve().then(function () { return index$6; })).quantityTypeFactory();
+                return (await Promise.resolve().then(function () { return quantityType_entity; })).quantityTypeFactory();
             case RootConfig.entities.unitOfMeasure.name:
-                return (await Promise.resolve().then(function () { return index; })).unitOfMeasureFactory();
+                return (await Promise.resolve().then(function () { return unitOfMeasure_entity; })).unitOfMeasureFactory();
             case RootConfig.entities.unitConversion.name:
-                return (await Promise.resolve().then(function () { return index$1; })).unitConversionFactory();
+                return (await Promise.resolve().then(function () { return unitConversion_entity; })).unitConversionFactory();
             case RootConfig.entities.measurementDimension.name:
-                return (await Promise.resolve().then(function () { return index$8; })).measurementDimensionFactory();
+                return (await Promise.resolve().then(function () { return measurementDimension_entity; })).measurementDimensionFactory();
             case RootConfig.entities.measurementRange.name:
-                return (await Promise.resolve().then(function () { return index$7; })).measurementRangeFactory();
+                return (await Promise.resolve().then(function () { return measurementRange_entity; })).measurementRangeFactory();
             case RootConfig.entities.sizingProfile.name:
-                return (await Promise.resolve().then(function () { return index$2; })).sizingProfileFactory();
+                return (await Promise.resolve().then(function () { return sizingProfile_entity; })).sizingProfileFactory();
             case RootConfig.entities.sizingDimensionUsage.name:
-                return (await Promise.resolve().then(function () { return index$3; })).sizingDimensionUsageFactory();
+                return (await Promise.resolve().then(function () { return sizingDimensionUsage_entity; })).sizingDimensionUsageFactory();
             case RootConfig.entities.sizeItem.name:
-                return (await Promise.resolve().then(function () { return index$5; })).sizeItemFactory();
+                return (await Promise.resolve().then(function () { return sizeItem_entity; })).sizeItemFactory();
             case RootConfig.entities.sizeRule.name:
-                return (await Promise.resolve().then(function () { return index$4; })).sizeRuleFactory();
+                return (await Promise.resolve().then(function () { return sizeRule_entity; })).sizeRuleFactory();
         }
         return null;
     }
@@ -395,9 +391,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+//#region ----   Quantity Type Model   ----
+//#endregion
+
+//#region ----   Imports   ----
 //#endregion
 //#region ----   Entity Factory   ----
-async function measurementDimensionFactory() {
+async function quantityTypeFactory() {
     const sections = [
         { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
     ];
@@ -405,35 +405,24 @@ async function measurementDimensionFactory() {
         { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 1 } } } },
         { name: 'title', layout: { positions: { lg: { colSpan: 8, order: 2 } } } },
         { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-        { name: 'quantityTypeId', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
-        { name: 'defaultUomId', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+        { name: 'baseUomId', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
     ];
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.measurementDimension.name,
-        title: RootConfig.entities.measurementDimension.title,
-        icon: RootConfig.entities.measurementDimension.icon,
+        name: RootConfig.entities.quantityType.name,
+        title: RootConfig.entities.quantityType.title,
+        icon: RootConfig.entities.quantityType.icon,
         formats: {
-            individual: RootConfig.entities.measurementDimension.title,
-            plural: RootConfig.entities.measurementDimension.titlePlural,
+            individual: RootConfig.entities.quantityType.title,
+            plural: RootConfig.entities.quantityType.titlePlural,
             searchResult: {
                 title: '{{ title }}',
                 description: '{{ code }}',
             },
         },
         plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'disable' }],
-        relatedEntities: [
-            {
-                entity: `${RootConfig.module.name}.${RootConfig.entities.measurementRange.name}`,
-                title: RootConfig.entities.measurementRange.titlePlural,
-                icon: RootConfig.entities.measurementRange.icon,
-                columns: ['code', 'title', 'min', 'max', 'target'],
-                conditions: [entityDetailsSimpleCondition('measurementDimensionId')],
-                actions: [...entityDetailsCrudActions('measurementDimensionId')],
-            },
-        ],
         groups: [
-            { id: 'basic-info', title: '@measurement-core:dimensions.entities.measurement-dimension.groups.basic-info' },
+            { id: 'basic-info', title: '@measurement-core:quantity-types.entities.quantity-type.groups.basic-info' },
         ],
         properties: [
             {
@@ -463,7 +452,7 @@ async function measurementDimensionFactory() {
                     interface: {
                         type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            placeholder: '@measurement-core:dimensions.entities.measurement-dimension.fields.code.placeholder',
+                            placeholder: '@measurement-core:quantity-types.entities.quantity-type.fields.code.placeholder',
                         },
                     },
                 },
@@ -485,7 +474,7 @@ async function measurementDimensionFactory() {
                     interface: {
                         type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            placeholder: '@measurement-core:dimensions.entities.measurement-dimension.fields.title.placeholder',
+                            placeholder: '@measurement-core:quantity-types.entities.quantity-type.fields.title.placeholder',
                         },
                     },
                 },
@@ -501,41 +490,14 @@ async function measurementDimensionFactory() {
                         type: AXPWidgetsList.Editors.LargeTextBox,
                         options: {
                             rows: 3,
-                            placeholder: '@measurement-core:dimensions.entities.measurement-dimension.fields.description.placeholder',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'quantityTypeId',
-                title: '@measurement-core:dimensions.entities.measurement-dimension.fields.quantity-type.title',
-                groupId: 'basic-info',
-                options: {
-                    sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.quantityType.name}`,
-                            expose: [
-                                { source: 'id', target: 'quantityTypeId' },
-                                { source: 'title', target: 'quantityType.title' },
-                                { source: 'code', target: 'quantityType.code' },
-                            ],
+                            placeholder: '@measurement-core:quantity-types.entities.quantity-type.fields.description.placeholder',
                         },
                     },
                 },
-                validations: [{ rule: 'required' }],
             },
             {
-                name: 'defaultUomId',
-                title: '@measurement-core:dimensions.entities.measurement-dimension.fields.default-uom.title',
+                name: 'baseUomId',
+                title: '@measurement-core:quantity-types.entities.quantity-type.fields.base-unit.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -551,9 +513,9 @@ async function measurementDimensionFactory() {
                         options: {
                             entity: `${RootConfig.module.name}.${RootConfig.entities.unitOfMeasure.name}`,
                             expose: [
-                                { source: 'id', target: 'defaultUomId' },
-                                { source: 'title', target: 'defaultUom.title' },
-                                { source: 'symbol', target: 'defaultUom.symbol' },
+                                { source: 'id', target: 'baseUomId' },
+                                { source: 'title', target: 'baseUnit.title' },
+                                { source: 'symbol', target: 'baseUnit.symbol' },
                             ],
                         },
                     },
@@ -563,8 +525,8 @@ async function measurementDimensionFactory() {
         columns: [
             { name: 'code', options: { width: '120px', order: 1 } },
             { name: 'title', options: { width: '220px', order: 2 } },
-            { name: 'quantityTypeId', options: { width: '160px', dataPath: 'quantityType.title', order: 3 } },
-            { name: 'defaultUomId', options: { width: '120px', dataPath: 'defaultUom.title', order: 4 } },
+            { name: 'description', options: { width: '220px', order: 3 } },
+            { name: 'baseUomId', options: { width: '150px', dataPath: 'baseUnit.title', order: 4 } },
         ],
         interfaces: {
             master: {
@@ -597,52 +559,49 @@ async function measurementDimensionFactory() {
 }
 //#endregion
 
-//#endregion
-
-var index$8 = /*#__PURE__*/Object.freeze({
+var quantityType_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    measurementDimensionFactory: measurementDimensionFactory
+    quantityTypeFactory: quantityTypeFactory
 });
 
+//#region ----   Unit of Measure Model   ----
+//#endregion
+
+//#region ----   Imports   ----
 //#endregion
 //#region ----   Entity Factory   ----
-async function measurementRangeFactory() {
+async function unitOfMeasureFactory() {
     const sections = [
         { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
-        { id: 'range-config', layout: { positions: { lg: { colSpan: 12 } } } },
+        { id: 'configuration', layout: { positions: { lg: { colSpan: 12 } } } },
     ];
     const propertyLayouts = [
-        { name: 'measurementDimensionId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-        { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 2 } } } },
-        { name: 'title', layout: { positions: { lg: { colSpan: 8, order: 3 } } } },
+        { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 1 } } } },
+        { name: 'title', layout: { positions: { lg: { colSpan: 5, order: 2 } } } },
+        { name: 'symbol', layout: { positions: { lg: { colSpan: 3, order: 3 } } } },
         { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
-        { name: 'uomId', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
-        { name: 'min', layout: { positions: { lg: { colSpan: 4, order: 6 } } } },
-        { name: 'max', layout: { positions: { lg: { colSpan: 4, order: 7 } } } },
-        { name: 'target', layout: { positions: { lg: { colSpan: 4, order: 8 } } } },
-        { name: 'rangeType', layout: { positions: { lg: { colSpan: 4, order: 9 } } } },
-        { name: 'boundType', layout: { positions: { lg: { colSpan: 4, order: 10 } } } },
-        { name: 'step', layout: { positions: { lg: { colSpan: 3, order: 11 } } } },
-        { name: 'priority', layout: { positions: { lg: { colSpan: 3, order: 12 } } } },
-        { name: 'isReusable', layout: { positions: { lg: { colSpan: 3, order: 13 } } } },
+        { name: 'quantityTypeId', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+        { name: 'factorToBase', layout: { positions: { lg: { colSpan: 3, order: 6 } } } },
+        { name: 'precision', layout: { positions: { lg: { colSpan: 3, order: 7 } } } },
+        { name: 'isBase', layout: { positions: { lg: { colSpan: 3, order: 8 } } } },
     ];
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.measurementRange.name,
-        title: RootConfig.entities.measurementRange.title,
-        icon: RootConfig.entities.measurementRange.icon,
+        name: RootConfig.entities.unitOfMeasure.name,
+        title: RootConfig.entities.unitOfMeasure.title,
+        icon: RootConfig.entities.unitOfMeasure.icon,
         formats: {
-            individual: RootConfig.entities.measurementRange.title,
-            plural: RootConfig.entities.measurementRange.titlePlural,
+            individual: RootConfig.entities.unitOfMeasure.title,
+            plural: RootConfig.entities.unitOfMeasure.titlePlural,
             searchResult: {
-                title: '{{ title || code }}',
-                description: '{{ measurementDimension.title }}',
+                title: '{{ title }}',
+                description: '{{ context.eval("code") + " (" + context.eval("symbol") + ")" }}',
             },
         },
         plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'disable' }],
         groups: [
-            { id: 'basic-info', title: '@measurement-core:ranges.entities.measurement-range.groups.basic-info' },
-            { id: 'range-config', title: '@measurement-core:ranges.entities.measurement-range.groups.range-config' },
+            { id: 'basic-info', title: '@measurement-core:units.entities.unit-of-measure.groups.basic-info' },
+            { id: 'configuration', title: '@measurement-core:units.entities.unit-of-measure.groups.configuration' },
         ],
         properties: [
             {
@@ -657,8 +616,8 @@ async function measurementRangeFactory() {
                 },
             },
             {
-                name: 'measurementDimensionId',
-                title: '@measurement-core:ranges.entities.measurement-range.fields.measurement-dimension.title',
+                name: 'code',
+                title: '@general:terms.common.code',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -670,51 +629,51 @@ async function measurementRangeFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
+                        type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.measurementDimension.name}`,
-                            expose: [
-                                { source: 'id', target: 'measurementDimensionId' },
-                                { source: 'title', target: 'measurementDimension.title' },
-                                { source: 'code', target: 'measurementDimension.code' },
-                            ],
+                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.code.placeholder',
                         },
                     },
                 },
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'code',
-                title: '@general:terms.common.code',
+                name: 'title',
+                title: '@general:terms.common.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.code.placeholder',
+                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.title.placeholder',
                         },
                     },
                 },
+                validations: [{ rule: 'required' }],
             },
             {
-                name: 'title',
-                title: '@general:terms.common.title',
+                name: 'symbol',
+                title: '@measurement-core:units.entities.unit-of-measure.fields.symbol.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                    filter: { advance: { enabled: true } },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.title.placeholder',
+                            maxLength: 10,
+                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.symbol.placeholder',
                         },
                     },
                 },
@@ -728,30 +687,34 @@ async function measurementRangeFactory() {
                     interface: {
                         type: AXPWidgetsList.Editors.LargeTextBox,
                         options: {
-                            rows: 2,
-                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.description.placeholder',
+                            rows: 3,
+                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.description.placeholder',
                         },
                     },
                 },
             },
             {
-                name: 'uomId',
-                title: '@measurement-core:ranges.entities.measurement-range.fields.unit.title',
-                groupId: 'range-config',
+                name: 'quantityTypeId',
+                title: '@measurement-core:units.entities.unit-of-measure.fields.quantity-type.title',
+                groupId: 'configuration',
                 options: {
                     sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.unitOfMeasure.name}`,
+                            look: 'select',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.quantityType.name}`,
                             expose: [
-                                { source: 'id', target: 'uomId' },
-                                { source: 'title', target: 'unit.title' },
-                                { source: 'symbol', target: 'unit.symbol' },
+                                { source: 'id', target: 'quantityTypeId' },
+                                { source: 'code', target: 'quantityType.code' },
+                                { source: 'title', target: 'quantityType.title' },
                             ],
                         },
                     },
@@ -759,126 +722,39 @@ async function measurementRangeFactory() {
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'min',
-                title: '@measurement-core:ranges.entities.measurement-range.fields.min.title',
-                groupId: 'range-config',
-                schema: {
-                    dataType: 'number',
-                    interface: {
-                        type: AXPWidgetsList.Editors.NumberBox,
-                        options: {
-                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.min.placeholder',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'max',
-                title: '@measurement-core:ranges.entities.measurement-range.fields.max.title',
-                groupId: 'range-config',
-                schema: {
-                    dataType: 'number',
-                    interface: {
-                        type: AXPWidgetsList.Editors.NumberBox,
-                        options: {
-                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.max.placeholder',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'target',
-                title: '@measurement-core:ranges.entities.measurement-range.fields.target.title',
-                groupId: 'range-config',
+                name: 'factorToBase',
+                title: '@measurement-core:units.entities.unit-of-measure.fields.factor-to-base.title',
+                groupId: 'configuration',
                 schema: {
                     dataType: 'number',
                     interface: {
                         type: AXPWidgetsList.Editors.NumberBox,
                         options: {
-                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.target.placeholder',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'rangeType',
-                title: '@measurement-core:ranges.entities.measurement-range.fields.range-type.title',
-                groupId: 'range-config',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.SelectBox,
-                        options: {
-                            valueField: 'value',
-                            textField: 'text',
-                            dataSource: [
-                                { value: 'acceptable', text: '@measurement-core:ranges.entities.measurement-range.fields.range-type.options.acceptable' },
-                                { value: 'preferred', text: '@measurement-core:ranges.entities.measurement-range.fields.range-type.options.preferred' },
-                                { value: 'tolerance', text: '@measurement-core:ranges.entities.measurement-range.fields.range-type.options.tolerance' },
-                                { value: 'ideal', text: '@measurement-core:ranges.entities.measurement-range.fields.range-type.options.ideal' },
-                            ],
-                        },
-                    },
-                },
-            },
-            {
-                name: 'boundType',
-                title: '@measurement-core:ranges.entities.measurement-range.fields.bound-type.title',
-                groupId: 'range-config',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.SelectBox,
-                        options: {
-                            valueField: 'value',
-                            textField: 'text',
-                            dataSource: [
-                                { value: 'closed', text: '@measurement-core:ranges.entities.measurement-range.fields.bound-type.options.closed' },
-                                { value: 'open', text: '@measurement-core:ranges.entities.measurement-range.fields.bound-type.options.open' },
-                                { value: 'leftClosed', text: '@measurement-core:ranges.entities.measurement-range.fields.bound-type.options.left-closed' },
-                                { value: 'rightClosed', text: '@measurement-core:ranges.entities.measurement-range.fields.bound-type.options.right-closed' },
-                            ],
+                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.factor-to-base.placeholder',
                         },
                     },
                 },
             },
             {
-                name: 'step',
-                title: '@measurement-core:ranges.entities.measurement-range.fields.step.title',
-                groupId: 'range-config',
+                name: 'precision',
+                title: '@measurement-core:units.entities.unit-of-measure.fields.precision.title',
+                groupId: 'configuration',
                 schema: {
                     dataType: 'number',
                     interface: {
                         type: AXPWidgetsList.Editors.NumberBox,
                         options: {
                             minValue: 0,
-                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.step.placeholder',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'priority',
-                title: '@measurement-core:ranges.entities.measurement-range.fields.priority.title',
-                groupId: 'range-config',
-                schema: {
-                    dataType: 'number',
-                    interface: {
-                        type: AXPWidgetsList.Editors.NumberBox,
-                        options: {
-                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.priority.placeholder',
+                            maxValue: 10,
+                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.precision.placeholder',
                         },
                     },
                 },
             },
             {
-                name: 'isReusable',
-                title: '@measurement-core:ranges.entities.measurement-range.fields.is-reusable.title',
-                groupId: 'range-config',
+                name: 'isBase',
+                title: '@measurement-core:units.entities.unit-of-measure.fields.is-base.title',
+                groupId: 'configuration',
                 schema: {
                     dataType: 'boolean',
                     interface: {
@@ -892,13 +768,11 @@ async function measurementRangeFactory() {
             },
         ],
         columns: [
-            { name: 'measurementDimensionId', options: { width: '180px', dataPath: 'measurementDimension.title', order: 1 } },
-            { name: 'code', options: { width: '120px', order: 2 } },
-            { name: 'title', options: { width: '160px', order: 3 } },
-            { name: 'min', options: { width: '90px', order: 4 } },
-            { name: 'max', options: { width: '90px', order: 5 } },
-            { name: 'target', options: { width: '90px', order: 6 } },
-            { name: 'rangeType', options: { width: '120px', order: 7 } },
+            { name: 'code', options: { width: '120px', order: 1 } },
+            { name: 'title', options: { width: '220px', order: 2 } },
+            { name: 'symbol', options: { width: '100px', order: 3 } },
+            { name: 'quantityTypeId', options: { width: '180px', order: 4 } },
+            { name: 'isBase', options: { width: '100px', order: 5 } },
         ],
         interfaces: {
             master: {
@@ -911,7 +785,7 @@ async function measurementRangeFactory() {
                     properties: propertyLayouts,
                 },
                 single: {
-                    title: '{{ title || code }}',
+                    title: '{{ title }}',
                     sections,
                     properties: propertyLayouts,
                     actions: [...entityMasterRecordActions()],
@@ -920,7 +794,7 @@ async function measurementRangeFactory() {
                     actions: [...entityMasterCrudActions()],
                     views: [
                         createAllQueryView({
-                            sorts: [{ name: 'measurementDimensionId', dir: 'asc' }, { name: 'priority', dir: 'asc' }],
+                            sorts: [{ name: 'code', dir: 'asc' }],
                         }),
                     ],
                 },
@@ -931,41 +805,45 @@ async function measurementRangeFactory() {
 }
 //#endregion
 
-//#endregion
-
-var index$7 = /*#__PURE__*/Object.freeze({
+var unitOfMeasure_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    measurementRangeFactory: measurementRangeFactory
+    unitOfMeasureFactory: unitOfMeasureFactory
 });
 
+//#region ----   Imports   ----
 //#endregion
 //#region ----   Entity Factory   ----
-async function quantityTypeFactory() {
+async function unitConversionFactory() {
     const sections = [
         { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
+        { id: 'conversion', layout: { positions: { lg: { colSpan: 12 } } } },
     ];
     const propertyLayouts = [
         { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 1 } } } },
-        { name: 'title', layout: { positions: { lg: { colSpan: 8, order: 2 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-        { name: 'baseUomId', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
+        { name: 'title', layout: { positions: { lg: { colSpan: 4, order: 2 } } } },
+        { name: 'description', layout: { positions: { lg: { colSpan: 8, order: 3 } } } },
+        { name: 'fromUomId', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
+        { name: 'toUomId', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+        { name: 'factor', layout: { positions: { lg: { colSpan: 4, order: 6 } } } },
+        { name: 'operator', layout: { positions: { lg: { colSpan: 4, order: 7 } } } },
     ];
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.quantityType.name,
-        title: RootConfig.entities.quantityType.title,
-        icon: RootConfig.entities.quantityType.icon,
+        name: RootConfig.entities.unitConversion.name,
+        title: RootConfig.entities.unitConversion.title,
+        icon: RootConfig.entities.unitConversion.icon,
         formats: {
-            individual: RootConfig.entities.quantityType.title,
-            plural: RootConfig.entities.quantityType.titlePlural,
+            individual: '{{ title || (fromUnit?.symbol + " → " + toUnit?.symbol) }}',
+            plural: RootConfig.entities.unitConversion.titlePlural,
             searchResult: {
-                title: '{{ title }}',
+                title: '{{ title || (fromUnit?.symbol + " → " + toUnit?.symbol) }}',
                 description: '{{ code }}',
             },
         },
         plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'disable' }],
         groups: [
-            { id: 'basic-info', title: '@measurement-core:quantity-types.entities.quantity-type.groups.basic-info' },
+            { id: 'basic-info', title: '@measurement-core:conversions.entities.unit-conversion.groups.basic-info' },
+            { id: 'conversion', title: '@measurement-core:conversions.entities.unit-conversion.groups.conversion' },
         ],
         properties: [
             {
@@ -985,21 +863,17 @@ async function quantityTypeFactory() {
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            placeholder: '@measurement-core:quantity-types.entities.quantity-type.fields.code.placeholder',
+                            placeholder: '@measurement-core:conversions.entities.unit-conversion.fields.code.placeholder',
                         },
                     },
                 },
-                validations: [{ rule: 'required' }],
             },
             {
                 name: 'title',
@@ -1007,21 +881,17 @@ async function quantityTypeFactory() {
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            placeholder: '@measurement-core:quantity-types.entities.quantity-type.fields.title.placeholder',
+                            placeholder: '@measurement-core:conversions.entities.unit-conversion.fields.title.placeholder',
                         },
                     },
                 },
-                validations: [{ rule: 'required' }],
             },
             {
                 name: 'description',
@@ -1032,22 +902,19 @@ async function quantityTypeFactory() {
                     interface: {
                         type: AXPWidgetsList.Editors.LargeTextBox,
                         options: {
-                            rows: 3,
-                            placeholder: '@measurement-core:quantity-types.entities.quantity-type.fields.description.placeholder',
+                            rows: 2,
+                            placeholder: '@measurement-core:conversions.entities.unit-conversion.fields.description.placeholder',
                         },
                     },
                 },
             },
             {
-                name: 'baseUomId',
-                title: '@measurement-core:quantity-types.entities.quantity-type.fields.base-unit.title',
-                groupId: 'basic-info',
+                name: 'fromUomId',
+                title: '@measurement-core:conversions.entities.unit-conversion.fields.from-unit.title',
+                groupId: 'conversion',
                 options: {
                     sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
                 },
                 schema: {
                     dataType: 'string',
@@ -1056,41 +923,96 @@ async function quantityTypeFactory() {
                         options: {
                             entity: `${RootConfig.module.name}.${RootConfig.entities.unitOfMeasure.name}`,
                             expose: [
-                                { source: 'id', target: 'baseUomId' },
-                                { source: 'title', target: 'baseUnit.title' },
-                                { source: 'symbol', target: 'baseUnit.symbol' },
+                                { source: 'id', target: 'fromUomId' },
+                                { source: 'title', target: 'fromUnit.title' },
+                                { source: 'symbol', target: 'fromUnit.symbol' },
                             ],
                         },
                     },
                 },
+                validations: [{ rule: 'required' }],
             },
-        ],
-        columns: [
-            { name: 'code', options: { width: '120px', order: 1 } },
-            { name: 'title', options: { width: '220px', order: 2 } },
-            { name: 'description', options: { width: '220px', order: 3 } },
-            { name: 'baseUomId', options: { width: '150px', dataPath: 'baseUnit.title', order: 4 } },
-        ],
-        interfaces: {
-            master: {
-                create: {
-                    sections,
-                    properties: propertyLayouts,
-                },
-                update: {
-                    sections,
-                    properties: propertyLayouts,
+            {
+                name: 'toUomId',
+                title: '@measurement-core:conversions.entities.unit-conversion.fields.to-unit.title',
+                groupId: 'conversion',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
                 },
-                single: {
-                    title: '{{ title }}',
-                    sections,
-                    properties: propertyLayouts,
-                    actions: [...entityMasterRecordActions()],
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.LookupBox,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.unitOfMeasure.name}`,
+                            expose: [
+                                { source: 'id', target: 'toUomId' },
+                                { source: 'title', target: 'toUnit.title' },
+                                { source: 'symbol', target: 'toUnit.symbol' },
+                            ],
+                        },
+                    },
                 },
-                list: {
-                    actions: [...entityMasterCrudActions()],
-                    views: [
-                        createAllQueryView({
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'factor',
+                title: '@measurement-core:conversions.entities.unit-conversion.fields.factor.title',
+                groupId: 'conversion',
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsList.Editors.NumberBox,
+                        options: {
+                            placeholder: '@measurement-core:conversions.entities.unit-conversion.fields.factor.placeholder',
+                        },
+                    },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'operator',
+                title: '@measurement-core:conversions.entities.unit-conversion.fields.operator.title',
+                groupId: 'conversion',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.SelectBox,
+                        options: {
+                            valueField: 'value',
+                            textField: 'text',
+                            dataSource: [
+                                { value: 'multiply', text: '@measurement-core:conversions.entities.unit-conversion.fields.operator.options.multiply' },
+                                { value: 'divide', text: '@measurement-core:conversions.entities.unit-conversion.fields.operator.options.divide' },
+                            ],
+                        },
+                    },
+                },
+            },
+        ],
+        columns: [
+            { name: 'code', options: { width: '120px', order: 1 } },
+            { name: 'title', options: { width: '140px', order: 2 } },
+            { name: 'fromUomId', options: { width: '120px', dataPath: 'fromUnit.symbol', order: 3 } },
+            { name: 'toUomId', options: { width: '120px', dataPath: 'toUnit.symbol', order: 4 } },
+            { name: 'factor', options: { width: '100px', order: 5 } },
+            { name: 'operator', options: { width: '100px', order: 6 } },
+        ],
+        interfaces: {
+            master: {
+                create: { sections, properties: propertyLayouts },
+                update: { sections, properties: propertyLayouts },
+                single: {
+                    title: '{{ context.eval("fromUnit.symbol") + " → " + context.eval("toUnit.symbol") }}',
+                    sections,
+                    properties: propertyLayouts,
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [...entityMasterCrudActions()],
+                    views: [
+                        createAllQueryView({
                             sorts: [{ name: 'code', dir: 'asc' }],
                         }),
                     ],
@@ -1102,41 +1024,54 @@ async function quantityTypeFactory() {
 }
 //#endregion
 
-//#endregion
-
-var index$6 = /*#__PURE__*/Object.freeze({
+var unitConversion_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    quantityTypeFactory: quantityTypeFactory
+    unitConversionFactory: unitConversionFactory
 });
 
+//#region ----   Unit Conversion Model   ----
+//#endregion
+
+//#region ----   Imports   ----
 //#endregion
 //#region ----   Entity Factory   ----
-async function sizeItemFactory() {
+async function measurementDimensionFactory() {
     const sections = [
         { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
     ];
     const propertyLayouts = [
-        { name: 'sizeChartId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-        { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 2 } } } },
-        { name: 'title', layout: { positions: { lg: { colSpan: 8, order: 3 } } } },
-        { name: 'sortOrder', layout: { positions: { lg: { colSpan: 4, order: 4 } } } },
+        { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 1 } } } },
+        { name: 'title', layout: { positions: { lg: { colSpan: 8, order: 2 } } } },
+        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+        { name: 'quantityTypeId', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
+        { name: 'defaultUomId', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
     ];
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.sizeItem.name,
-        title: RootConfig.entities.sizeItem.title,
-        icon: RootConfig.entities.sizeItem.icon,
+        name: RootConfig.entities.measurementDimension.name,
+        title: RootConfig.entities.measurementDimension.title,
+        icon: RootConfig.entities.measurementDimension.icon,
         formats: {
-            individual: RootConfig.entities.sizeItem.title,
-            plural: RootConfig.entities.sizeItem.titlePlural,
+            individual: RootConfig.entities.measurementDimension.title,
+            plural: RootConfig.entities.measurementDimension.titlePlural,
             searchResult: {
-                title: '{{ title || code }}',
-                description: '{{ sizeChart.title }}',
+                title: '{{ title }}',
+                description: '{{ code }}',
             },
         },
         plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'disable' }],
+        relatedEntities: [
+            {
+                entity: `${RootConfig.module.name}.${RootConfig.entities.measurementRange.name}`,
+                title: RootConfig.entities.measurementRange.titlePlural,
+                icon: RootConfig.entities.measurementRange.icon,
+                columns: ['code', 'title', 'min', 'max', 'target'],
+                conditions: [entityDetailsSimpleCondition('measurementDimensionId')],
+                actions: [...entityDetailsCrudActions('measurementDimensionId')],
+            },
+        ],
         groups: [
-            { id: 'basic-info', title: '@measurement-core:sizes.entities.size-item.groups.basic-info' },
+            { id: 'basic-info', title: '@measurement-core:dimensions.entities.measurement-dimension.groups.basic-info' },
         ],
         properties: [
             {
@@ -1151,8 +1086,8 @@ async function sizeItemFactory() {
                 },
             },
             {
-                name: 'sizeChartId',
-                title: '@measurement-core:sizes.entities.size-item.fields.sizing-profile.title',
+                name: 'code',
+                title: '@general:terms.common.code',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -1164,22 +1099,17 @@ async function sizeItemFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
+                        type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.sizingProfile.name}`,
-                            expose: [
-                                { source: 'id', target: 'sizeChartId' },
-                                { source: 'title', target: 'sizeChart.title' },
-                                { source: 'code', target: 'sizeChart.code' },
-                            ],
+                            placeholder: '@measurement-core:dimensions.entities.measurement-dimension.fields.code.placeholder',
                         },
                     },
                 },
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'code',
-                title: '@general:terms.common.code',
+                name: 'title',
+                title: '@general:terms.common.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -1193,15 +1123,30 @@ async function sizeItemFactory() {
                     interface: {
                         type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            placeholder: '@measurement-core:sizes.entities.size-item.fields.code.placeholder',
+                            placeholder: '@measurement-core:dimensions.entities.measurement-dimension.fields.title.placeholder',
                         },
                     },
                 },
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'title',
-                title: '@general:terms.common.title',
+                name: 'description',
+                title: '@general:terms.common.description',
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.LargeTextBox,
+                        options: {
+                            rows: 3,
+                            placeholder: '@measurement-core:dimensions.entities.measurement-dimension.fields.description.placeholder',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'quantityTypeId',
+                title: '@measurement-core:dimensions.entities.measurement-dimension.fields.quantity-type.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -1213,38 +1158,51 @@ async function sizeItemFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
+                        type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            placeholder: '@measurement-core:sizes.entities.size-item.fields.title.placeholder',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.quantityType.name}`,
+                            expose: [
+                                { source: 'id', target: 'quantityTypeId' },
+                                { source: 'title', target: 'quantityType.title' },
+                                { source: 'code', target: 'quantityType.code' },
+                            ],
                         },
                     },
                 },
+                validations: [{ rule: 'required' }],
             },
             {
-                name: 'sortOrder',
-                title: '@measurement-core:sizes.entities.size-item.fields.sort-order.title',
+                name: 'defaultUomId',
+                title: '@measurement-core:dimensions.entities.measurement-dimension.fields.default-uom.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
-                    filter: { advance: { enabled: true } },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
                 },
                 schema: {
-                    dataType: 'number',
+                    dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.NumberBox,
+                        type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            minValue: 0,
-                            placeholder: '@measurement-core:sizes.entities.size-item.fields.sort-order.placeholder',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.unitOfMeasure.name}`,
+                            expose: [
+                                { source: 'id', target: 'defaultUomId' },
+                                { source: 'title', target: 'defaultUom.title' },
+                                { source: 'symbol', target: 'defaultUom.symbol' },
+                            ],
                         },
                     },
                 },
             },
         ],
         columns: [
-            { name: 'sizeChartId', options: { width: '180px', dataPath: 'sizeChart.title', order: 1 } },
-            { name: 'code', options: { width: '100px', order: 2 } },
-            { name: 'title', options: { width: '200px', order: 3 } },
-            { name: 'sortOrder', options: { width: '100px', order: 4 } },
+            { name: 'code', options: { width: '120px', order: 1 } },
+            { name: 'title', options: { width: '220px', order: 2 } },
+            { name: 'quantityTypeId', options: { width: '160px', dataPath: 'quantityType.title', order: 3 } },
+            { name: 'defaultUomId', options: { width: '120px', dataPath: 'defaultUom.title', order: 4 } },
         ],
         interfaces: {
             master: {
@@ -1257,7 +1215,7 @@ async function sizeItemFactory() {
                     properties: propertyLayouts,
                 },
                 single: {
-                    title: '{{ title || code }}',
+                    title: '{{ title }}',
                     sections,
                     properties: propertyLayouts,
                     actions: [...entityMasterRecordActions()],
@@ -1266,11 +1224,7 @@ async function sizeItemFactory() {
                     actions: [...entityMasterCrudActions()],
                     views: [
                         createAllQueryView({
-                            sorts: [
-                                { name: 'sizeChartId', dir: 'asc' },
-                                { name: 'sortOrder', dir: 'asc' },
-                                { name: 'code', dir: 'asc' },
-                            ],
+                            sorts: [{ name: 'code', dir: 'asc' }],
                         }),
                     ],
                 },
@@ -1281,43 +1235,54 @@ async function sizeItemFactory() {
 }
 //#endregion
 
-//#endregion
-
-var index$5 = /*#__PURE__*/Object.freeze({
+var measurementDimension_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    sizeItemFactory: sizeItemFactory
+    measurementDimensionFactory: measurementDimensionFactory
 });
 
+//#region ----   Measurement Dimension Model   ----
+//#endregion
+
+//#region ----   Imports   ----
 //#endregion
 //#region ----   Entity Factory   ----
-async function sizeRuleFactory() {
+async function measurementRangeFactory() {
     const sections = [
         { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
+        { id: 'range-config', layout: { positions: { lg: { colSpan: 12 } } } },
     ];
     const propertyLayouts = [
-        { name: 'sizeChartId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-        { name: 'sizeItemId', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-        { name: 'measurementDimensionId', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-        { name: 'measurementRangeId', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
-        { name: 'matchBehavior', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
-        { name: 'priority', layout: { positions: { lg: { colSpan: 6, order: 6 } } } },
+        { name: 'measurementDimensionId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
+        { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 2 } } } },
+        { name: 'title', layout: { positions: { lg: { colSpan: 8, order: 3 } } } },
+        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
+        { name: 'uomId', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+        { name: 'min', layout: { positions: { lg: { colSpan: 4, order: 6 } } } },
+        { name: 'max', layout: { positions: { lg: { colSpan: 4, order: 7 } } } },
+        { name: 'target', layout: { positions: { lg: { colSpan: 4, order: 8 } } } },
+        { name: 'rangeType', layout: { positions: { lg: { colSpan: 4, order: 9 } } } },
+        { name: 'boundType', layout: { positions: { lg: { colSpan: 4, order: 10 } } } },
+        { name: 'step', layout: { positions: { lg: { colSpan: 3, order: 11 } } } },
+        { name: 'priority', layout: { positions: { lg: { colSpan: 3, order: 12 } } } },
+        { name: 'isReusable', layout: { positions: { lg: { colSpan: 3, order: 13 } } } },
     ];
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.sizeRule.name,
-        title: RootConfig.entities.sizeRule.title,
-        icon: RootConfig.entities.sizeRule.icon,
+        name: RootConfig.entities.measurementRange.name,
+        title: RootConfig.entities.measurementRange.title,
+        icon: RootConfig.entities.measurementRange.icon,
         formats: {
-            individual: RootConfig.entities.sizeRule.title,
-            plural: RootConfig.entities.sizeRule.titlePlural,
+            individual: RootConfig.entities.measurementRange.title,
+            plural: RootConfig.entities.measurementRange.titlePlural,
             searchResult: {
-                title: '{{ context.eval("sizeItem.code") + " / " + context.eval("measurementDimension.title", { pipes: ["translate"] }) }}',
-                description: '{{ measurementRange.title || measurementRange.code }}',
+                title: '{{ title || code }}',
+                description: '{{ measurementDimension.title }}',
             },
         },
-        plugins: [{ name: 'history' }, { name: 'compare' }],
+        plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'disable' }],
         groups: [
-            { id: 'basic-info', title: '@measurement-core:sizes.entities.size-rule.groups.basic-info' },
+            { id: 'basic-info', title: '@measurement-core:ranges.entities.measurement-range.groups.basic-info' },
+            { id: 'range-config', title: '@measurement-core:ranges.entities.measurement-range.groups.range-config' },
         ],
         properties: [
             {
@@ -1332,8 +1297,8 @@ async function sizeRuleFactory() {
                 },
             },
             {
-                name: 'sizeChartId',
-                title: '@measurement-core:sizes.entities.size-rule.fields.sizing-profile.title',
+                name: 'measurementDimensionId',
+                title: '@measurement-core:ranges.entities.measurement-range.fields.measurement-dimension.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -1347,11 +1312,11 @@ async function sizeRuleFactory() {
                     interface: {
                         type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.sizingProfile.name}`,
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.measurementDimension.name}`,
                             expose: [
-                                { source: 'id', target: 'sizeChartId' },
-                                { source: 'title', target: 'sizeChart.title' },
-                                { source: 'code', target: 'sizeChart.code' },
+                                { source: 'id', target: 'measurementDimensionId' },
+                                { source: 'title', target: 'measurementDimension.title' },
+                                { source: 'code', target: 'measurementDimension.code' },
                             ],
                         },
                     },
@@ -1359,67 +1324,74 @@ async function sizeRuleFactory() {
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'sizeItemId',
-                title: '@measurement-core:sizes.entities.size-rule.fields.size-item.title',
+                name: 'code',
+                title: '@general:terms.common.code',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
+                        type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.sizeItem.name}`,
-                            expose: [
-                                { source: 'id', target: 'sizeItemId' },
-                                { source: 'code', target: 'sizeItem.code' },
-                                { source: 'title', target: 'sizeItem.title' },
-                            ],
-                            conditions: [
-                                {
-                                    name: 'sizeChartId',
-                                    operator: { type: 'equal' },
-                                    value: '{{context.eval("sizeChartId")}}',
-                                },
-                            ],
+                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.code.placeholder',
                         },
                     },
                 },
-                validations: [{ rule: 'required' }],
             },
             {
-                name: 'measurementDimensionId',
-                title: '@measurement-core:sizes.entities.size-rule.fields.measurement-dimension.title',
+                name: 'title',
+                title: '@general:terms.common.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.TextBox,
+                        options: {
+                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.title.placeholder',
+                        },
                     },
                 },
+            },
+            {
+                name: 'description',
+                title: '@general:terms.common.description',
+                groupId: 'basic-info',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.LargeTextBox,
+                        options: {
+                            rows: 2,
+                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.description.placeholder',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'uomId',
+                title: '@measurement-core:ranges.entities.measurement-range.fields.unit.title',
+                groupId: 'range-config',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.measurementDimension.name}`,
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.unitOfMeasure.name}`,
                             expose: [
-                                { source: 'id', target: 'measurementDimensionId' },
-                                { source: 'title', target: 'measurementDimension.title' },
-                                { source: 'code', target: 'measurementDimension.code' },
-                            ],
-                            conditions: [
-                                {
-                                    name: 'sizeChartId',
-                                    operator: { type: 'equal' },
-                                    value: '{{context.eval("sizeChartId")}}',
-                                },
+                                { source: 'id', target: 'uomId' },
+                                { source: 'title', target: 'unit.title' },
+                                { source: 'symbol', target: 'unit.symbol' },
                             ],
                         },
                     },
@@ -1427,43 +1399,76 @@ async function sizeRuleFactory() {
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'measurementRangeId',
-                title: '@measurement-core:sizes.entities.size-rule.fields.measurement-range.title',
-                groupId: 'basic-info',
+                name: 'min',
+                title: '@measurement-core:ranges.entities.measurement-range.fields.min.title',
+                groupId: 'range-config',
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsList.Editors.NumberBox,
+                        options: {
+                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.min.placeholder',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'max',
+                title: '@measurement-core:ranges.entities.measurement-range.fields.max.title',
+                groupId: 'range-config',
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsList.Editors.NumberBox,
+                        options: {
+                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.max.placeholder',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'target',
+                title: '@measurement-core:ranges.entities.measurement-range.fields.target.title',
+                groupId: 'range-config',
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsList.Editors.NumberBox,
+                        options: {
+                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.target.placeholder',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'rangeType',
+                title: '@measurement-core:ranges.entities.measurement-range.fields.range-type.title',
+                groupId: 'range-config',
                 options: {
                     sort: { enabled: true },
-                    filter: {
-                        advance: { enabled: true },
-                        inline: { enabled: true },
-                    },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
+                        type: AXPWidgetsList.Editors.SelectBox,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.measurementRange.name}`,
-                            expose: [
-                                { source: 'id', target: 'measurementRangeId' },
-                                { source: 'title', target: 'measurementRange.title' },
-                                { source: 'code', target: 'measurementRange.code' },
-                            ],
-                            conditions: [
-                                {
-                                    name: 'measurementDimensionId',
-                                    operator: { type: 'equal' },
-                                    value: '{{context.eval("measurementDimensionId")}}',
-                                },
+                            valueField: 'value',
+                            textField: 'text',
+                            dataSource: [
+                                { value: 'acceptable', text: '@measurement-core:ranges.entities.measurement-range.fields.range-type.options.acceptable' },
+                                { value: 'preferred', text: '@measurement-core:ranges.entities.measurement-range.fields.range-type.options.preferred' },
+                                { value: 'tolerance', text: '@measurement-core:ranges.entities.measurement-range.fields.range-type.options.tolerance' },
+                                { value: 'ideal', text: '@measurement-core:ranges.entities.measurement-range.fields.range-type.options.ideal' },
                             ],
                         },
                     },
                 },
-                validations: [{ rule: 'required' }],
             },
             {
-                name: 'matchBehavior',
-                title: '@measurement-core:sizes.entities.size-rule.fields.match-behavior.title',
-                groupId: 'basic-info',
+                name: 'boundType',
+                title: '@measurement-core:ranges.entities.measurement-range.fields.bound-type.title',
+                groupId: 'range-config',
                 schema: {
                     dataType: 'string',
                     interface: {
@@ -1472,36 +1477,68 @@ async function sizeRuleFactory() {
                             valueField: 'value',
                             textField: 'text',
                             dataSource: [
-                                { value: 'hard', text: '@measurement-core:sizes.entities.size-rule.fields.match-behavior.options.hard' },
-                                { value: 'soft', text: '@measurement-core:sizes.entities.size-rule.fields.match-behavior.options.soft' },
-                                { value: 'scoring', text: '@measurement-core:sizes.entities.size-rule.fields.match-behavior.options.scoring' },
+                                { value: 'closed', text: '@measurement-core:ranges.entities.measurement-range.fields.bound-type.options.closed' },
+                                { value: 'open', text: '@measurement-core:ranges.entities.measurement-range.fields.bound-type.options.open' },
+                                { value: 'leftClosed', text: '@measurement-core:ranges.entities.measurement-range.fields.bound-type.options.left-closed' },
+                                { value: 'rightClosed', text: '@measurement-core:ranges.entities.measurement-range.fields.bound-type.options.right-closed' },
                             ],
                         },
                     },
                 },
             },
+            {
+                name: 'step',
+                title: '@measurement-core:ranges.entities.measurement-range.fields.step.title',
+                groupId: 'range-config',
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsList.Editors.NumberBox,
+                        options: {
+                            minValue: 0,
+                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.step.placeholder',
+                        },
+                    },
+                },
+            },
             {
                 name: 'priority',
-                title: '@measurement-core:sizes.entities.size-rule.fields.priority.title',
-                groupId: 'basic-info',
+                title: '@measurement-core:ranges.entities.measurement-range.fields.priority.title',
+                groupId: 'range-config',
                 schema: {
                     dataType: 'number',
                     interface: {
                         type: AXPWidgetsList.Editors.NumberBox,
                         options: {
-                            placeholder: '@measurement-core:sizes.entities.size-rule.fields.priority.placeholder',
+                            placeholder: '@measurement-core:ranges.entities.measurement-range.fields.priority.placeholder',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'isReusable',
+                title: '@measurement-core:ranges.entities.measurement-range.fields.is-reusable.title',
+                groupId: 'range-config',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsList.Editors.ToggleSwitch,
+                        options: {
+                            trulyText: '@general:terms.common.yes-no.yes',
+                            falsyText: '@general:terms.common.yes-no.no',
                         },
                     },
                 },
             },
         ],
         columns: [
-            { name: 'sizeChartId', options: { width: '160px', dataPath: 'sizeChart.title', order: 1 } },
-            { name: 'sizeItemId', options: { width: '120px', dataPath: 'sizeItem.code', order: 2 } },
-            { name: 'measurementDimensionId', options: { width: '160px', dataPath: 'measurementDimension.title', order: 3 } },
-            { name: 'measurementRangeId', options: { width: '160px', dataPath: 'measurementRange.title', order: 4 } },
-            { name: 'matchBehavior', options: { width: '100px', order: 5 } },
-            { name: 'priority', options: { width: '90px', order: 6 } },
+            { name: 'measurementDimensionId', options: { width: '180px', dataPath: 'measurementDimension.title', order: 1 } },
+            { name: 'code', options: { width: '120px', order: 2 } },
+            { name: 'title', options: { width: '160px', order: 3 } },
+            { name: 'min', options: { width: '90px', order: 4 } },
+            { name: 'max', options: { width: '90px', order: 5 } },
+            { name: 'target', options: { width: '90px', order: 6 } },
+            { name: 'rangeType', options: { width: '120px', order: 7 } },
         ],
         interfaces: {
             master: {
@@ -1514,7 +1551,7 @@ async function sizeRuleFactory() {
                     properties: propertyLayouts,
                 },
                 single: {
-                    title: '{{ context.eval("sizeItem.code") + " / " + context.eval("measurementDimension.title", { pipes: ["translate"] }) }}',
+                    title: '{{ title || code }}',
                     sections,
                     properties: propertyLayouts,
                     actions: [...entityMasterRecordActions()],
@@ -1523,10 +1560,7 @@ async function sizeRuleFactory() {
                     actions: [...entityMasterCrudActions()],
                     views: [
                         createAllQueryView({
-                            sorts: [
-                                { name: 'sizeItemId', dir: 'asc' },
-                                { name: 'measurementDimensionId', dir: 'asc' },
-                            ],
+                            sorts: [{ name: 'measurementDimensionId', dir: 'asc' }, { name: 'priority', dir: 'asc' }],
                         }),
                     ],
                 },
@@ -1537,43 +1571,93 @@ async function sizeRuleFactory() {
 }
 //#endregion
 
-//#endregion
-
-var index$4 = /*#__PURE__*/Object.freeze({
+var measurementRange_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    sizeRuleFactory: sizeRuleFactory
+    measurementRangeFactory: measurementRangeFactory
 });
 
+//#region ----   Measurement Range Model   ----
+//#endregion
+
+//#region ----   Imports   ----
 //#endregion
 //#region ----   Entity Factory   ----
-async function sizingDimensionUsageFactory() {
+async function sizingProfileFactory() {
     const sections = [
         { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
+        { id: 'configuration', layout: { positions: { lg: { colSpan: 12 } } } },
     ];
     const propertyLayouts = [
-        { name: 'sizeChartId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
-        { name: 'measurementDimensionId', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
-        { name: 'required', layout: { positions: { lg: { colSpan: 4, order: 3 } } } },
-        { name: 'primary', layout: { positions: { lg: { colSpan: 4, order: 4 } } } },
-        { name: 'sortOrder', layout: { positions: { lg: { colSpan: 4, order: 5 } } } },
-        { name: 'priority', layout: { positions: { lg: { colSpan: 4, order: 6 } } } },
+        { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 1 } } } },
+        { name: 'title', layout: { positions: { lg: { colSpan: 8, order: 2 } } } },
+        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+        { name: 'regionId', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
+        { name: 'matchStrategy', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+        { name: 'enforceNoOverlap', layout: { positions: { lg: { colSpan: 6, order: 6 } } } },
     ];
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.sizingDimensionUsage.name,
-        title: RootConfig.entities.sizingDimensionUsage.title,
-        icon: RootConfig.entities.sizingDimensionUsage.icon,
+        name: RootConfig.entities.sizingProfile.name,
+        title: RootConfig.entities.sizingProfile.title,
+        icon: RootConfig.entities.sizingProfile.icon,
         formats: {
-            individual: RootConfig.entities.sizingDimensionUsage.title,
-            plural: RootConfig.entities.sizingDimensionUsage.titlePlural,
+            individual: RootConfig.entities.sizingProfile.title,
+            plural: RootConfig.entities.sizingProfile.titlePlural,
             searchResult: {
-                title: '{{ measurementDimension.title }}',
-                description: '{{ sizeChart.title }}',
+                title: '{{ title }}',
+                description: '{{ code }}',
             },
         },
-        plugins: [{ name: 'history' }, { name: 'compare' }],
+        plugins: [
+            { name: 'history' },
+            { name: 'compare' },
+            { name: 'disable' },
+            {
+                name: 'category',
+                options: {
+                    appearance: { icon: true, color: true },
+                    metaData: { enabled: true, title: 'Meta Data Configuration' },
+                },
+            },
+        ],
+        relatedEntities: [
+            {
+                entity: `${RootConfig.module.name}.${RootConfig.entities.sizeItem.name}`,
+                title: RootConfig.entities.sizeItem.titlePlural,
+                icon: RootConfig.entities.sizeItem.icon,
+                layout: {
+                    type: 'page-list',
+                },
+                columns: ['code', 'title', 'sortOrder'],
+                conditions: [entityDetailsSimpleCondition('sizeChartId')],
+                actions: [...entityDetailsCrudActions('sizeChartId')],
+            },
+            {
+                entity: `${RootConfig.module.name}.${RootConfig.entities.sizingDimensionUsage.name}`,
+                title: RootConfig.entities.sizingDimensionUsage.titlePlural,
+                icon: RootConfig.entities.sizingDimensionUsage.icon,
+                layout: {
+                    type: 'page-list',
+                },
+                columns: ['measurementDimensionId', 'required', 'primary', 'sortOrder'],
+                conditions: [entityDetailsSimpleCondition('sizeChartId')],
+                actions: [...entityDetailsCrudActions('sizeChartId')],
+            },
+            {
+                entity: `${RootConfig.module.name}.${RootConfig.entities.sizeRule.name}`,
+                title: RootConfig.entities.sizeRule.titlePlural,
+                icon: RootConfig.entities.sizeRule.icon,
+                layout: {
+                    type: 'page-list',
+                },
+                columns: ['sizeChartId', 'sizeItemId', 'measurementDimensionId', 'measurementRangeId', 'matchBehavior', 'priority'],
+                conditions: [entityDetailsSimpleCondition('sizeChartId')],
+                actions: [...entityDetailsCrudActions('sizeChartId')],
+            },
+        ],
         groups: [
-            { id: 'basic-info', title: '@measurement-core:sizes.entities.sizing-dimension-usage.groups.basic-info' },
+            { id: 'basic-info', title: '@measurement-core:sizes.entities.sizing-profile.groups.basic-info' },
+            { id: 'configuration', title: '@measurement-core:sizes.entities.sizing-profile.groups.configuration' },
         ],
         properties: [
             {
@@ -1588,8 +1672,8 @@ async function sizingDimensionUsageFactory() {
                 },
             },
             {
-                name: 'sizeChartId',
-                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.sizing-profile.title',
+                name: 'code',
+                title: '@general:terms.common.code',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -1601,22 +1685,18 @@ async function sizingDimensionUsageFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
+                        type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.sizingProfile.name}`,
-                            expose: [
-                                { source: 'id', target: 'sizeChartId' },
-                                { source: 'title', target: 'sizeChart.title' },
-                                { source: 'code', target: 'sizeChart.code' },
-                            ],
+                            placeholder: '@measurement-core:sizes.entities.sizing-profile.fields.code.placeholder',
                         },
                     },
+                    unique: { enabled: true },
                 },
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'measurementDimensionId',
-                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.measurement-dimension.title',
+                name: 'title',
+                title: '@general:terms.common.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -1628,85 +1708,94 @@ async function sizingDimensionUsageFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
+                        type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.measurementDimension.name}`,
-                            expose: [
-                                { source: 'id', target: 'measurementDimensionId' },
-                                { source: 'title', target: 'measurementDimension.title' },
-                                { source: 'code', target: 'measurementDimension.code' },
-                            ],
+                            placeholder: '@measurement-core:sizes.entities.sizing-profile.fields.title.placeholder',
                         },
                     },
                 },
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'required',
-                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.required.title',
+                name: 'description',
+                title: '@general:terms.common.description',
                 groupId: 'basic-info',
                 schema: {
-                    dataType: 'boolean',
+                    dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.ToggleSwitch,
+                        type: AXPWidgetsList.Editors.LargeTextBox,
                         options: {
-                            trulyText: '@general:terms.common.yes-no.yes',
-                            falsyText: '@general:terms.common.yes-no.no',
+                            rows: 3,
+                            placeholder: '@measurement-core:sizes.entities.sizing-profile.fields.description.placeholder',
                         },
                     },
                 },
             },
             {
-                name: 'primary',
-                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.primary.title',
-                groupId: 'basic-info',
+                name: 'regionId',
+                title: '@measurement-core:sizes.entities.sizing-profile.fields.region.title',
+                groupId: 'configuration',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
                 schema: {
-                    dataType: 'boolean',
+                    dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.ToggleSwitch,
+                        type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            trulyText: '@general:terms.common.yes-no.yes',
-                            falsyText: '@general:terms.common.yes-no.no',
+                            entity: 'LocationManagement.GeographicRegion',
+                            valueField: 'id',
+                            textField: 'title',
+                            columns: ['code', 'title'],
+                            expose: [
+                                { source: 'id', target: 'region.id' },
+                                { source: 'title', target: 'region.title' },
+                            ],
                         },
                     },
                 },
             },
             {
-                name: 'sortOrder',
-                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.sort-order.title',
-                groupId: 'basic-info',
+                name: 'matchStrategy',
+                title: '@measurement-core:sizes.entities.sizing-profile.fields.match-strategy.title',
+                groupId: 'configuration',
                 schema: {
-                    dataType: 'number',
+                    dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.NumberBox,
+                        type: AXPWidgetsList.Editors.SelectBox,
                         options: {
-                            minValue: 0,
-                            placeholder: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.sort-order.placeholder',
+                            valueField: 'value',
+                            textField: 'text',
+                            dataSource: [
+                                { value: 'primary-first', text: '@measurement-core:sizes.entities.sizing-profile.fields.match-strategy.options.primary-first' },
+                                { value: 'all-required', text: '@measurement-core:sizes.entities.sizing-profile.fields.match-strategy.options.all-required' },
+                            ],
                         },
                     },
                 },
             },
             {
-                name: 'priority',
-                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.priority.title',
-                groupId: 'basic-info',
+                name: 'enforceNoOverlap',
+                title: '@measurement-core:sizes.entities.sizing-profile.fields.enforce-no-overlap.title',
+                groupId: 'configuration',
                 schema: {
-                    dataType: 'number',
+                    dataType: 'boolean',
                     interface: {
-                        type: AXPWidgetsList.Editors.NumberBox,
+                        type: AXPWidgetsList.Editors.ToggleSwitch,
                         options: {
-                            placeholder: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.priority.placeholder',
+                            trulyText: '@general:terms.common.yes-no.yes',
+                            falsyText: '@general:terms.common.yes-no.no',
                         },
                     },
                 },
             },
         ],
         columns: [
-            { name: 'sizeChartId', options: { width: '180px', dataPath: 'sizeChart.title', order: 1 } },
-            { name: 'measurementDimensionId', options: { width: '200px', dataPath: 'measurementDimension.title', order: 2 } },
-            { name: 'required', options: { width: '90px', order: 3 } },
-            { name: 'primary', options: { width: '90px', order: 4 } },
-            { name: 'sortOrder', options: { width: '100px', order: 5 } },
+            { name: 'code', options: { width: '140px', order: 1 } },
+            { name: 'title', options: { width: '220px', order: 2 } },
+            { name: 'region', options: { width: '140px', order: 3 } },
+            { name: 'description', options: { width: '220px', order: 4 } },
         ],
         interfaces: {
             master: {
@@ -1719,7 +1808,7 @@ async function sizingDimensionUsageFactory() {
                     properties: propertyLayouts,
                 },
                 single: {
-                    title: '{{ measurementDimension.title }}',
+                    title: '{{ title }}',
                     sections,
                     properties: propertyLayouts,
                     actions: [...entityMasterRecordActions()],
@@ -1728,10 +1817,7 @@ async function sizingDimensionUsageFactory() {
                     actions: [...entityMasterCrudActions()],
                     views: [
                         createAllQueryView({
-                            sorts: [
-                                { name: 'sizeChartId', dir: 'asc' },
-                                { name: 'sortOrder', dir: 'asc' },
-                            ],
+                            sorts: [{ name: 'code', dir: 'asc' }],
                         }),
                     ],
                 },
@@ -1742,91 +1828,44 @@ async function sizingDimensionUsageFactory() {
 }
 //#endregion
 
-//#endregion
-
-var index$3 = /*#__PURE__*/Object.freeze({
+var sizingProfile_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    sizingDimensionUsageFactory: sizingDimensionUsageFactory
+    sizingProfileFactory: sizingProfileFactory
 });
 
+//#endregion
+
+//#region ----   Imports   ----
 //#endregion
 //#region ----   Entity Factory   ----
-async function sizingProfileFactory() {
+async function sizingDimensionUsageFactory() {
     const sections = [
         { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
-        { id: 'configuration', layout: { positions: { lg: { colSpan: 12 } } } },
     ];
     const propertyLayouts = [
-        { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 1 } } } },
-        { name: 'title', layout: { positions: { lg: { colSpan: 8, order: 2 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
-        { name: 'regionId', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
-        { name: 'matchStrategy', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
-        { name: 'enforceNoOverlap', layout: { positions: { lg: { colSpan: 6, order: 6 } } } },
+        { name: 'sizeChartId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
+        { name: 'measurementDimensionId', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+        { name: 'required', layout: { positions: { lg: { colSpan: 4, order: 3 } } } },
+        { name: 'primary', layout: { positions: { lg: { colSpan: 4, order: 4 } } } },
+        { name: 'sortOrder', layout: { positions: { lg: { colSpan: 4, order: 5 } } } },
+        { name: 'priority', layout: { positions: { lg: { colSpan: 4, order: 6 } } } },
     ];
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.sizingProfile.name,
-        title: RootConfig.entities.sizingProfile.title,
-        icon: RootConfig.entities.sizingProfile.icon,
+        name: RootConfig.entities.sizingDimensionUsage.name,
+        title: RootConfig.entities.sizingDimensionUsage.title,
+        icon: RootConfig.entities.sizingDimensionUsage.icon,
         formats: {
-            individual: RootConfig.entities.sizingProfile.title,
-            plural: RootConfig.entities.sizingProfile.titlePlural,
+            individual: RootConfig.entities.sizingDimensionUsage.title,
+            plural: RootConfig.entities.sizingDimensionUsage.titlePlural,
             searchResult: {
-                title: '{{ title }}',
-                description: '{{ code }}',
-            },
-        },
-        plugins: [
-            { name: 'history' },
-            { name: 'compare' },
-            { name: 'disable' },
-            {
-                name: 'category',
-                options: {
-                    appearance: { icon: true, color: true },
-                    metaData: { enabled: true, title: 'Meta Data Configuration' },
-                },
-            },
-        ],
-        relatedEntities: [
-            {
-                entity: `${RootConfig.module.name}.${RootConfig.entities.sizeItem.name}`,
-                title: RootConfig.entities.sizeItem.titlePlural,
-                icon: RootConfig.entities.sizeItem.icon,
-                layout: {
-                    type: 'page-list',
-                },
-                columns: ['code', 'title', 'sortOrder'],
-                conditions: [entityDetailsSimpleCondition('sizeChartId')],
-                actions: [...entityDetailsCrudActions('sizeChartId')],
-            },
-            {
-                entity: `${RootConfig.module.name}.${RootConfig.entities.sizingDimensionUsage.name}`,
-                title: RootConfig.entities.sizingDimensionUsage.titlePlural,
-                icon: RootConfig.entities.sizingDimensionUsage.icon,
-                layout: {
-                    type: 'page-list',
-                },
-                columns: ['measurementDimensionId', 'required', 'primary', 'sortOrder'],
-                conditions: [entityDetailsSimpleCondition('sizeChartId')],
-                actions: [...entityDetailsCrudActions('sizeChartId')],
-            },
-            {
-                entity: `${RootConfig.module.name}.${RootConfig.entities.sizeRule.name}`,
-                title: RootConfig.entities.sizeRule.titlePlural,
-                icon: RootConfig.entities.sizeRule.icon,
-                layout: {
-                    type: 'page-list',
-                },
-                columns: ['sizeChartId', 'sizeItemId', 'measurementDimensionId', 'measurementRangeId', 'matchBehavior', 'priority'],
-                conditions: [entityDetailsSimpleCondition('sizeChartId')],
-                actions: [...entityDetailsCrudActions('sizeChartId')],
+                title: '{{ measurementDimension.title }}',
+                description: '{{ sizeChart.title }}',
             },
-        ],
+        },
+        plugins: [{ name: 'history' }, { name: 'compare' }],
         groups: [
-            { id: 'basic-info', title: '@measurement-core:sizes.entities.sizing-profile.groups.basic-info' },
-            { id: 'configuration', title: '@measurement-core:sizes.entities.sizing-profile.groups.configuration' },
+            { id: 'basic-info', title: '@measurement-core:sizes.entities.sizing-dimension-usage.groups.basic-info' },
         ],
         properties: [
             {
@@ -1841,8 +1880,8 @@ async function sizingProfileFactory() {
                 },
             },
             {
-                name: 'code',
-                title: '@general:terms.common.code',
+                name: 'sizeChartId',
+                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.sizing-profile.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -1854,18 +1893,22 @@ async function sizingProfileFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
+                        type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            placeholder: '@measurement-core:sizes.entities.sizing-profile.fields.code.placeholder',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.sizingProfile.name}`,
+                            expose: [
+                                { source: 'id', target: 'sizeChartId' },
+                                { source: 'title', target: 'sizeChart.title' },
+                                { source: 'code', target: 'sizeChart.code' },
+                            ],
                         },
                     },
-                    unique: { enabled: true },
                 },
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'title',
-                title: '@general:terms.common.title',
+                name: 'measurementDimensionId',
+                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.measurement-dimension.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -1877,94 +1920,85 @@ async function sizingProfileFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
+                        type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            placeholder: '@measurement-core:sizes.entities.sizing-profile.fields.title.placeholder',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.measurementDimension.name}`,
+                            expose: [
+                                { source: 'id', target: 'measurementDimensionId' },
+                                { source: 'title', target: 'measurementDimension.title' },
+                                { source: 'code', target: 'measurementDimension.code' },
+                            ],
                         },
                     },
                 },
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'description',
-                title: '@general:terms.common.description',
+                name: 'required',
+                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.required.title',
                 groupId: 'basic-info',
                 schema: {
-                    dataType: 'string',
+                    dataType: 'boolean',
                     interface: {
-                        type: AXPWidgetsList.Editors.LargeTextBox,
+                        type: AXPWidgetsList.Editors.ToggleSwitch,
                         options: {
-                            rows: 3,
-                            placeholder: '@measurement-core:sizes.entities.sizing-profile.fields.description.placeholder',
+                            trulyText: '@general:terms.common.yes-no.yes',
+                            falsyText: '@general:terms.common.yes-no.no',
                         },
                     },
                 },
             },
             {
-                name: 'regionId',
-                title: '@measurement-core:sizes.entities.sizing-profile.fields.region.title',
-                groupId: 'configuration',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
+                name: 'primary',
+                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.primary.title',
+                groupId: 'basic-info',
                 schema: {
-                    dataType: 'string',
+                    dataType: 'boolean',
                     interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
+                        type: AXPWidgetsList.Editors.ToggleSwitch,
                         options: {
-                            entity: 'LocationManagement.GeographicRegion',
-                            valueField: 'id',
-                            textField: 'title',
-                            columns: ['code', 'title'],
-                            expose: [
-                                { source: 'id', target: 'region.id' },
-                                { source: 'title', target: 'region.title' },
-                            ],
+                            trulyText: '@general:terms.common.yes-no.yes',
+                            falsyText: '@general:terms.common.yes-no.no',
                         },
                     },
                 },
             },
             {
-                name: 'matchStrategy',
-                title: '@measurement-core:sizes.entities.sizing-profile.fields.match-strategy.title',
-                groupId: 'configuration',
+                name: 'sortOrder',
+                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.sort-order.title',
+                groupId: 'basic-info',
                 schema: {
-                    dataType: 'string',
+                    dataType: 'number',
                     interface: {
-                        type: AXPWidgetsList.Editors.SelectBox,
+                        type: AXPWidgetsList.Editors.NumberBox,
                         options: {
-                            valueField: 'value',
-                            textField: 'text',
-                            dataSource: [
-                                { value: 'primary-first', text: '@measurement-core:sizes.entities.sizing-profile.fields.match-strategy.options.primary-first' },
-                                { value: 'all-required', text: '@measurement-core:sizes.entities.sizing-profile.fields.match-strategy.options.all-required' },
-                            ],
+                            minValue: 0,
+                            placeholder: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.sort-order.placeholder',
                         },
                     },
                 },
             },
             {
-                name: 'enforceNoOverlap',
-                title: '@measurement-core:sizes.entities.sizing-profile.fields.enforce-no-overlap.title',
-                groupId: 'configuration',
+                name: 'priority',
+                title: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.priority.title',
+                groupId: 'basic-info',
                 schema: {
-                    dataType: 'boolean',
+                    dataType: 'number',
                     interface: {
-                        type: AXPWidgetsList.Editors.ToggleSwitch,
+                        type: AXPWidgetsList.Editors.NumberBox,
                         options: {
-                            trulyText: '@general:terms.common.yes-no.yes',
-                            falsyText: '@general:terms.common.yes-no.no',
+                            placeholder: '@measurement-core:sizes.entities.sizing-dimension-usage.fields.priority.placeholder',
                         },
                     },
                 },
             },
         ],
         columns: [
-            { name: 'code', options: { width: '140px', order: 1 } },
-            { name: 'title', options: { width: '220px', order: 2 } },
-            { name: 'region', options: { width: '140px', order: 3 } },
-            { name: 'description', options: { width: '220px', order: 4 } },
+            { name: 'sizeChartId', options: { width: '180px', dataPath: 'sizeChart.title', order: 1 } },
+            { name: 'measurementDimensionId', options: { width: '200px', dataPath: 'measurementDimension.title', order: 2 } },
+            { name: 'required', options: { width: '90px', order: 3 } },
+            { name: 'primary', options: { width: '90px', order: 4 } },
+            { name: 'sortOrder', options: { width: '100px', order: 5 } },
         ],
         interfaces: {
             master: {
@@ -1977,7 +2011,7 @@ async function sizingProfileFactory() {
                     properties: propertyLayouts,
                 },
                 single: {
-                    title: '{{ title }}',
+                    title: '{{ measurementDimension.title }}',
                     sections,
                     properties: propertyLayouts,
                     actions: [...entityMasterRecordActions()],
@@ -1986,7 +2020,10 @@ async function sizingProfileFactory() {
                     actions: [...entityMasterCrudActions()],
                     views: [
                         createAllQueryView({
-                            sorts: [{ name: 'code', dir: 'asc' }],
+                            sorts: [
+                                { name: 'sizeChartId', dir: 'asc' },
+                                { name: 'sortOrder', dir: 'asc' },
+                            ],
                         }),
                     ],
                 },
@@ -1997,46 +2034,43 @@ async function sizingProfileFactory() {
 }
 //#endregion
 
-//#endregion
-
-var index$2 = /*#__PURE__*/Object.freeze({
+var sizingDimensionUsage_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    sizingProfileFactory: sizingProfileFactory
+    sizingDimensionUsageFactory: sizingDimensionUsageFactory
 });
 
+//#region ----   Sizing Dimension Usage Model   ----
+//#endregion
+
+//#region ----   Imports   ----
 //#endregion
 //#region ----   Entity Factory   ----
-async function unitConversionFactory() {
+async function sizeItemFactory() {
     const sections = [
         { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
-        { id: 'conversion', layout: { positions: { lg: { colSpan: 12 } } } },
     ];
     const propertyLayouts = [
-        { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 1 } } } },
-        { name: 'title', layout: { positions: { lg: { colSpan: 4, order: 2 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 8, order: 3 } } } },
-        { name: 'fromUomId', layout: { positions: { lg: { colSpan: 6, order: 4 } } } },
-        { name: 'toUomId', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
-        { name: 'factor', layout: { positions: { lg: { colSpan: 4, order: 6 } } } },
-        { name: 'operator', layout: { positions: { lg: { colSpan: 4, order: 7 } } } },
+        { name: 'sizeChartId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
+        { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 2 } } } },
+        { name: 'title', layout: { positions: { lg: { colSpan: 8, order: 3 } } } },
+        { name: 'sortOrder', layout: { positions: { lg: { colSpan: 4, order: 4 } } } },
     ];
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.unitConversion.name,
-        title: RootConfig.entities.unitConversion.title,
-        icon: RootConfig.entities.unitConversion.icon,
+        name: RootConfig.entities.sizeItem.name,
+        title: RootConfig.entities.sizeItem.title,
+        icon: RootConfig.entities.sizeItem.icon,
         formats: {
-            individual: '{{ title || (fromUnit?.symbol + " → " + toUnit?.symbol) }}',
-            plural: RootConfig.entities.unitConversion.titlePlural,
+            individual: RootConfig.entities.sizeItem.title,
+            plural: RootConfig.entities.sizeItem.titlePlural,
             searchResult: {
-                title: '{{ title || (fromUnit?.symbol + " → " + toUnit?.symbol) }}',
-                description: '{{ code }}',
+                title: '{{ title || code }}',
+                description: '{{ sizeChart.title }}',
             },
         },
         plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'disable' }],
         groups: [
-            { id: 'basic-info', title: '@measurement-core:conversions.entities.unit-conversion.groups.basic-info' },
-            { id: 'conversion', title: '@measurement-core:conversions.entities.unit-conversion.groups.conversion' },
+            { id: 'basic-info', title: '@measurement-core:sizes.entities.size-item.groups.basic-info' },
         ],
         properties: [
             {
@@ -2051,153 +2085,113 @@ async function unitConversionFactory() {
                 },
             },
             {
-                name: 'code',
-                title: '@general:terms.common.code',
+                name: 'sizeChartId',
+                title: '@measurement-core:sizes.entities.size-item.fields.sizing-profile.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
+                        type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            placeholder: '@measurement-core:conversions.entities.unit-conversion.fields.code.placeholder',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.sizingProfile.name}`,
+                            expose: [
+                                { source: 'id', target: 'sizeChartId' },
+                                { source: 'title', target: 'sizeChart.title' },
+                                { source: 'code', target: 'sizeChart.code' },
+                            ],
                         },
                     },
                 },
+                validations: [{ rule: 'required' }],
             },
             {
-                name: 'title',
-                title: '@general:terms.common.title',
+                name: 'code',
+                title: '@general:terms.common.code',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
+                    },
                 },
                 schema: {
                     dataType: 'string',
                     interface: {
                         type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            placeholder: '@measurement-core:conversions.entities.unit-conversion.fields.title.placeholder',
+                            placeholder: '@measurement-core:sizes.entities.size-item.fields.code.placeholder',
                         },
                     },
                 },
+                validations: [{ rule: 'required' }],
             },
             {
-                name: 'description',
-                title: '@general:terms.common.description',
+                name: 'title',
+                title: '@general:terms.common.title',
                 groupId: 'basic-info',
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LargeTextBox,
-                        options: {
-                            rows: 2,
-                            placeholder: '@measurement-core:conversions.entities.unit-conversion.fields.description.placeholder',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'fromUomId',
-                title: '@measurement-core:conversions.entities.unit-conversion.fields.from-unit.title',
-                groupId: 'conversion',
                 options: {
                     sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.unitOfMeasure.name}`,
-                            expose: [
-                                { source: 'id', target: 'fromUomId' },
-                                { source: 'title', target: 'fromUnit.title' },
-                                { source: 'symbol', target: 'fromUnit.symbol' },
-                            ],
-                        },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
                     },
                 },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'toUomId',
-                title: '@measurement-core:conversions.entities.unit-conversion.fields.to-unit.title',
-                groupId: 'conversion',
-                options: {
-                    sort: { enabled: true },
-                    filter: { advance: { enabled: true }, inline: { enabled: true } },
-                },
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.LookupBox,
-                        options: {
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.unitOfMeasure.name}`,
-                            expose: [
-                                { source: 'id', target: 'toUomId' },
-                                { source: 'title', target: 'toUnit.title' },
-                                { source: 'symbol', target: 'toUnit.symbol' },
-                            ],
-                        },
-                    },
-                },
-                validations: [{ rule: 'required' }],
-            },
-            {
-                name: 'factor',
-                title: '@measurement-core:conversions.entities.unit-conversion.fields.factor.title',
-                groupId: 'conversion',
-                schema: {
-                    dataType: 'number',
-                    interface: {
-                        type: AXPWidgetsList.Editors.NumberBox,
+                        type: AXPWidgetsList.Editors.TextBox,
                         options: {
-                            placeholder: '@measurement-core:conversions.entities.unit-conversion.fields.factor.placeholder',
+                            placeholder: '@measurement-core:sizes.entities.size-item.fields.title.placeholder',
                         },
                     },
                 },
-                validations: [{ rule: 'required' }],
             },
             {
-                name: 'operator',
-                title: '@measurement-core:conversions.entities.unit-conversion.fields.operator.title',
-                groupId: 'conversion',
+                name: 'sortOrder',
+                title: '@measurement-core:sizes.entities.size-item.fields.sort-order.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true } },
+                },
                 schema: {
-                    dataType: 'string',
+                    dataType: 'number',
                     interface: {
-                        type: AXPWidgetsList.Editors.SelectBox,
+                        type: AXPWidgetsList.Editors.NumberBox,
                         options: {
-                            valueField: 'value',
-                            textField: 'text',
-                            dataSource: [
-                                { value: 'multiply', text: '@measurement-core:conversions.entities.unit-conversion.fields.operator.options.multiply' },
-                                { value: 'divide', text: '@measurement-core:conversions.entities.unit-conversion.fields.operator.options.divide' },
-                            ],
+                            minValue: 0,
+                            placeholder: '@measurement-core:sizes.entities.size-item.fields.sort-order.placeholder',
                         },
                     },
                 },
             },
         ],
         columns: [
-            { name: 'code', options: { width: '120px', order: 1 } },
-            { name: 'title', options: { width: '140px', order: 2 } },
-            { name: 'fromUomId', options: { width: '120px', dataPath: 'fromUnit.symbol', order: 3 } },
-            { name: 'toUomId', options: { width: '120px', dataPath: 'toUnit.symbol', order: 4 } },
-            { name: 'factor', options: { width: '100px', order: 5 } },
-            { name: 'operator', options: { width: '100px', order: 6 } },
+            { name: 'sizeChartId', options: { width: '180px', dataPath: 'sizeChart.title', order: 1 } },
+            { name: 'code', options: { width: '100px', order: 2 } },
+            { name: 'title', options: { width: '200px', order: 3 } },
+            { name: 'sortOrder', options: { width: '100px', order: 4 } },
         ],
         interfaces: {
             master: {
-                create: { sections, properties: propertyLayouts },
-                update: { sections, properties: propertyLayouts },
+                create: {
+                    sections,
+                    properties: propertyLayouts,
+                },
+                update: {
+                    sections,
+                    properties: propertyLayouts,
+                },
                 single: {
-                    title: '{{ context.eval("fromUnit.symbol") + " → " + context.eval("toUnit.symbol") }}',
+                    title: '{{ title || code }}',
                     sections,
                     properties: propertyLayouts,
                     actions: [...entityMasterRecordActions()],
@@ -2206,7 +2200,11 @@ async function unitConversionFactory() {
                     actions: [...entityMasterCrudActions()],
                     views: [
                         createAllQueryView({
-                            sorts: [{ name: 'code', dir: 'asc' }],
+                            sorts: [
+                                { name: 'sizeChartId', dir: 'asc' },
+                                { name: 'sortOrder', dir: 'asc' },
+                                { name: 'code', dir: 'asc' },
+                            ],
                         }),
                     ],
                 },
@@ -2217,47 +2215,45 @@ async function unitConversionFactory() {
 }
 //#endregion
 
-//#endregion
-
-var index$1 = /*#__PURE__*/Object.freeze({
+var sizeItem_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    unitConversionFactory: unitConversionFactory
+    sizeItemFactory: sizeItemFactory
 });
 
+//#region ----   Size Item Model   ----
+//#endregion
+
+//#region ----   Imports   ----
 //#endregion
 //#region ----   Entity Factory   ----
-async function unitOfMeasureFactory() {
+async function sizeRuleFactory() {
     const sections = [
         { id: 'basic-info', layout: { positions: { lg: { colSpan: 12 } } } },
-        { id: 'configuration', layout: { positions: { lg: { colSpan: 12 } } } },
     ];
     const propertyLayouts = [
-        { name: 'code', layout: { positions: { lg: { colSpan: 4, order: 1 } } } },
-        { name: 'title', layout: { positions: { lg: { colSpan: 5, order: 2 } } } },
-        { name: 'symbol', layout: { positions: { lg: { colSpan: 3, order: 3 } } } },
-        { name: 'description', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
-        { name: 'quantityTypeId', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
-        { name: 'factorToBase', layout: { positions: { lg: { colSpan: 3, order: 6 } } } },
-        { name: 'precision', layout: { positions: { lg: { colSpan: 3, order: 7 } } } },
-        { name: 'isBase', layout: { positions: { lg: { colSpan: 3, order: 8 } } } },
+        { name: 'sizeChartId', layout: { positions: { lg: { colSpan: 12, order: 1 } } } },
+        { name: 'sizeItemId', layout: { positions: { lg: { colSpan: 12, order: 2 } } } },
+        { name: 'measurementDimensionId', layout: { positions: { lg: { colSpan: 12, order: 3 } } } },
+        { name: 'measurementRangeId', layout: { positions: { lg: { colSpan: 12, order: 4 } } } },
+        { name: 'matchBehavior', layout: { positions: { lg: { colSpan: 6, order: 5 } } } },
+        { name: 'priority', layout: { positions: { lg: { colSpan: 6, order: 6 } } } },
     ];
     const entityDef = {
         module: RootConfig.module.name,
-        name: RootConfig.entities.unitOfMeasure.name,
-        title: RootConfig.entities.unitOfMeasure.title,
-        icon: RootConfig.entities.unitOfMeasure.icon,
+        name: RootConfig.entities.sizeRule.name,
+        title: RootConfig.entities.sizeRule.title,
+        icon: RootConfig.entities.sizeRule.icon,
         formats: {
-            individual: RootConfig.entities.unitOfMeasure.title,
-            plural: RootConfig.entities.unitOfMeasure.titlePlural,
+            individual: RootConfig.entities.sizeRule.title,
+            plural: RootConfig.entities.sizeRule.titlePlural,
             searchResult: {
-                title: '{{ title }}',
-                description: '{{ context.eval("code") + " (" + context.eval("symbol") + ")" }}',
+                title: '{{ context.eval("sizeItem.code") + " / " + context.eval("measurementDimension.title") }}',
+                description: '{{ measurementRange.title || measurementRange.code }}',
             },
         },
-        plugins: [{ name: 'history' }, { name: 'compare' }, { name: 'disable' }],
+        plugins: [{ name: 'history' }, { name: 'compare' }],
         groups: [
-            { id: 'basic-info', title: '@measurement-core:units.entities.unit-of-measure.groups.basic-info' },
-            { id: 'configuration', title: '@measurement-core:units.entities.unit-of-measure.groups.configuration' },
+            { id: 'basic-info', title: '@measurement-core:sizes.entities.size-rule.groups.basic-info' },
         ],
         properties: [
             {
@@ -2272,8 +2268,8 @@ async function unitOfMeasureFactory() {
                 },
             },
             {
-                name: 'code',
-                title: '@general:terms.common.code',
+                name: 'sizeChartId',
+                title: '@measurement-core:sizes.entities.size-rule.fields.sizing-profile.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -2285,17 +2281,22 @@ async function unitOfMeasureFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
+                        type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.code.placeholder',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.sizingProfile.name}`,
+                            expose: [
+                                { source: 'id', target: 'sizeChartId' },
+                                { source: 'title', target: 'sizeChart.title' },
+                                { source: 'code', target: 'sizeChart.code' },
+                            ],
                         },
                     },
                 },
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'title',
-                title: '@general:terms.common.title',
+                name: 'sizeItemId',
+                title: '@measurement-core:sizes.entities.size-rule.fields.size-item.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
@@ -2307,52 +2308,64 @@ async function unitOfMeasureFactory() {
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
+                        type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.title.placeholder',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.sizeItem.name}`,
+                            expose: [
+                                { source: 'id', target: 'sizeItemId' },
+                                { source: 'code', target: 'sizeItem.code' },
+                                { source: 'title', target: 'sizeItem.title' },
+                            ],
+                            conditions: [
+                                {
+                                    name: 'sizeChartId',
+                                    operator: { type: 'equal' },
+                                    value: '{{context.eval("sizeChartId")}}',
+                                },
+                            ],
                         },
                     },
                 },
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'symbol',
-                title: '@measurement-core:units.entities.unit-of-measure.fields.symbol.title',
+                name: 'measurementDimensionId',
+                title: '@measurement-core:sizes.entities.size-rule.fields.measurement-dimension.title',
                 groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
-                    filter: { advance: { enabled: true } },
-                },
-                schema: {
-                    dataType: 'string',
-                    interface: {
-                        type: AXPWidgetsList.Editors.TextBox,
-                        options: {
-                            maxLength: 10,
-                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.symbol.placeholder',
-                        },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true },
                     },
                 },
-            },
-            {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'basic-info',
                 schema: {
                     dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.LargeTextBox,
+                        type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            rows: 3,
-                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.description.placeholder',
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.measurementDimension.name}`,
+                            expose: [
+                                { source: 'id', target: 'measurementDimensionId' },
+                                { source: 'title', target: 'measurementDimension.title' },
+                                { source: 'code', target: 'measurementDimension.code' },
+                            ],
+                            conditions: [
+                                {
+                                    name: 'sizeChartId',
+                                    operator: { type: 'equal' },
+                                    value: '{{context.eval("sizeChartId")}}',
+                                },
+                            ],
                         },
                     },
                 },
+                validations: [{ rule: 'required' }],
             },
             {
-                name: 'quantityTypeId',
-                title: '@measurement-core:units.entities.unit-of-measure.fields.quantity-type.title',
-                groupId: 'configuration',
+                name: 'measurementRangeId',
+                title: '@measurement-core:sizes.entities.size-rule.fields.measurement-range.title',
+                groupId: 'basic-info',
                 options: {
                     sort: { enabled: true },
                     filter: {
@@ -2365,12 +2378,18 @@ async function unitOfMeasureFactory() {
                     interface: {
                         type: AXPWidgetsList.Editors.LookupBox,
                         options: {
-                            look: 'select',
-                            entity: `${RootConfig.module.name}.${RootConfig.entities.quantityType.name}`,
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.measurementRange.name}`,
                             expose: [
-                                { source: 'id', target: 'quantityTypeId' },
-                                { source: 'code', target: 'quantityType.code' },
-                                { source: 'title', target: 'quantityType.title' },
+                                { source: 'id', target: 'measurementRangeId' },
+                                { source: 'title', target: 'measurementRange.title' },
+                                { source: 'code', target: 'measurementRange.code' },
+                            ],
+                            conditions: [
+                                {
+                                    name: 'measurementDimensionId',
+                                    operator: { type: 'equal' },
+                                    value: '{{context.eval("measurementDimensionId")}}',
+                                },
                             ],
                         },
                     },
@@ -2378,57 +2397,47 @@ async function unitOfMeasureFactory() {
                 validations: [{ rule: 'required' }],
             },
             {
-                name: 'factorToBase',
-                title: '@measurement-core:units.entities.unit-of-measure.fields.factor-to-base.title',
-                groupId: 'configuration',
+                name: 'matchBehavior',
+                title: '@measurement-core:sizes.entities.size-rule.fields.match-behavior.title',
+                groupId: 'basic-info',
                 schema: {
-                    dataType: 'number',
+                    dataType: 'string',
                     interface: {
-                        type: AXPWidgetsList.Editors.NumberBox,
+                        type: AXPWidgetsList.Editors.SelectBox,
                         options: {
-                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.factor-to-base.placeholder',
+                            valueField: 'value',
+                            textField: 'text',
+                            dataSource: [
+                                { value: 'hard', text: '@measurement-core:sizes.entities.size-rule.fields.match-behavior.options.hard' },
+                                { value: 'soft', text: '@measurement-core:sizes.entities.size-rule.fields.match-behavior.options.soft' },
+                                { value: 'scoring', text: '@measurement-core:sizes.entities.size-rule.fields.match-behavior.options.scoring' },
+                            ],
                         },
                     },
                 },
             },
             {
-                name: 'precision',
-                title: '@measurement-core:units.entities.unit-of-measure.fields.precision.title',
-                groupId: 'configuration',
+                name: 'priority',
+                title: '@measurement-core:sizes.entities.size-rule.fields.priority.title',
+                groupId: 'basic-info',
                 schema: {
                     dataType: 'number',
                     interface: {
                         type: AXPWidgetsList.Editors.NumberBox,
                         options: {
-                            minValue: 0,
-                            maxValue: 10,
-                            placeholder: '@measurement-core:units.entities.unit-of-measure.fields.precision.placeholder',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'isBase',
-                title: '@measurement-core:units.entities.unit-of-measure.fields.is-base.title',
-                groupId: 'configuration',
-                schema: {
-                    dataType: 'boolean',
-                    interface: {
-                        type: AXPWidgetsList.Editors.ToggleSwitch,
-                        options: {
-                            trulyText: '@general:terms.common.yes-no.yes',
-                            falsyText: '@general:terms.common.yes-no.no',
+                            placeholder: '@measurement-core:sizes.entities.size-rule.fields.priority.placeholder',
                         },
                     },
                 },
             },
         ],
         columns: [
-            { name: 'code', options: { width: '120px', order: 1 } },
-            { name: 'title', options: { width: '220px', order: 2 } },
-            { name: 'symbol', options: { width: '100px', order: 3 } },
-            { name: 'quantityTypeId', options: { width: '180px', order: 4 } },
-            { name: 'isBase', options: { width: '100px', order: 5 } },
+            { name: 'sizeChartId', options: { width: '160px', dataPath: 'sizeChart.title', order: 1 } },
+            { name: 'sizeItemId', options: { width: '120px', dataPath: 'sizeItem.code', order: 2 } },
+            { name: 'measurementDimensionId', options: { width: '160px', dataPath: 'measurementDimension.title', order: 3 } },
+            { name: 'measurementRangeId', options: { width: '160px', dataPath: 'measurementRange.title', order: 4 } },
+            { name: 'matchBehavior', options: { width: '100px', order: 5 } },
+            { name: 'priority', options: { width: '90px', order: 6 } },
         ],
         interfaces: {
             master: {
@@ -2441,7 +2450,7 @@ async function unitOfMeasureFactory() {
                     properties: propertyLayouts,
                 },
                 single: {
-                    title: '{{ title }}',
+                    title: '{{ context.eval("sizeItem.code") + " / " + context.eval("measurementDimension.title") }}',
                     sections,
                     properties: propertyLayouts,
                     actions: [...entityMasterRecordActions()],
@@ -2450,7 +2459,10 @@ async function unitOfMeasureFactory() {
                     actions: [...entityMasterCrudActions()],
                     views: [
                         createAllQueryView({
-                            sorts: [{ name: 'code', dir: 'asc' }],
+                            sorts: [
+                                { name: 'sizeItemId', dir: 'asc' },
+                                { name: 'measurementDimensionId', dir: 'asc' },
+                            ],
                         }),
                     ],
                 },
@@ -2461,13 +2473,17 @@ async function unitOfMeasureFactory() {
 }
 //#endregion
 
-//#endregion
-
-var index = /*#__PURE__*/Object.freeze({
+var sizeRule_entity = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    unitOfMeasureFactory: unitOfMeasureFactory
+    sizeRuleFactory: sizeRuleFactory
 });
 
+//#region ----   Size Rule Model   ----
+//#endregion
+
+//#region ---- Contracts barrel ----
+//#endregion
+
 // Main Module
 
 /**