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

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

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