diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
index 416ca27273..f69fc52a7f 100644
--- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
@@ -36,7 +36,8 @@ public QuantityGenerator(Quantity quantity)
                               baseDimensions.I == 0 &&
                               baseDimensions.Θ == 0 &&
                               baseDimensions.N == 0 &&
-                              baseDimensions.J == 0;
+                              baseDimensions.J == 0 &&
+                              baseDimensions.b == 0;
 
         }
 
@@ -120,7 +121,7 @@ private void GenerateStaticConstructor()
             BaseDimensions = BaseDimensions.Dimensionless;
 "
                 : $@"
-            BaseDimensions = new BaseDimensions({baseDimensions.L}, {baseDimensions.M}, {baseDimensions.T}, {baseDimensions.I}, {baseDimensions.Θ}, {baseDimensions.N}, {baseDimensions.J});
+            BaseDimensions = new BaseDimensions({baseDimensions.L}, {baseDimensions.M}, {baseDimensions.T}, {baseDimensions.I}, {baseDimensions.Θ}, {baseDimensions.N}, {baseDimensions.J}, {baseDimensions.b});
 ");
 
             Writer.WL($@"
diff --git a/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs
index 24c3d5eb34..df90e27026 100644
--- a/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetWrcGen/QuantityGenerator.cs
@@ -36,7 +36,8 @@ public QuantityGenerator(Quantity quantity)
                               baseDimensions.I == 0 &&
                               baseDimensions.Θ == 0 &&
                               baseDimensions.N == 0 &&
-                              baseDimensions.J == 0;
+                              baseDimensions.J == 0 &&
+                              baseDimensions.b == 0;
 
         }
 
@@ -114,7 +115,7 @@ private void GenerateStaticConstructor()
                 ? @"
             BaseDimensions = BaseDimensions.Dimensionless;"
                 : $@"
-            BaseDimensions = new BaseDimensions({baseDimensions.L}, {baseDimensions.M}, {baseDimensions.T}, {baseDimensions.I}, {baseDimensions.Θ}, {baseDimensions.N}, {baseDimensions.J});");
+            BaseDimensions = new BaseDimensions({baseDimensions.L}, {baseDimensions.M}, {baseDimensions.T}, {baseDimensions.I}, {baseDimensions.Θ}, {baseDimensions.N}, {baseDimensions.J}, {baseDimensions.b});");
 
             Writer.WL($@"
             Info = new QuantityInfo(QuantityType.{_quantity.Name}, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
diff --git a/CodeGen/JsonTypes/BaseDimensions.cs b/CodeGen/JsonTypes/BaseDimensions.cs
index a6caad21fd..0cc889f214 100644
--- a/CodeGen/JsonTypes/BaseDimensions.cs
+++ b/CodeGen/JsonTypes/BaseDimensions.cs
@@ -22,6 +22,8 @@ internal class BaseDimensions
         public int Θ = 0;
         /// <summary>Time.</summary>
         public int T = 0;
+        /// <summary>Information.</summary>
+        public int b = 0;
 
         // 0649 Field is never assigned to
 #pragma warning restore 0649
diff --git a/Common/UnitDefinitions/BitRate.json b/Common/UnitDefinitions/BitRate.json
index a987c9421e..35da1f46b3 100644
--- a/Common/UnitDefinitions/BitRate.json
+++ b/Common/UnitDefinitions/BitRate.json
@@ -3,6 +3,10 @@
   "BaseUnit": "BitPerSecond",
   "BaseType": "decimal",
   "XmlDoc": "In telecommunications and computing, bit rate is the number of bits that are conveyed or processed per unit of time.",
+  "BaseDimensions": {
+    "b": 1,
+    "T": -1
+  },
   "XmlDocRemarks": "https://en.wikipedia.org/wiki/Bit_rate",
   "Units": [
     {
diff --git a/Common/UnitDefinitions/Information.json b/Common/UnitDefinitions/Information.json
index 465fea7e23..0390906068 100644
--- a/Common/UnitDefinitions/Information.json
+++ b/Common/UnitDefinitions/Information.json
@@ -3,6 +3,9 @@
   "BaseUnit": "Bit",
   "BaseType": "decimal",
   "XmlDoc": "In computing and telecommunications, a unit of information is the capacity of some standard data storage system or communication channel, used to measure the capacities of other systems and channels. In information theory, units of information are also used to measure the information contents or entropy of random variables.",
+  "BaseDimensions": {
+    "b": 1
+  },
   "Units": [
     {
       "SingularName": "Byte",
diff --git a/UnitsNet.Tests/BaseDimensionsTests.cs b/UnitsNet.Tests/BaseDimensionsTests.cs
index 9c0b593590..5ef48bc28a 100644
--- a/UnitsNet.Tests/BaseDimensionsTests.cs
+++ b/UnitsNet.Tests/BaseDimensionsTests.cs
@@ -9,7 +9,7 @@ public class BaseDimensionsTests
         [Fact]
         public void ConstructorImplementedCorrectly()
         {
-            var baseDimensions = new BaseDimensions(1, 2, 3, 4, 5, 6, 7);
+            var baseDimensions = new BaseDimensions(1, 2, 3, 4, 5, 6, 7, 8);
 
             Assert.True(baseDimensions.Length == 1);
             Assert.True(baseDimensions.Mass == 2);
@@ -18,37 +18,40 @@ public void ConstructorImplementedCorrectly()
             Assert.True(baseDimensions.Temperature == 5);
             Assert.True(baseDimensions.Amount == 6);
             Assert.True(baseDimensions.LuminousIntensity == 7);
+            Assert.True(baseDimensions.Information == 8);
         }
 
         [Theory]
-        [InlineData(1, 0, 0, 0, 0, 0, 0)]
-        [InlineData(0, 1, 0, 0, 0, 0, 0)]
-        [InlineData(0, 0, 1, 0, 0, 0, 0)]
-        [InlineData(0, 0, 0, 1, 0, 0, 0)]
-        [InlineData(0, 0, 0, 0, 1, 0, 0)]
-        [InlineData(0, 0, 0, 0, 0, 1, 0)]
-        [InlineData(0, 0, 0, 0, 0, 0, 1)]
-        public void IsBaseQuantityImplementedProperly(int length, int mass, int time, int current, int temperature, int amount, int luminousIntensity)
-        {
-            var baseDimensions = new BaseDimensions(length, mass, time, current, temperature, amount, luminousIntensity);
-            var derivedDimensions = new BaseDimensions(length * 2, mass * 2, time * 2, current * 2, temperature * 2, amount * 2, luminousIntensity * 2);
+        [InlineData(1, 0, 0, 0, 0, 0, 0, 0)]
+        [InlineData(0, 1, 0, 0, 0, 0, 0, 0)]
+        [InlineData(0, 0, 1, 0, 0, 0, 0, 0)]
+        [InlineData(0, 0, 0, 1, 0, 0, 0, 0)]
+        [InlineData(0, 0, 0, 0, 1, 0, 0, 0)]
+        [InlineData(0, 0, 0, 0, 0, 1, 0, 0)]
+        [InlineData(0, 0, 0, 0, 0, 0, 1, 0)]
+        [InlineData(0, 0, 0, 0, 0, 0, 0, 1)]
+        public void IsBaseQuantityImplementedProperly(int length, int mass, int time, int current, int temperature, int amount, int luminousIntensity, int information)
+        {
+            var baseDimensions = new BaseDimensions(length, mass, time, current, temperature, amount, luminousIntensity, information);
+            var derivedDimensions = new BaseDimensions(length * 2, mass * 2, time * 2, current * 2, temperature * 2, amount * 2, luminousIntensity * 2, information * 2);
 
             Assert.True(baseDimensions.IsBaseQuantity());
             Assert.False(derivedDimensions.IsBaseQuantity());
         }
 
         [Theory]
-        [InlineData(2, 0, 0, 0, 0, 0, 0)]
-        [InlineData(0, 2, 0, 0, 0, 0, 0)]
-        [InlineData(0, 0, 2, 0, 0, 0, 0)]
-        [InlineData(0, 0, 0, 2, 0, 0, 0)]
-        [InlineData(0, 0, 0, 0, 2, 0, 0)]
-        [InlineData(0, 0, 0, 0, 0, 2, 0)]
-        [InlineData(0, 0, 0, 0, 0, 0, 2)]
-        public void IsDerivedQuantityImplementedProperly(int length, int mass, int time, int current, int temperature, int amount, int luminousIntensity)
-        {
-            var baseDimensions = new BaseDimensions(length / 2, mass / 2, time / 2, current / 2, temperature / 2, amount / 2, luminousIntensity / 2);
-            var derivedDimensions = new BaseDimensions(length, mass, time, current, temperature, amount, luminousIntensity);
+        [InlineData(2, 0, 0, 0, 0, 0, 0, 0)]
+        [InlineData(0, 2, 0, 0, 0, 0, 0, 0)]
+        [InlineData(0, 0, 2, 0, 0, 0, 0, 0)]
+        [InlineData(0, 0, 0, 2, 0, 0, 0, 0)]
+        [InlineData(0, 0, 0, 0, 2, 0, 0, 0)]
+        [InlineData(0, 0, 0, 0, 0, 2, 0, 0)]
+        [InlineData(0, 0, 0, 0, 0, 0, 2, 0)]
+        [InlineData(0, 0, 0, 0, 0, 0, 0, 2)]
+        public void IsDerivedQuantityImplementedProperly(int length, int mass, int time, int current, int temperature, int amount, int luminousIntensity, int information)
+        {
+            var baseDimensions = new BaseDimensions(length / 2, mass / 2, time / 2, current / 2, temperature / 2, amount / 2, luminousIntensity / 2, information / 2);
+            var derivedDimensions = new BaseDimensions(length, mass, time, current, temperature, amount, luminousIntensity, information);
 
             Assert.False(baseDimensions.IsDerivedQuantity());
             Assert.True(derivedDimensions.IsDerivedQuantity());
@@ -57,8 +60,8 @@ public void IsDerivedQuantityImplementedProperly(int length, int mass, int time,
         [Fact]
         public void EqualsWorksAsExpected()
         {
-            var baseDimensions1 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7);
-            var baseDimensions2 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7);
+            var baseDimensions1 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7, 8);
+            var baseDimensions2 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7, 8);
 
             Assert.True(baseDimensions1.Equals(baseDimensions2));
             Assert.True(baseDimensions2.Equals(baseDimensions1));
@@ -69,8 +72,8 @@ public void EqualsWorksAsExpected()
         [Fact]
         public void EqualityOperatorsWorkAsExpected()
         {
-            var baseDimensions1 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7);
-            var baseDimensions2 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7);
+            var baseDimensions1 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7, 8);
+            var baseDimensions2 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7, 8);
 
             Assert.True(baseDimensions1 == baseDimensions2);
             Assert.True(baseDimensions2 == baseDimensions1);
@@ -90,8 +93,8 @@ public void EqualityOperatorsWorkAsExpected()
         [Fact]
         public void InequalityOperatorsWorkAsExpected()
         {
-            var baseDimensions1 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7);
-            var baseDimensions2 = new BaseDimensions(7, 6, 5, 4, 3, 2, 1);
+            var baseDimensions1 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7, 8);
+            var baseDimensions2 = new BaseDimensions(8, 7, 6, 5, 4, 3, 2, 1);
 
             Assert.True(baseDimensions1 != baseDimensions2);
             Assert.True(baseDimensions2 != baseDimensions1);
@@ -111,21 +114,21 @@ public void InequalityOperatorsWorkAsExpected()
         [Fact]
         public void MultiplyThrowsExceptionIfPassedNull()
         {
-            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0, 0);
             Assert.Throws<ArgumentNullException>(() => baseDimensions1.Multiply(null));
         }
 
         [Fact]
         public void DivideThrowsExceptionIfPassedNull()
         {
-            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0, 0);
             Assert.Throws<ArgumentNullException>(() => baseDimensions1.Divide(null));
         }
 
         [Fact]
         public void MultiplyOperatorThrowsExceptionWithNull()
         {
-            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0, 0);
             Assert.Throws<ArgumentNullException>(() => baseDimensions1 / null);
             Assert.Throws<ArgumentNullException>(() => null / baseDimensions1);
         }
@@ -133,7 +136,7 @@ public void MultiplyOperatorThrowsExceptionWithNull()
         [Fact]
         public void DivideOperatorThrowsExceptionWithNull()
         {
-            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0, 0);
             Assert.Throws<ArgumentNullException>(() => baseDimensions1 * null);
             Assert.Throws<ArgumentNullException>(() => null * baseDimensions1);
         }
@@ -141,8 +144,8 @@ public void DivideOperatorThrowsExceptionWithNull()
         [Fact]
         public void LengthDimensionsMultiplyCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(2, 0, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(2, 0, 0, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1.Multiply(baseDimensions2);
 
@@ -153,13 +156,14 @@ public void LengthDimensionsMultiplyCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void MassDimensionsMultiplyCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 2, 0, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 3, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 2, 0, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 3, 0, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1.Multiply(baseDimensions2);
 
@@ -170,13 +174,14 @@ public void MassDimensionsMultiplyCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void TimeDimensionsMultiplyCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 3, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 4, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 3, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 4, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1.Multiply(baseDimensions2);
 
@@ -187,13 +192,14 @@ public void TimeDimensionsMultiplyCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void CurrentDimensionsMultiplyCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 4, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 5, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 4, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 5, 0, 0, 0, 0);
 
             var result = baseDimensions1.Multiply(baseDimensions2);
 
@@ -204,13 +210,14 @@ public void CurrentDimensionsMultiplyCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void TemperatureDimensionsMultiplyCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 5, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 6, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 5, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 6, 0, 0, 0);
 
             var result = baseDimensions1.Multiply(baseDimensions2);
 
@@ -221,13 +228,14 @@ public void TemperatureDimensionsMultiplyCorrectly()
             Assert.True(result.Temperature == 11);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void AmountDimensionsMultiplyCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 6, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 7, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 6, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 7, 0, 0);
 
             var result = baseDimensions1.Multiply(baseDimensions2);
 
@@ -238,13 +246,14 @@ public void AmountDimensionsMultiplyCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 13);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void LuminousIntensityDimensionsMultiplyCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 7);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 8);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 7, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 8, 0);
 
             var result = baseDimensions1.Multiply(baseDimensions2);
 
@@ -255,13 +264,32 @@ public void LuminousIntensityDimensionsMultiplyCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 15);
+            Assert.True(result.Information == 0);
+        }
+
+        [Fact]
+        public void InformationDimensionsMultiplyCorrectly()
+        {
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 7);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 8);
+
+            var result = baseDimensions1.Multiply(baseDimensions2);
+
+            Assert.True(result.Length == 0);
+            Assert.True(result.Mass == 0);
+            Assert.True(result.Time == 0);
+            Assert.True(result.Current == 0);
+            Assert.True(result.Temperature == 0);
+            Assert.True(result.Amount == 0);
+            Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 15);
         }
 
         [Fact]
         public void LengthDimensionsDivideCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(8, 0, 0, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(7, 0, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(8, 0, 0, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(7, 0, 0, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1.Divide(baseDimensions2);
 
@@ -272,13 +300,14 @@ public void LengthDimensionsDivideCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void MassDimensionsDivideCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 7, 0, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 6, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 7, 0, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 6, 0, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1.Divide(baseDimensions2);
 
@@ -289,13 +318,14 @@ public void MassDimensionsDivideCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void TimeDimensionsDivideCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 6, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 5, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 6, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 5, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1.Divide(baseDimensions2);
 
@@ -306,13 +336,14 @@ public void TimeDimensionsDivideCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void CurrentDimensionsDivideCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 5, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 4, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 5, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 4, 0, 0, 0, 0);
 
             var result = baseDimensions1.Divide(baseDimensions2);
 
@@ -323,13 +354,14 @@ public void CurrentDimensionsDivideCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void TemperatureDimensionsDivideCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 4, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 3, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 4, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 3, 0, 0, 0);
 
             var result = baseDimensions1.Divide(baseDimensions2);
 
@@ -340,13 +372,14 @@ public void TemperatureDimensionsDivideCorrectly()
             Assert.True(result.Temperature == 1);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void AmountDimensionsDivideCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 3, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 2, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 3, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 2, 0, 0);
 
             var result = baseDimensions1.Divide(baseDimensions2);
 
@@ -357,13 +390,14 @@ public void AmountDimensionsDivideCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 1);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void LuminousIntensityDimensionsDivideCorrectly()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 2);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 1);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 2, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 1, 0);
 
             var result = baseDimensions1.Divide(baseDimensions2);
 
@@ -374,6 +408,25 @@ public void LuminousIntensityDimensionsDivideCorrectly()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 1);
+            Assert.True(result.Information == 0);
+        }
+
+        [Fact]
+        public void InformationDimensionsDivideCorrectly()
+        {
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 2);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 1);
+
+            var result = baseDimensions1.Divide(baseDimensions2);
+
+            Assert.True(result.Length == 0);
+            Assert.True(result.Mass == 0);
+            Assert.True(result.Time == 0);
+            Assert.True(result.Current == 0);
+            Assert.True(result.Temperature == 0);
+            Assert.True(result.Amount == 0);
+            Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 1);
         }
 
         [Fact]
@@ -413,8 +466,8 @@ public void CheckBaseDimensionMultiplicationWithForceEqualsMassTimesAcceleration
         [Fact]
         public void EqualityWorksAsExpectedWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7);
-            var baseDimensions2 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7);
+            var baseDimensions1 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7, 8);
+            var baseDimensions2 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7, 8);
 
             Assert.True(baseDimensions1 == baseDimensions2);
             Assert.True(baseDimensions2 == baseDimensions1);
@@ -423,8 +476,8 @@ public void EqualityWorksAsExpectedWithOperatorOverloads()
         [Fact]
         public void LengthDimensionsMultiplyCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(2, 0, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(1, 0, 0, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(2, 0, 0, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1 * baseDimensions2;
 
@@ -435,13 +488,14 @@ public void LengthDimensionsMultiplyCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void MassDimensionsMultiplyCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 2, 0, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 3, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 2, 0, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 3, 0, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1 * baseDimensions2;
 
@@ -452,13 +506,14 @@ public void MassDimensionsMultiplyCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void TimeDimensionsMultiplyCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 3, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 4, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 3, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 4, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1 * baseDimensions2;
 
@@ -469,13 +524,14 @@ public void TimeDimensionsMultiplyCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void CurrentDimensionsMultiplyCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 4, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 5, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 4, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 5, 0, 0, 0, 0);
 
             var result = baseDimensions1 * baseDimensions2;
 
@@ -486,13 +542,14 @@ public void CurrentDimensionsMultiplyCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void TemperatureDimensionsMultiplyCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 5, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 6, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 5, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 6, 0, 0, 0);
 
             var result = baseDimensions1 * baseDimensions2;
 
@@ -503,13 +560,14 @@ public void TemperatureDimensionsMultiplyCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 11);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void AmountDimensionsMultiplyCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 6, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 7, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 6, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 7, 0, 0);
 
             var result = baseDimensions1 * baseDimensions2;
 
@@ -520,13 +578,14 @@ public void AmountDimensionsMultiplyCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 13);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void LuminousIntensityDimensionsMultiplyCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 7);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 8);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 7, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 8, 0);
 
             var result = baseDimensions1 * baseDimensions2;
 
@@ -537,13 +596,32 @@ public void LuminousIntensityDimensionsMultiplyCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 15);
+            Assert.True(result.Information == 0);
+        }
+
+        [Fact]
+        public void InformationDimensionsMultiplyCorrectlyWithOperatorOverloads()
+        {
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 8);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 9);
+
+            var result = baseDimensions1 * baseDimensions2;
+
+            Assert.True(result.Length == 0);
+            Assert.True(result.Mass == 0);
+            Assert.True(result.Time == 0);
+            Assert.True(result.Current == 0);
+            Assert.True(result.Temperature == 0);
+            Assert.True(result.Amount == 0);
+            Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 17);
         }
 
         [Fact]
         public void LengthDimensionsDivideCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(8, 0, 0, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(7, 0, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(8, 0, 0, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(7, 0, 0, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1 / baseDimensions2;
 
@@ -554,13 +632,14 @@ public void LengthDimensionsDivideCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void MassDimensionsDivideCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 7, 0, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 6, 0, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 7, 0, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 6, 0, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1 / baseDimensions2;
 
@@ -571,13 +650,14 @@ public void MassDimensionsDivideCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void TimeDimensionsDivideCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 6, 0, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 5, 0, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 6, 0, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 5, 0, 0, 0, 0, 0);
 
             var result = baseDimensions1 / baseDimensions2;
 
@@ -588,13 +668,14 @@ public void TimeDimensionsDivideCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void CurrentDimensionsDivideCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 5, 0, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 4, 0, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 5, 0, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 4, 0, 0, 0, 0);
 
             var result = baseDimensions1 / baseDimensions2;
 
@@ -605,13 +686,14 @@ public void CurrentDimensionsDivideCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void TemperatureDimensionsDivideCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 4, 0, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 3, 0, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 4, 0, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 3, 0, 0, 0);
 
             var result = baseDimensions1 / baseDimensions2;
 
@@ -622,13 +704,14 @@ public void TemperatureDimensionsDivideCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 1);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void AmountDimensionsDivideCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 3, 0);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 2, 0);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 3, 0, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 2, 0, 0);
 
             var result = baseDimensions1 / baseDimensions2;
 
@@ -639,13 +722,14 @@ public void AmountDimensionsDivideCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 1);
             Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 0);
         }
 
         [Fact]
         public void LuminousIntensityDimensionsDivideCorrectlyWithOperatorOverloads()
         {
-            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 2);
-            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 1);
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 2, 0);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 1, 0);
 
             var result = baseDimensions1 / baseDimensions2;
 
@@ -656,6 +740,25 @@ public void LuminousIntensityDimensionsDivideCorrectlyWithOperatorOverloads()
             Assert.True(result.Temperature == 0);
             Assert.True(result.Amount == 0);
             Assert.True(result.LuminousIntensity == 1);
+            Assert.True(result.Information == 0);
+        }
+
+        [Fact]
+        public void InformationDimensionsDivideCorrectlyWithOperatorOverloads()
+        {
+            var baseDimensions1 = new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 2);
+            var baseDimensions2 = new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 1);
+
+            var result = baseDimensions1 / baseDimensions2;
+
+            Assert.True(result.Length == 0);
+            Assert.True(result.Mass == 0);
+            Assert.True(result.Time == 0);
+            Assert.True(result.Current == 0);
+            Assert.True(result.Temperature == 0);
+            Assert.True(result.Amount == 0);
+            Assert.True(result.LuminousIntensity == 0);
+            Assert.True(result.Information == 1);
         }
 
         [Fact]
@@ -701,9 +804,9 @@ public void CheckToStringUsingMolarEntropy()
         [Fact]
         public void GetHashCodeWorksProperly()
         {
-            var baseDimensions1 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7);
-            var baseDimensions2 = new BaseDimensions(7, 6, 5, 4, 3, 2, 1);
-            var baseDimensions3 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7);
+            var baseDimensions1 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7, 8);
+            var baseDimensions2 = new BaseDimensions(8, 7, 6, 5, 4, 3, 2, 1);
+            var baseDimensions3 = new BaseDimensions(1, 2, 3, 4, 5, 6, 7, 8);
 
             var hashSet = new HashSet<BaseDimensions>();
 
@@ -723,14 +826,14 @@ public void GetHashCodeWorksProperly()
         [Fact]
         public void DimensionlessPropertyIsCorrect()
         {
-            Assert.True(BaseDimensions.Dimensionless == new BaseDimensions(0, 0, 0, 0, 0, 0, 0));
+            Assert.True(BaseDimensions.Dimensionless == new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 0));
         }
 
         [Fact]
         public void IsDimensionlessMethodImplementedCorrectly()
         {
             Assert.True(BaseDimensions.Dimensionless.IsDimensionless());
-            Assert.True(new BaseDimensions(0, 0, 0, 0, 0, 0, 0).IsDimensionless());
+            Assert.True(new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 0).IsDimensionless());
 
             Assert.False(BaseDimensions.Dimensionless.IsBaseQuantity());
             Assert.False(BaseDimensions.Dimensionless.IsDerivedQuantity());
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs
index 85cab970be..ee0111710d 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Acceleration.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Acceleration : IQuantity
 
         static Acceleration()
         {
-            BaseDimensions = new BaseDimensions(1, 0, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 0, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Acceleration, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs
index 5ad5fa29f4..4dc5d5ce7e 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AmountOfSubstance.g.cs
@@ -48,7 +48,7 @@ public sealed partial class AmountOfSubstance : IQuantity
 
         static AmountOfSubstance()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 1, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 1, 0, 0);
             Info = new QuantityInfo(QuantityType.AmountOfSubstance, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs
index 3ddcbd6a6e..f606b05e2b 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentEnergy.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ApparentEnergy : IQuantity
 
         static ApparentEnergy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ApparentEnergy, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs
index 0781f3b56a..283ccd87a6 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ApparentPower.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ApparentPower : IQuantity
 
         static ApparentPower()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ApparentPower, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs
index 2e8dfb7f71..8e590d7712 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Area.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Area : IQuantity
 
         static Area()
         {
-            BaseDimensions = new BaseDimensions(2, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 0, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Area, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs
index 0a351eab96..30df3806e8 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaDensity.g.cs
@@ -48,7 +48,7 @@ public sealed partial class AreaDensity : IQuantity
 
         static AreaDensity()
         {
-            BaseDimensions = new BaseDimensions(-2, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 1, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.AreaDensity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
index 6b9b75cc31..2cd00619c7 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
@@ -48,7 +48,7 @@ public sealed partial class AreaMomentOfInertia : IQuantity
 
         static AreaMomentOfInertia()
         {
-            BaseDimensions = new BaseDimensions(4, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(4, 0, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.AreaMomentOfInertia, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs
index e4fee981aa..0e98616514 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BitRate.g.cs
@@ -51,7 +51,7 @@ public sealed partial class BitRate : IQuantity
 
         static BitRate()
         {
-            BaseDimensions = BaseDimensions.Dimensionless;
+            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 0, 0, 0, 1);
             Info = new QuantityInfo(QuantityType.BitRate, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
index 81d4e9c4d7..9fdab0fea2 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
@@ -48,7 +48,7 @@ public sealed partial class BrakeSpecificFuelConsumption : IQuantity
 
         static BrakeSpecificFuelConsumption()
         {
-            BaseDimensions = new BaseDimensions(-2, 0, 2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 0, 2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.BrakeSpecificFuelConsumption, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs
index 211e9d682b..d95e789e62 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Capacitance.g.cs
@@ -51,7 +51,7 @@ public sealed partial class Capacitance : IQuantity
 
         static Capacitance()
         {
-            BaseDimensions = new BaseDimensions(-2, -1, 4, 2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, -1, 4, 2, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Capacitance, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
index a491a33eb4..327bf7230b 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
@@ -48,7 +48,7 @@ public sealed partial class CoefficientOfThermalExpansion : IQuantity
 
         static CoefficientOfThermalExpansion()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, -1, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.CoefficientOfThermalExpansion, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs
index 4322085fa7..1a40f6773b 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Density.g.cs
@@ -51,7 +51,7 @@ public sealed partial class Density : IQuantity
 
         static Density()
         {
-            BaseDimensions = new BaseDimensions(-3, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-3, 1, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Density, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs
index 9a5441a262..33e2429943 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Duration.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Duration : IQuantity
 
         static Duration()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 1, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Duration, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs
index 2975d76bd9..fee976e6c2 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/DynamicViscosity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class DynamicViscosity : IQuantity
 
         static DynamicViscosity()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, -1, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.DynamicViscosity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs
index 519872df8f..2f3afc5b9f 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricAdmittance.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ElectricAdmittance : IQuantity
 
         static ElectricAdmittance()
         {
-            BaseDimensions = new BaseDimensions(-2, -1, 3, 2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, -1, 3, 2, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricAdmittance, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs
index abb5480f7c..afaa7945a2 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCharge.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ElectricCharge : IQuantity
 
         static ElectricCharge()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 1, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 1, 1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricCharge, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
index c56a49e549..619a3b0533 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ElectricChargeDensity : IQuantity
 
         static ElectricChargeDensity()
         {
-            BaseDimensions = new BaseDimensions(-3, 0, 1, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-3, 0, 1, 1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricChargeDensity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs
index 89fe68bac9..3fb5ad5bcd 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductance.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ElectricConductance : IQuantity
 
         static ElectricConductance()
         {
-            BaseDimensions = new BaseDimensions(-2, -1, 3, 2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, -1, 3, 2, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricConductance, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs
index 1af5cf33cf..6f606e1cd0 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricConductivity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ElectricConductivity : IQuantity
 
         static ElectricConductivity()
         {
-            BaseDimensions = new BaseDimensions(-3, -1, 3, 2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-3, -1, 3, 2, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricConductivity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs
index 2842e7852c..245a0d852a 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrent.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ElectricCurrent : IQuantity
 
         static ElectricCurrent()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricCurrent, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
index 80778d222b..1984bf0aaa 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ElectricCurrentDensity : IQuantity
 
         static ElectricCurrentDensity()
         {
-            BaseDimensions = new BaseDimensions(-2, 0, 0, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 0, 0, 1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricCurrentDensity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
index 937a762793..3e2de1330b 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ElectricCurrentGradient : IQuantity
 
         static ElectricCurrentGradient()
         {
-            BaseDimensions = new BaseDimensions(0, 0, -1, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, -1, 1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricCurrentGradient, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs
index 22ef18d5f6..199d457fa0 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricField.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ElectricField : IQuantity
 
         static ElectricField()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -3, -1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -3, -1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricField, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs
index 5109849aec..9af1cac38c 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricInductance.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ElectricInductance : IQuantity
 
         static ElectricInductance()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, -2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, -2, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricInductance, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs
index 7aa0e72cfb..524a4030a5 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotential.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ElectricPotential : IQuantity
 
         static ElectricPotential()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, -1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, -1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricPotential, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
index f01bc555f9..1b37e06d83 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ElectricPotentialChangeRate : IQuantity
 
         static ElectricPotentialChangeRate()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -4, -1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -4, -1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricPotentialChangeRate, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs
index 62c594e09e..f2abda5d79 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistance.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ElectricResistance : IQuantity
 
         static ElectricResistance()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, -2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, -2, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricResistance, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs
index c47de6271c..dbe4202ac1 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricResistivity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ElectricResistivity : IQuantity
 
         static ElectricResistivity()
         {
-            BaseDimensions = new BaseDimensions(3, 1, -3, -2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(3, 1, -3, -2, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricResistivity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
index f56800c357..bf8fc8ba4a 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ElectricSurfaceChargeDensity : IQuantity
 
         static ElectricSurfaceChargeDensity()
         {
-            BaseDimensions = new BaseDimensions(-2, 0, 1, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 0, 1, 1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ElectricSurfaceChargeDensity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs
index c1bbd532f8..dabe0f0dbe 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Energy.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Energy : IQuantity
 
         static Energy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Energy, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs
index 724b9a22d6..498eef6939 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Entropy.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Entropy : IQuantity
 
         static Entropy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, -1, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Entropy, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs
index dbc95e816f..2b5262bb8a 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Force : IQuantity
 
         static Force()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Force, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs
index f6e0d5bd50..a630019780 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForceChangeRate.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ForceChangeRate : IQuantity
 
         static ForceChangeRate()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ForceChangeRate, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs
index 9ba947a00e..4117d26f95 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ForcePerLength.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ForcePerLength : IQuantity
 
         static ForcePerLength()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ForcePerLength, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs
index a0f99c7cb5..06bb3e64b4 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Frequency.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Frequency : IQuantity
 
         static Frequency()
         {
-            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Frequency, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs
index b0899f7903..135693665a 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatFlux.g.cs
@@ -48,7 +48,7 @@ public sealed partial class HeatFlux : IQuantity
 
         static HeatFlux()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -3, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.HeatFlux, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
index eb4cdc4691..147d3d7f8c 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
@@ -48,7 +48,7 @@ public sealed partial class HeatTransferCoefficient : IQuantity
 
         static HeatTransferCoefficient()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -3, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -3, 0, -1, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.HeatTransferCoefficient, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs
index 543b303667..4e288b7835 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Illuminance.g.cs
@@ -51,7 +51,7 @@ public sealed partial class Illuminance : IQuantity
 
         static Illuminance()
         {
-            BaseDimensions = new BaseDimensions(-2, 0, 0, 0, 0, 0, 1);
+            BaseDimensions = new BaseDimensions(-2, 0, 0, 0, 0, 0, 1, 0);
             Info = new QuantityInfo(QuantityType.Illuminance, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs
index 493d68e580..a1c3a01504 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Information.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Information : IQuantity
 
         static Information()
         {
-            BaseDimensions = BaseDimensions.Dimensionless;
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 1);
             Info = new QuantityInfo(QuantityType.Information, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs
index c144fc7db5..80d7edb5f3 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiance.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Irradiance : IQuantity
 
         static Irradiance()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -3, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Irradiance, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs
index cc5a256723..b620ea59e4 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Irradiation.g.cs
@@ -51,7 +51,7 @@ public sealed partial class Irradiation : IQuantity
 
         static Irradiation()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Irradiation, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs
index c8783a04c9..b7b5852f71 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/KinematicViscosity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class KinematicViscosity : IQuantity
 
         static KinematicViscosity()
         {
-            BaseDimensions = new BaseDimensions(2, 0, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 0, -1, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.KinematicViscosity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs
index ae4b7fe44c..776478b0c8 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LapseRate.g.cs
@@ -48,7 +48,7 @@ public sealed partial class LapseRate : IQuantity
 
         static LapseRate()
         {
-            BaseDimensions = new BaseDimensions(-1, 0, 0, 0, 1, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 0, 0, 0, 1, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.LapseRate, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs
index f901c4999c..413cb7446e 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Length.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Length : IQuantity
 
         static Length()
         {
-            BaseDimensions = new BaseDimensions(1, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 0, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Length, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs
index da30246f8b..e396ce480f 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearDensity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class LinearDensity : IQuantity
 
         static LinearDensity()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.LinearDensity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs
index 3bfbb20af2..58388ce9c9 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LinearPowerDensity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class LinearPowerDensity : IQuantity
 
         static LinearPowerDensity()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.LinearPowerDensity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs
index 7ee56e2f39..1312c765f0 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Luminosity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class Luminosity : IQuantity
 
         static Luminosity()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Luminosity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs
index c197dc10fd..e2a4328601 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousFlux.g.cs
@@ -51,7 +51,7 @@ public sealed partial class LuminousFlux : IQuantity
 
         static LuminousFlux()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 0, 1);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 0, 1, 0);
             Info = new QuantityInfo(QuantityType.LuminousFlux, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs
index 143e64a04a..b685866d17 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/LuminousIntensity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class LuminousIntensity : IQuantity
 
         static LuminousIntensity()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 0, 1);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 0, 1, 0);
             Info = new QuantityInfo(QuantityType.LuminousIntensity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs
index a7777d5c1a..84b0d7e4d9 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticField.g.cs
@@ -51,7 +51,7 @@ public sealed partial class MagneticField : IQuantity
 
         static MagneticField()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -2, -1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -2, -1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.MagneticField, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs
index ebce2331a4..da94cf832a 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MagneticFlux.g.cs
@@ -51,7 +51,7 @@ public sealed partial class MagneticFlux : IQuantity
 
         static MagneticFlux()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, -1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, -1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.MagneticFlux, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs
index b0b66874e3..20c55b30a5 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Magnetization.g.cs
@@ -51,7 +51,7 @@ public sealed partial class Magnetization : IQuantity
 
         static Magnetization()
         {
-            BaseDimensions = new BaseDimensions(-1, 0, 0, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 0, 0, 1, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Magnetization, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs
index 5e49ff77b0..130bb22262 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Mass.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Mass : IQuantity
 
         static Mass()
         {
-            BaseDimensions = new BaseDimensions(0, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Mass, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs
index 3dee8e60c8..3bf6ecd8e6 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs
@@ -51,7 +51,7 @@ public sealed partial class MassConcentration : IQuantity
 
         static MassConcentration()
         {
-            BaseDimensions = new BaseDimensions(-3, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-3, 1, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.MassConcentration, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs
index 690395d14f..acdd48466c 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlow.g.cs
@@ -48,7 +48,7 @@ public sealed partial class MassFlow : IQuantity
 
         static MassFlow()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -1, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.MassFlow, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs
index 6c9c1c2519..03c3ea4c61 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassFlux.g.cs
@@ -48,7 +48,7 @@ public sealed partial class MassFlux : IQuantity
 
         static MassFlux()
         {
-            BaseDimensions = new BaseDimensions(-2, 1, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 1, -1, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.MassFlux, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
index c0632713dc..0ce97033ee 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
@@ -48,7 +48,7 @@ public sealed partial class MassMomentOfInertia : IQuantity
 
         static MassMomentOfInertia()
         {
-            BaseDimensions = new BaseDimensions(2, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.MassMomentOfInertia, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs
index f1bb8ab9b1..ea20492095 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEnergy.g.cs
@@ -48,7 +48,7 @@ public sealed partial class MolarEnergy : IQuantity
 
         static MolarEnergy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, -1, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, -1, 0, 0);
             Info = new QuantityInfo(QuantityType.MolarEnergy, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs
index 055bcd576b..8c4bf3d474 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarEntropy.g.cs
@@ -48,7 +48,7 @@ public sealed partial class MolarEntropy : IQuantity
 
         static MolarEntropy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, -1, -1, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, -1, -1, 0, 0);
             Info = new QuantityInfo(QuantityType.MolarEntropy, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs
index e00565a7fd..2c2ca1b9c8 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MolarMass.g.cs
@@ -48,7 +48,7 @@ public sealed partial class MolarMass : IQuantity
 
         static MolarMass()
         {
-            BaseDimensions = new BaseDimensions(0, 1, 0, 0, 0, -1, 0);
+            BaseDimensions = new BaseDimensions(0, 1, 0, 0, 0, -1, 0, 0);
             Info = new QuantityInfo(QuantityType.MolarMass, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs
index 008ec84178..6d9ccce8da 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Molarity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class Molarity : IQuantity
 
         static Molarity()
         {
-            BaseDimensions = new BaseDimensions(-3, 0, 0, 0, 0, 1, 0);
+            BaseDimensions = new BaseDimensions(-3, 0, 0, 0, 0, 1, 0, 0);
             Info = new QuantityInfo(QuantityType.Molarity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs
index 398cf90dae..aa82081c33 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permeability.g.cs
@@ -51,7 +51,7 @@ public sealed partial class Permeability : IQuantity
 
         static Permeability()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -2, -2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -2, -2, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Permeability, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs
index 21a5a1eda3..d9674b52b9 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Permittivity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class Permittivity : IQuantity
 
         static Permittivity()
         {
-            BaseDimensions = new BaseDimensions(-3, -1, 4, 2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-3, -1, 4, 2, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Permittivity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs
index fb8c263383..c5c7fe5a7a 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Power.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Power : IQuantity
 
         static Power()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Power, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs
index e374a600e1..be2ac3e9b9 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PowerDensity.g.cs
@@ -48,7 +48,7 @@ public sealed partial class PowerDensity : IQuantity
 
         static PowerDensity()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, -3, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.PowerDensity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs
index 4e242094bb..4f5adf25b4 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Pressure.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Pressure : IQuantity
 
         static Pressure()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Pressure, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs
index 4c20c6aba2..5782195c59 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/PressureChangeRate.g.cs
@@ -48,7 +48,7 @@ public sealed partial class PressureChangeRate : IQuantity
 
         static PressureChangeRate()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, -3, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.PressureChangeRate, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs
index 851d24d687..7e33069c67 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactiveEnergy.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ReactiveEnergy : IQuantity
 
         static ReactiveEnergy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -1, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ReactiveEnergy, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs
index 47e1add8ac..a982215f40 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReactivePower.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ReactivePower : IQuantity
 
         static ReactivePower()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ReactivePower, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs
index ff9fa40dce..0d2bcde728 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalArea.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ReciprocalArea : IQuantity
 
         static ReciprocalArea()
         {
-            BaseDimensions = new BaseDimensions(-2, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 0, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ReciprocalArea, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs
index 8a0d4d8d1d..5137abb5ac 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ReciprocalLength.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ReciprocalLength : IQuantity
 
         static ReciprocalLength()
         {
-            BaseDimensions = new BaseDimensions(-1, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 0, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ReciprocalLength, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs
index 5a0de083e2..cbf8962e5e 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalAcceleration.g.cs
@@ -48,7 +48,7 @@ public sealed partial class RotationalAcceleration : IQuantity
 
         static RotationalAcceleration()
         {
-            BaseDimensions = new BaseDimensions(0, 0, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.RotationalAcceleration, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs
index 99b6922094..cac805e62b 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalSpeed.g.cs
@@ -48,7 +48,7 @@ public sealed partial class RotationalSpeed : IQuantity
 
         static RotationalSpeed()
         {
-            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.RotationalSpeed, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs
index b7879af272..1a6f4a76ad 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs
@@ -48,7 +48,7 @@ public sealed partial class RotationalStiffness : IQuantity
 
         static RotationalStiffness()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.RotationalStiffness, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
index cec23a5888..6d6472520d 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
@@ -48,7 +48,7 @@ public sealed partial class RotationalStiffnessPerLength : IQuantity
 
         static RotationalStiffnessPerLength()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.RotationalStiffnessPerLength, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs
index 87c65ba238..791b14c15a 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEnergy.g.cs
@@ -51,7 +51,7 @@ public sealed partial class SpecificEnergy : IQuantity
 
         static SpecificEnergy()
         {
-            BaseDimensions = new BaseDimensions(2, 0, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 0, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.SpecificEnergy, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs
index a24c093d9e..8ea964b3a5 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificEntropy.g.cs
@@ -48,7 +48,7 @@ public sealed partial class SpecificEntropy : IQuantity
 
         static SpecificEntropy()
         {
-            BaseDimensions = new BaseDimensions(2, 0, -2, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 0, -2, 0, -1, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.SpecificEntropy, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs
index b0fbec3944..6d75bdd0e4 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificVolume.g.cs
@@ -48,7 +48,7 @@ public sealed partial class SpecificVolume : IQuantity
 
         static SpecificVolume()
         {
-            BaseDimensions = new BaseDimensions(3, -1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(3, -1, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.SpecificVolume, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs
index 129be9de76..2600c83be8 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/SpecificWeight.g.cs
@@ -51,7 +51,7 @@ public sealed partial class SpecificWeight : IQuantity
 
         static SpecificWeight()
         {
-            BaseDimensions = new BaseDimensions(-2, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 1, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.SpecificWeight, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs
index 563c5ac20c..a9eb0d00c3 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Speed.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Speed : IQuantity
 
         static Speed()
         {
-            BaseDimensions = new BaseDimensions(1, 0, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 0, -1, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Speed, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
index 38b7664b58..99964a3baa 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
@@ -48,7 +48,7 @@ public sealed partial class StandardVolumeFlow : IQuantity
 
         static StandardVolumeFlow()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -1, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.StandardVolumeFlow, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs
index 7060f1fdd0..ae0ea5d80f 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Temperature.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Temperature : IQuantity
 
         static Temperature()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 1, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Temperature, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
index 8cf1566aa2..4ffa4b67db 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
@@ -48,7 +48,7 @@ public sealed partial class TemperatureChangeRate : IQuantity
 
         static TemperatureChangeRate()
         {
-            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 1, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.TemperatureChangeRate, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs
index 90c7179d75..a565eeb772 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TemperatureDelta.g.cs
@@ -48,7 +48,7 @@ public sealed partial class TemperatureDelta : IQuantity
 
         static TemperatureDelta()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 1, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.TemperatureDelta, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs
index d1dca98373..c4d6b4000f 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalConductivity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class ThermalConductivity : IQuantity
 
         static ThermalConductivity()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -3, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -3, 0, -1, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ThermalConductivity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs
index e379250e72..56b4acecee 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/ThermalResistance.g.cs
@@ -48,7 +48,7 @@ public sealed partial class ThermalResistance : IQuantity
 
         static ThermalResistance()
         {
-            BaseDimensions = new BaseDimensions(0, -1, 3, 0, 1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, -1, 3, 0, 1, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.ThermalResistance, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs
index 60673bb5f7..9a39641b77 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Torque.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Torque : IQuantity
 
         static Torque()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Torque, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs
index 66e8eb26b3..735339915d 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/TorquePerLength.g.cs
@@ -48,7 +48,7 @@ public sealed partial class TorquePerLength : IQuantity
 
         static TorquePerLength()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.TorquePerLength, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs
index f81ce7cd6f..1ab51be090 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Volume.g.cs
@@ -48,7 +48,7 @@ public sealed partial class Volume : IQuantity
 
         static Volume()
         {
-            BaseDimensions = new BaseDimensions(3, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(3, 0, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.Volume, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs
index 966db193d7..6cd905bb77 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumeFlow.g.cs
@@ -48,7 +48,7 @@ public sealed partial class VolumeFlow : IQuantity
 
         static VolumeFlow()
         {
-            BaseDimensions = new BaseDimensions(3, 0, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(3, 0, -1, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.VolumeFlow, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs
index 81ab899959..484801b284 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs
@@ -48,7 +48,7 @@ public sealed partial class VolumePerLength : IQuantity
 
         static VolumePerLength()
         {
-            BaseDimensions = new BaseDimensions(2, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 0, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.VolumePerLength, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
index a836761c8a..135ea86b02 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
@@ -51,7 +51,7 @@ public sealed partial class VolumetricHeatCapacity : IQuantity
 
         static VolumetricHeatCapacity()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, -2, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, -2, 0, -1, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.VolumetricHeatCapacity, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
index 74bc407b4d..d6cbddf805 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
@@ -48,7 +48,7 @@ public sealed partial class WarpingMomentOfInertia : IQuantity
 
         static WarpingMomentOfInertia()
         {
-            BaseDimensions = new BaseDimensions(6, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(6, 0, 0, 0, 0, 0, 0, 0);
             Info = new QuantityInfo(QuantityType.WarpingMomentOfInertia, Units.Cast<Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
         }
 
diff --git a/UnitsNet/BaseDimensions.cs b/UnitsNet/BaseDimensions.cs
index 1b2f8c70ff..7b80dcf5c4 100644
--- a/UnitsNet/BaseDimensions.cs
+++ b/UnitsNet/BaseDimensions.cs
@@ -13,7 +13,7 @@ namespace UnitsNet
     public sealed class BaseDimensions
     {
         /// <inheritdoc />
-        public BaseDimensions(int length, int mass, int time, int current, int temperature, int amount, int luminousIntensity)
+        public BaseDimensions(int length, int mass, int time, int current, int temperature, int amount, int luminousIntensity, int information)
         {
             Length = length;
             Mass = mass;
@@ -22,6 +22,7 @@ public BaseDimensions(int length, int mass, int time, int current, int temperatu
             Temperature = temperature;
             Amount = amount;
             LuminousIntensity = luminousIntensity;
+            Information = information;
         }
 
         /// <summary>
@@ -30,7 +31,7 @@ public BaseDimensions(int length, int mass, int time, int current, int temperatu
         /// <returns>True if the dimensions represent a base quantity, otherwise false.</returns>
         public bool IsBaseQuantity()
         {
-            var dimensionsArray = new int[]{Length, Mass, Time, Current, Temperature, Amount, LuminousIntensity};
+            var dimensionsArray = new int[]{Length, Mass, Time, Current, Temperature, Amount, LuminousIntensity, Information};
             bool onlyOneEqualsOne = dimensionsArray.Where(dimension => dimension == 1).Take(2).Count() == 1;
             return onlyOneEqualsOne;
         }
@@ -67,7 +68,8 @@ public override bool Equals(object obj)
                 Current == other.Current &&
                 Temperature == other.Temperature &&
                 Amount == other.Amount &&
-                LuminousIntensity == other.LuminousIntensity;
+                LuminousIntensity == other.LuminousIntensity &&
+                Information == other.Information;
         }
 
         /// <inheritdoc />
@@ -93,7 +95,8 @@ public BaseDimensions Multiply(BaseDimensions right)
                 Current + right.Current,
                 Temperature + right.Temperature,
                 Amount + right.Amount,
-                LuminousIntensity + right.LuminousIntensity);
+                LuminousIntensity + right.LuminousIntensity,
+                Information + right.Information);
         }
 
         /// <summary>
@@ -113,7 +116,8 @@ public BaseDimensions Divide(BaseDimensions right)
                 Current - right.Current,
                 Temperature - right.Temperature,
                 Amount - right.Amount,
-                LuminousIntensity - right.LuminousIntensity);
+                LuminousIntensity - right.LuminousIntensity,
+                Information - right.Information);
         }
 
         /// <summary>
@@ -182,6 +186,7 @@ public override string ToString()
             AppendDimensionString(sb, "Temperature", Temperature);
             AppendDimensionString(sb, "Amount", Amount);
             AppendDimensionString(sb, "LuminousIntensity", LuminousIntensity);
+            AppendDimensionString(sb, "Information", Information);
 
             return sb.ToString();
         }
@@ -234,9 +239,14 @@ private static void AppendDimensionString(StringBuilder sb, string name, int val
         /// </summary>
         public int LuminousIntensity{ get; }
 
+        /// <summary>
+        /// Gets the information dimensions (b).
+        /// </summary>
+        public int Information { get; }
+
         /// <summary>
         /// Represents a dimensionless (unitless) quantity.
         /// </summary>
-        public static BaseDimensions Dimensionless { get; } = new BaseDimensions(0, 0, 0, 0, 0, 0, 0);
+        public static BaseDimensions Dimensionless { get; } = new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 0);
     }
 }
diff --git a/UnitsNet/CustomCode/Quantities/BitRate.extra.cs b/UnitsNet/CustomCode/Quantities/BitRate.extra.cs
new file mode 100644
index 0000000000..a0fa42faed
--- /dev/null
+++ b/UnitsNet/CustomCode/Quantities/BitRate.extra.cs
@@ -0,0 +1,19 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+
+namespace UnitsNet
+{
+    public partial struct BitRate
+    {
+        /// <summary>Get <see cref="Information"/> from <see cref="BitRate"/> times <see cref="Duration"/>.</summary>
+        public static Information operator *(BitRate bitRate, Duration duration)
+        {
+            return Information.FromBits(bitRate.BitsPerSecond * duration.Seconds);
+        }
+
+        /// <summary>Get <see cref="Information"/> from <see cref="Duration"/> times <see cref="BitRate"/>.</summary>
+        public static Information operator *(Duration duration, BitRate bitRate)
+        {
+            return Information.FromBits(bitRate.BitsPerSecond * duration.Seconds);
+        }
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
index 23596a1f09..a2974d609f 100644
--- a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
@@ -48,7 +48,7 @@ public partial struct Acceleration : IQuantity<AccelerationUnit>, IEquatable<Acc
 
         static Acceleration()
         {
-            BaseDimensions = new BaseDimensions(1, 0, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 0, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<AccelerationUnit>("Acceleration",
                 new UnitInfo<AccelerationUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
index e04c14b3ac..263c73f58e 100644
--- a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
@@ -48,7 +48,7 @@ public partial struct AmountOfSubstance : IQuantity<AmountOfSubstanceUnit>, IEqu
 
         static AmountOfSubstance()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 1, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 1, 0, 0);
 
             Info = new QuantityInfo<AmountOfSubstanceUnit>("AmountOfSubstance",
                 new UnitInfo<AmountOfSubstanceUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
index a8217547dc..b153437d59 100644
--- a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
@@ -48,7 +48,7 @@ public partial struct ApparentEnergy : IQuantity<ApparentEnergyUnit>, IEquatable
 
         static ApparentEnergy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ApparentEnergyUnit>("ApparentEnergy",
                 new UnitInfo<ApparentEnergyUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
index 8dd4285980..76e649c0ef 100644
--- a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
@@ -48,7 +48,7 @@ public partial struct ApparentPower : IQuantity<ApparentPowerUnit>, IEquatable<A
 
         static ApparentPower()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ApparentPowerUnit>("ApparentPower",
                 new UnitInfo<ApparentPowerUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Area.g.cs b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
index b5f005b410..fea5ae5305 100644
--- a/UnitsNet/GeneratedCode/Quantities/Area.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
@@ -48,7 +48,7 @@ public partial struct Area : IQuantity<AreaUnit>, IEquatable<Area>, IComparable,
 
         static Area()
         {
-            BaseDimensions = new BaseDimensions(2, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 0, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<AreaUnit>("Area",
                 new UnitInfo<AreaUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
index a1a50c7f96..f8cee6c2f8 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
@@ -48,7 +48,7 @@ public partial struct AreaDensity : IQuantity<AreaDensityUnit>, IEquatable<AreaD
 
         static AreaDensity()
         {
-            BaseDimensions = new BaseDimensions(-2, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 1, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<AreaDensityUnit>("AreaDensity",
                 new UnitInfo<AreaDensityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
index 4ba0111c01..507fa9fa9d 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
@@ -48,7 +48,7 @@ public partial struct AreaMomentOfInertia : IQuantity<AreaMomentOfInertiaUnit>,
 
         static AreaMomentOfInertia()
         {
-            BaseDimensions = new BaseDimensions(4, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(4, 0, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<AreaMomentOfInertiaUnit>("AreaMomentOfInertia",
                 new UnitInfo<AreaMomentOfInertiaUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
index 010b522aa1..c7983d53e5 100644
--- a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
@@ -51,7 +51,7 @@ public partial struct BitRate : IQuantity<BitRateUnit>, IDecimalQuantity, IEquat
 
         static BitRate()
         {
-            BaseDimensions = BaseDimensions.Dimensionless;
+            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 0, 0, 0, 1);
 
             Info = new QuantityInfo<BitRateUnit>("BitRate",
                 new UnitInfo<BitRateUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
index dff5e96295..13fe08f422 100644
--- a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
@@ -48,7 +48,7 @@ public partial struct BrakeSpecificFuelConsumption : IQuantity<BrakeSpecificFuel
 
         static BrakeSpecificFuelConsumption()
         {
-            BaseDimensions = new BaseDimensions(-2, 0, 2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 0, 2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<BrakeSpecificFuelConsumptionUnit>("BrakeSpecificFuelConsumption",
                 new UnitInfo<BrakeSpecificFuelConsumptionUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
index 362105e94e..acdbd6b01e 100644
--- a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
@@ -51,7 +51,7 @@ public partial struct Capacitance : IQuantity<CapacitanceUnit>, IEquatable<Capac
 
         static Capacitance()
         {
-            BaseDimensions = new BaseDimensions(-2, -1, 4, 2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, -1, 4, 2, 0, 0, 0, 0);
 
             Info = new QuantityInfo<CapacitanceUnit>("Capacitance",
                 new UnitInfo<CapacitanceUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
index 7db27bc82f..4513db5e24 100644
--- a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
@@ -48,7 +48,7 @@ public partial struct CoefficientOfThermalExpansion : IQuantity<CoefficientOfThe
 
         static CoefficientOfThermalExpansion()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, -1, 0, 0, 0);
 
             Info = new QuantityInfo<CoefficientOfThermalExpansionUnit>("CoefficientOfThermalExpansion",
                 new UnitInfo<CoefficientOfThermalExpansionUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
index ac370318a9..defa15b7f7 100644
--- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
@@ -51,7 +51,7 @@ public partial struct Density : IQuantity<DensityUnit>, IEquatable<Density>, ICo
 
         static Density()
         {
-            BaseDimensions = new BaseDimensions(-3, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-3, 1, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<DensityUnit>("Density",
                 new UnitInfo<DensityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
index 127dfa337f..52d60d88c2 100644
--- a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
@@ -48,7 +48,7 @@ public partial struct Duration : IQuantity<DurationUnit>, IEquatable<Duration>,
 
         static Duration()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 1, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<DurationUnit>("Duration",
                 new UnitInfo<DurationUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
index b3d996a0ba..b2860b5cf7 100644
--- a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
@@ -51,7 +51,7 @@ public partial struct DynamicViscosity : IQuantity<DynamicViscosityUnit>, IEquat
 
         static DynamicViscosity()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, -1, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<DynamicViscosityUnit>("DynamicViscosity",
                 new UnitInfo<DynamicViscosityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
index bfaa342018..784a931f41 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
@@ -48,7 +48,7 @@ public partial struct ElectricAdmittance : IQuantity<ElectricAdmittanceUnit>, IE
 
         static ElectricAdmittance()
         {
-            BaseDimensions = new BaseDimensions(-2, -1, 3, 2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, -1, 3, 2, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricAdmittanceUnit>("ElectricAdmittance",
                 new UnitInfo<ElectricAdmittanceUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
index 72a0a8e6e5..2bd99806a1 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
@@ -51,7 +51,7 @@ public partial struct ElectricCharge : IQuantity<ElectricChargeUnit>, IEquatable
 
         static ElectricCharge()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 1, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 1, 1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricChargeUnit>("ElectricCharge",
                 new UnitInfo<ElectricChargeUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
index 693ca6e463..d219a885a9 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
@@ -51,7 +51,7 @@ public partial struct ElectricChargeDensity : IQuantity<ElectricChargeDensityUni
 
         static ElectricChargeDensity()
         {
-            BaseDimensions = new BaseDimensions(-3, 0, 1, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-3, 0, 1, 1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricChargeDensityUnit>("ElectricChargeDensity",
                 new UnitInfo<ElectricChargeDensityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
index 43b165bb2f..17e9bce5a6 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
@@ -51,7 +51,7 @@ public partial struct ElectricConductance : IQuantity<ElectricConductanceUnit>,
 
         static ElectricConductance()
         {
-            BaseDimensions = new BaseDimensions(-2, -1, 3, 2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, -1, 3, 2, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricConductanceUnit>("ElectricConductance",
                 new UnitInfo<ElectricConductanceUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
index 94bbceaa59..4bcae22d89 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
@@ -51,7 +51,7 @@ public partial struct ElectricConductivity : IQuantity<ElectricConductivityUnit>
 
         static ElectricConductivity()
         {
-            BaseDimensions = new BaseDimensions(-3, -1, 3, 2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-3, -1, 3, 2, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricConductivityUnit>("ElectricConductivity",
                 new UnitInfo<ElectricConductivityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
index 089ec210d0..9b0639a1f3 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
@@ -48,7 +48,7 @@ public partial struct ElectricCurrent : IQuantity<ElectricCurrentUnit>, IEquatab
 
         static ElectricCurrent()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricCurrentUnit>("ElectricCurrent",
                 new UnitInfo<ElectricCurrentUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
index ab134cd7d9..97ea5e1f9c 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
@@ -51,7 +51,7 @@ public partial struct ElectricCurrentDensity : IQuantity<ElectricCurrentDensityU
 
         static ElectricCurrentDensity()
         {
-            BaseDimensions = new BaseDimensions(-2, 0, 0, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 0, 0, 1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricCurrentDensityUnit>("ElectricCurrentDensity",
                 new UnitInfo<ElectricCurrentDensityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
index fa825e9c96..2458cab029 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
@@ -48,7 +48,7 @@ public partial struct ElectricCurrentGradient : IQuantity<ElectricCurrentGradien
 
         static ElectricCurrentGradient()
         {
-            BaseDimensions = new BaseDimensions(0, 0, -1, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, -1, 1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricCurrentGradientUnit>("ElectricCurrentGradient",
                 new UnitInfo<ElectricCurrentGradientUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
index 100c782634..87824d6cc7 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
@@ -51,7 +51,7 @@ public partial struct ElectricField : IQuantity<ElectricFieldUnit>, IEquatable<E
 
         static ElectricField()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -3, -1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -3, -1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricFieldUnit>("ElectricField",
                 new UnitInfo<ElectricFieldUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
index b9e1c1a2c4..ddda9ee843 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
@@ -51,7 +51,7 @@ public partial struct ElectricInductance : IQuantity<ElectricInductanceUnit>, IE
 
         static ElectricInductance()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, -2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, -2, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricInductanceUnit>("ElectricInductance",
                 new UnitInfo<ElectricInductanceUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
index 1e8967ab9e..5d5205d7a3 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
@@ -48,7 +48,7 @@ public partial struct ElectricPotential : IQuantity<ElectricPotentialUnit>, IEqu
 
         static ElectricPotential()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, -1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, -1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricPotentialUnit>("ElectricPotential",
                 new UnitInfo<ElectricPotentialUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
index 8d7dda5995..f2a017d32e 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
@@ -48,7 +48,7 @@ public partial struct ElectricPotentialChangeRate : IQuantity<ElectricPotentialC
 
         static ElectricPotentialChangeRate()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -4, -1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -4, -1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricPotentialChangeRateUnit>("ElectricPotentialChangeRate",
                 new UnitInfo<ElectricPotentialChangeRateUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
index f8d8c6d8c5..b6fdb9fc9a 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
@@ -48,7 +48,7 @@ public partial struct ElectricResistance : IQuantity<ElectricResistanceUnit>, IE
 
         static ElectricResistance()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, -2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, -2, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricResistanceUnit>("ElectricResistance",
                 new UnitInfo<ElectricResistanceUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
index 3b2c3cdb98..8c8a8862c8 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
@@ -51,7 +51,7 @@ public partial struct ElectricResistivity : IQuantity<ElectricResistivityUnit>,
 
         static ElectricResistivity()
         {
-            BaseDimensions = new BaseDimensions(3, 1, -3, -2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(3, 1, -3, -2, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricResistivityUnit>("ElectricResistivity",
                 new UnitInfo<ElectricResistivityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
index d8d12b7d71..4a9357ea89 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
@@ -51,7 +51,7 @@ public partial struct ElectricSurfaceChargeDensity : IQuantity<ElectricSurfaceCh
 
         static ElectricSurfaceChargeDensity()
         {
-            BaseDimensions = new BaseDimensions(-2, 0, 1, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 0, 1, 1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ElectricSurfaceChargeDensityUnit>("ElectricSurfaceChargeDensity",
                 new UnitInfo<ElectricSurfaceChargeDensityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
index d363c555ad..f17f317543 100644
--- a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
@@ -48,7 +48,7 @@ public partial struct Energy : IQuantity<EnergyUnit>, IEquatable<Energy>, ICompa
 
         static Energy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<EnergyUnit>("Energy",
                 new UnitInfo<EnergyUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
index 2d2ca58f0d..97be2a0e7c 100644
--- a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
@@ -48,7 +48,7 @@ public partial struct Entropy : IQuantity<EntropyUnit>, IEquatable<Entropy>, ICo
 
         static Entropy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, -1, 0, 0, 0);
 
             Info = new QuantityInfo<EntropyUnit>("Entropy",
                 new UnitInfo<EntropyUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
index bf0a87d8b4..f7bf619f45 100644
--- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
@@ -48,7 +48,7 @@ public partial struct Force : IQuantity<ForceUnit>, IEquatable<Force>, IComparab
 
         static Force()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ForceUnit>("Force",
                 new UnitInfo<ForceUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
index ac5fd53d49..ea097e9120 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
@@ -48,7 +48,7 @@ public partial struct ForceChangeRate : IQuantity<ForceChangeRateUnit>, IEquatab
 
         static ForceChangeRate()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ForceChangeRateUnit>("ForceChangeRate",
                 new UnitInfo<ForceChangeRateUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
index 0908af5d75..71dbb58476 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
@@ -48,7 +48,7 @@ public partial struct ForcePerLength : IQuantity<ForcePerLengthUnit>, IEquatable
 
         static ForcePerLength()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ForcePerLengthUnit>("ForcePerLength",
                 new UnitInfo<ForcePerLengthUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
index cb9bcaf77d..82051283e8 100644
--- a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
@@ -48,7 +48,7 @@ public partial struct Frequency : IQuantity<FrequencyUnit>, IEquatable<Frequency
 
         static Frequency()
         {
-            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<FrequencyUnit>("Frequency",
                 new UnitInfo<FrequencyUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
index 1b1038abb8..aad2cbee86 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
@@ -48,7 +48,7 @@ public partial struct HeatFlux : IQuantity<HeatFluxUnit>, IEquatable<HeatFlux>,
 
         static HeatFlux()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -3, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<HeatFluxUnit>("HeatFlux",
                 new UnitInfo<HeatFluxUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
index 0e8bfac3c6..9f6cdc8a76 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
@@ -48,7 +48,7 @@ public partial struct HeatTransferCoefficient : IQuantity<HeatTransferCoefficien
 
         static HeatTransferCoefficient()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -3, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -3, 0, -1, 0, 0, 0);
 
             Info = new QuantityInfo<HeatTransferCoefficientUnit>("HeatTransferCoefficient",
                 new UnitInfo<HeatTransferCoefficientUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
index b6bb8874df..39cb36bb69 100644
--- a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
@@ -51,7 +51,7 @@ public partial struct Illuminance : IQuantity<IlluminanceUnit>, IEquatable<Illum
 
         static Illuminance()
         {
-            BaseDimensions = new BaseDimensions(-2, 0, 0, 0, 0, 0, 1);
+            BaseDimensions = new BaseDimensions(-2, 0, 0, 0, 0, 0, 1, 0);
 
             Info = new QuantityInfo<IlluminanceUnit>("Illuminance",
                 new UnitInfo<IlluminanceUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Information.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
index 32b9c7d385..1285f289c4 100644
--- a/UnitsNet/GeneratedCode/Quantities/Information.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
@@ -48,7 +48,7 @@ public partial struct Information : IQuantity<InformationUnit>, IDecimalQuantity
 
         static Information()
         {
-            BaseDimensions = BaseDimensions.Dimensionless;
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 0, 0, 1);
 
             Info = new QuantityInfo<InformationUnit>("Information",
                 new UnitInfo<InformationUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
index 50ecdf78ba..1d21c52789 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
@@ -48,7 +48,7 @@ public partial struct Irradiance : IQuantity<IrradianceUnit>, IEquatable<Irradia
 
         static Irradiance()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -3, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<IrradianceUnit>("Irradiance",
                 new UnitInfo<IrradianceUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
index 9f3829ede2..bee26f7efb 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
@@ -51,7 +51,7 @@ public partial struct Irradiation : IQuantity<IrradiationUnit>, IEquatable<Irrad
 
         static Irradiation()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<IrradiationUnit>("Irradiation",
                 new UnitInfo<IrradiationUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
index 450ea9a0b9..a4169777cd 100644
--- a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
@@ -51,7 +51,7 @@ public partial struct KinematicViscosity : IQuantity<KinematicViscosityUnit>, IE
 
         static KinematicViscosity()
         {
-            BaseDimensions = new BaseDimensions(2, 0, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 0, -1, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<KinematicViscosityUnit>("KinematicViscosity",
                 new UnitInfo<KinematicViscosityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs b/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs
index 424d4d0d9b..7f78e40398 100644
--- a/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LapseRate.g.cs
@@ -48,7 +48,7 @@ public partial struct LapseRate : IQuantity<LapseRateUnit>, IEquatable<LapseRate
 
         static LapseRate()
         {
-            BaseDimensions = new BaseDimensions(-1, 0, 0, 0, 1, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 0, 0, 0, 1, 0, 0, 0);
 
             Info = new QuantityInfo<LapseRateUnit>("LapseRate",
                 new UnitInfo<LapseRateUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Length.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
index 28fe924cb1..6f694efe5d 100644
--- a/UnitsNet/GeneratedCode/Quantities/Length.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
@@ -48,7 +48,7 @@ public partial struct Length : IQuantity<LengthUnit>, IEquatable<Length>, ICompa
 
         static Length()
         {
-            BaseDimensions = new BaseDimensions(1, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 0, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<LengthUnit>("Length",
                 new UnitInfo<LengthUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
index 2850dda697..d216512c6d 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
@@ -51,7 +51,7 @@ public partial struct LinearDensity : IQuantity<LinearDensityUnit>, IEquatable<L
 
         static LinearDensity()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<LinearDensityUnit>("LinearDensity",
                 new UnitInfo<LinearDensityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
index c7ecc66066..5bd26bb594 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
@@ -51,7 +51,7 @@ public partial struct LinearPowerDensity : IQuantity<LinearPowerDensityUnit>, IE
 
         static LinearPowerDensity()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<LinearPowerDensityUnit>("LinearPowerDensity",
                 new UnitInfo<LinearPowerDensityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
index 26b57be183..e9554c8543 100644
--- a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
@@ -51,7 +51,7 @@ public partial struct Luminosity : IQuantity<LuminosityUnit>, IEquatable<Luminos
 
         static Luminosity()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<LuminosityUnit>("Luminosity",
                 new UnitInfo<LuminosityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
index 37aef29d6f..2365e68f1b 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
@@ -51,7 +51,7 @@ public partial struct LuminousFlux : IQuantity<LuminousFluxUnit>, IEquatable<Lum
 
         static LuminousFlux()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 0, 1);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 0, 1, 0);
 
             Info = new QuantityInfo<LuminousFluxUnit>("LuminousFlux",
                 new UnitInfo<LuminousFluxUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
index 301782522b..6ea8da04d9 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
@@ -51,7 +51,7 @@ public partial struct LuminousIntensity : IQuantity<LuminousIntensityUnit>, IEqu
 
         static LuminousIntensity()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 0, 1);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 0, 0, 1, 0);
 
             Info = new QuantityInfo<LuminousIntensityUnit>("LuminousIntensity",
                 new UnitInfo<LuminousIntensityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
index 93f2e9b8ae..3746b99904 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
@@ -51,7 +51,7 @@ public partial struct MagneticField : IQuantity<MagneticFieldUnit>, IEquatable<M
 
         static MagneticField()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -2, -1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -2, -1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<MagneticFieldUnit>("MagneticField",
                 new UnitInfo<MagneticFieldUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
index afb0404ff1..7992a61a55 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
@@ -51,7 +51,7 @@ public partial struct MagneticFlux : IQuantity<MagneticFluxUnit>, IEquatable<Mag
 
         static MagneticFlux()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, -1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, -1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<MagneticFluxUnit>("MagneticFlux",
                 new UnitInfo<MagneticFluxUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
index 7361e5684d..d395777c1f 100644
--- a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
@@ -51,7 +51,7 @@ public partial struct Magnetization : IQuantity<MagnetizationUnit>, IEquatable<M
 
         static Magnetization()
         {
-            BaseDimensions = new BaseDimensions(-1, 0, 0, 1, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 0, 0, 1, 0, 0, 0, 0);
 
             Info = new QuantityInfo<MagnetizationUnit>("Magnetization",
                 new UnitInfo<MagnetizationUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
index a8e7635172..530710e99c 100644
--- a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
@@ -48,7 +48,7 @@ public partial struct Mass : IQuantity<MassUnit>, IEquatable<Mass>, IComparable,
 
         static Mass()
         {
-            BaseDimensions = new BaseDimensions(0, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<MassUnit>("Mass",
                 new UnitInfo<MassUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
index d59c9b2676..9c1c40ff00 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
@@ -51,7 +51,7 @@ public partial struct MassConcentration : IQuantity<MassConcentrationUnit>, IEqu
 
         static MassConcentration()
         {
-            BaseDimensions = new BaseDimensions(-3, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-3, 1, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<MassConcentrationUnit>("MassConcentration",
                 new UnitInfo<MassConcentrationUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
index 960dbdf305..d41a963623 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
@@ -48,7 +48,7 @@ public partial struct MassFlow : IQuantity<MassFlowUnit>, IEquatable<MassFlow>,
 
         static MassFlow()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -1, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<MassFlowUnit>("MassFlow",
                 new UnitInfo<MassFlowUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
index 38a603fdf9..e6d6558930 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
@@ -48,7 +48,7 @@ public partial struct MassFlux : IQuantity<MassFluxUnit>, IEquatable<MassFlux>,
 
         static MassFlux()
         {
-            BaseDimensions = new BaseDimensions(-2, 1, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 1, -1, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<MassFluxUnit>("MassFlux",
                 new UnitInfo<MassFluxUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
index d56a50f788..2fccf062f5 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
@@ -48,7 +48,7 @@ public partial struct MassMomentOfInertia : IQuantity<MassMomentOfInertiaUnit>,
 
         static MassMomentOfInertia()
         {
-            BaseDimensions = new BaseDimensions(2, 1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<MassMomentOfInertiaUnit>("MassMomentOfInertia",
                 new UnitInfo<MassMomentOfInertiaUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
index fd1557a30d..516b74d03a 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
@@ -48,7 +48,7 @@ public partial struct MolarEnergy : IQuantity<MolarEnergyUnit>, IEquatable<Molar
 
         static MolarEnergy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, -1, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, -1, 0, 0);
 
             Info = new QuantityInfo<MolarEnergyUnit>("MolarEnergy",
                 new UnitInfo<MolarEnergyUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
index 7156cff419..d0c31e1161 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
@@ -48,7 +48,7 @@ public partial struct MolarEntropy : IQuantity<MolarEntropyUnit>, IEquatable<Mol
 
         static MolarEntropy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, -1, -1, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, -1, -1, 0, 0);
 
             Info = new QuantityInfo<MolarEntropyUnit>("MolarEntropy",
                 new UnitInfo<MolarEntropyUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
index 19f82649e4..44260eb451 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
@@ -48,7 +48,7 @@ public partial struct MolarMass : IQuantity<MolarMassUnit>, IEquatable<MolarMass
 
         static MolarMass()
         {
-            BaseDimensions = new BaseDimensions(0, 1, 0, 0, 0, -1, 0);
+            BaseDimensions = new BaseDimensions(0, 1, 0, 0, 0, -1, 0, 0);
 
             Info = new QuantityInfo<MolarMassUnit>("MolarMass",
                 new UnitInfo<MolarMassUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
index a5b5fd7e6b..fcc4cad82e 100644
--- a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
@@ -51,7 +51,7 @@ public partial struct Molarity : IQuantity<MolarityUnit>, IEquatable<Molarity>,
 
         static Molarity()
         {
-            BaseDimensions = new BaseDimensions(-3, 0, 0, 0, 0, 1, 0);
+            BaseDimensions = new BaseDimensions(-3, 0, 0, 0, 0, 1, 0, 0);
 
             Info = new QuantityInfo<MolarityUnit>("Molarity",
                 new UnitInfo<MolarityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
index 938143c27b..8d76055b71 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
@@ -51,7 +51,7 @@ public partial struct Permeability : IQuantity<PermeabilityUnit>, IEquatable<Per
 
         static Permeability()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -2, -2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -2, -2, 0, 0, 0, 0);
 
             Info = new QuantityInfo<PermeabilityUnit>("Permeability",
                 new UnitInfo<PermeabilityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
index 3ff1b84ed6..a9bf9063b4 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
@@ -51,7 +51,7 @@ public partial struct Permittivity : IQuantity<PermittivityUnit>, IEquatable<Per
 
         static Permittivity()
         {
-            BaseDimensions = new BaseDimensions(-3, -1, 4, 2, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-3, -1, 4, 2, 0, 0, 0, 0);
 
             Info = new QuantityInfo<PermittivityUnit>("Permittivity",
                 new UnitInfo<PermittivityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Power.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
index 44537fc22d..f24415e975 100644
--- a/UnitsNet/GeneratedCode/Quantities/Power.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
@@ -48,7 +48,7 @@ public partial struct Power : IQuantity<PowerUnit>, IDecimalQuantity, IEquatable
 
         static Power()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<PowerUnit>("Power",
                 new UnitInfo<PowerUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
index 92ad77ae45..df7e8f5c43 100644
--- a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
@@ -48,7 +48,7 @@ public partial struct PowerDensity : IQuantity<PowerDensityUnit>, IEquatable<Pow
 
         static PowerDensity()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, -3, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<PowerDensityUnit>("PowerDensity",
                 new UnitInfo<PowerDensityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
index 87958096df..66c419a97c 100644
--- a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
@@ -48,7 +48,7 @@ public partial struct Pressure : IQuantity<PressureUnit>, IEquatable<Pressure>,
 
         static Pressure()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<PressureUnit>("Pressure",
                 new UnitInfo<PressureUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
index 91cb3ae47e..db2c07f104 100644
--- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
@@ -48,7 +48,7 @@ public partial struct PressureChangeRate : IQuantity<PressureChangeRateUnit>, IE
 
         static PressureChangeRate()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, -3, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<PressureChangeRateUnit>("PressureChangeRate",
                 new UnitInfo<PressureChangeRateUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
index 9405a11cc2..35a5fdc3b0 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
@@ -48,7 +48,7 @@ public partial struct ReactiveEnergy : IQuantity<ReactiveEnergyUnit>, IEquatable
 
         static ReactiveEnergy()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -1, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ReactiveEnergyUnit>("ReactiveEnergy",
                 new UnitInfo<ReactiveEnergyUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
index a2fc6356d7..2f1164a56c 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
@@ -48,7 +48,7 @@ public partial struct ReactivePower : IQuantity<ReactivePowerUnit>, IEquatable<R
 
         static ReactivePower()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ReactivePowerUnit>("ReactivePower",
                 new UnitInfo<ReactivePowerUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
index 82e64503f2..3723d44b24 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
@@ -51,7 +51,7 @@ public partial struct ReciprocalArea : IQuantity<ReciprocalAreaUnit>, IEquatable
 
         static ReciprocalArea()
         {
-            BaseDimensions = new BaseDimensions(-2, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 0, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ReciprocalAreaUnit>("ReciprocalArea",
                 new UnitInfo<ReciprocalAreaUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
index 124d5ce4a5..c9f064dd30 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
@@ -51,7 +51,7 @@ public partial struct ReciprocalLength : IQuantity<ReciprocalLengthUnit>, IEquat
 
         static ReciprocalLength()
         {
-            BaseDimensions = new BaseDimensions(-1, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 0, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<ReciprocalLengthUnit>("ReciprocalLength",
                 new UnitInfo<ReciprocalLengthUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
index 43be0eca36..ab489203dc 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
@@ -48,7 +48,7 @@ public partial struct RotationalAcceleration : IQuantity<RotationalAccelerationU
 
         static RotationalAcceleration()
         {
-            BaseDimensions = new BaseDimensions(0, 0, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<RotationalAccelerationUnit>("RotationalAcceleration",
                 new UnitInfo<RotationalAccelerationUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
index 6c35060b63..0b1f369198 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
@@ -48,7 +48,7 @@ public partial struct RotationalSpeed : IQuantity<RotationalSpeedUnit>, IEquatab
 
         static RotationalSpeed()
         {
-            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<RotationalSpeedUnit>("RotationalSpeed",
                 new UnitInfo<RotationalSpeedUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
index fd02a0b23d..4f9d0c226a 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
@@ -48,7 +48,7 @@ public partial struct RotationalStiffness : IQuantity<RotationalStiffnessUnit>,
 
         static RotationalStiffness()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<RotationalStiffnessUnit>("RotationalStiffness",
                 new UnitInfo<RotationalStiffnessUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
index 75a982e461..0d7612b2c3 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
@@ -48,7 +48,7 @@ public partial struct RotationalStiffnessPerLength : IQuantity<RotationalStiffne
 
         static RotationalStiffnessPerLength()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<RotationalStiffnessPerLengthUnit>("RotationalStiffnessPerLength",
                 new UnitInfo<RotationalStiffnessPerLengthUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
index 16ba113950..1126ac0ad7 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
@@ -51,7 +51,7 @@ public partial struct SpecificEnergy : IQuantity<SpecificEnergyUnit>, IEquatable
 
         static SpecificEnergy()
         {
-            BaseDimensions = new BaseDimensions(2, 0, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 0, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<SpecificEnergyUnit>("SpecificEnergy",
                 new UnitInfo<SpecificEnergyUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
index 4599bda2d2..77e57328f2 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
@@ -48,7 +48,7 @@ public partial struct SpecificEntropy : IQuantity<SpecificEntropyUnit>, IEquatab
 
         static SpecificEntropy()
         {
-            BaseDimensions = new BaseDimensions(2, 0, -2, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 0, -2, 0, -1, 0, 0, 0);
 
             Info = new QuantityInfo<SpecificEntropyUnit>("SpecificEntropy",
                 new UnitInfo<SpecificEntropyUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
index c7b0c0fab3..6ce8a16cc5 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
@@ -48,7 +48,7 @@ public partial struct SpecificVolume : IQuantity<SpecificVolumeUnit>, IEquatable
 
         static SpecificVolume()
         {
-            BaseDimensions = new BaseDimensions(3, -1, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(3, -1, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<SpecificVolumeUnit>("SpecificVolume",
                 new UnitInfo<SpecificVolumeUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
index f4885a0cda..808720e832 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
@@ -51,7 +51,7 @@ public partial struct SpecificWeight : IQuantity<SpecificWeightUnit>, IEquatable
 
         static SpecificWeight()
         {
-            BaseDimensions = new BaseDimensions(-2, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(-2, 1, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<SpecificWeightUnit>("SpecificWeight",
                 new UnitInfo<SpecificWeightUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
index e7a1a13a7e..267a6cb724 100644
--- a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
@@ -48,7 +48,7 @@ public partial struct Speed : IQuantity<SpeedUnit>, IEquatable<Speed>, IComparab
 
         static Speed()
         {
-            BaseDimensions = new BaseDimensions(1, 0, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 0, -1, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<SpeedUnit>("Speed",
                 new UnitInfo<SpeedUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
index bde9ddb503..0462c5e088 100644
--- a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
@@ -48,7 +48,7 @@ public partial struct StandardVolumeFlow : IQuantity<StandardVolumeFlowUnit>, IE
 
         static StandardVolumeFlow()
         {
-            BaseDimensions = new BaseDimensions(0, 1, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 1, -1, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<StandardVolumeFlowUnit>("StandardVolumeFlow",
                 new UnitInfo<StandardVolumeFlowUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
index 3a55402be9..1ce8fe9a36 100644
--- a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
@@ -48,7 +48,7 @@ public partial struct Temperature : IQuantity<TemperatureUnit>, IEquatable<Tempe
 
         static Temperature()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 1, 0, 0, 0);
 
             Info = new QuantityInfo<TemperatureUnit>("Temperature",
                 new UnitInfo<TemperatureUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
index a4268424ac..038c493d5f 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
@@ -48,7 +48,7 @@ public partial struct TemperatureChangeRate : IQuantity<TemperatureChangeRateUni
 
         static TemperatureChangeRate()
         {
-            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, -1, 0, 1, 0, 0, 0);
 
             Info = new QuantityInfo<TemperatureChangeRateUnit>("TemperatureChangeRate",
                 new UnitInfo<TemperatureChangeRateUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
index d7a8c8d2bd..e4d6719efa 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
@@ -48,7 +48,7 @@ public partial struct TemperatureDelta : IQuantity<TemperatureDeltaUnit>, IEquat
 
         static TemperatureDelta()
         {
-            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, 0, 0, 0, 1, 0, 0, 0);
 
             Info = new QuantityInfo<TemperatureDeltaUnit>("TemperatureDelta",
                 new UnitInfo<TemperatureDeltaUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
index 32672a6abf..d86eb20b94 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
@@ -51,7 +51,7 @@ public partial struct ThermalConductivity : IQuantity<ThermalConductivityUnit>,
 
         static ThermalConductivity()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -3, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -3, 0, -1, 0, 0, 0);
 
             Info = new QuantityInfo<ThermalConductivityUnit>("ThermalConductivity",
                 new UnitInfo<ThermalConductivityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
index b71032087b..89ee1a6aef 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
@@ -48,7 +48,7 @@ public partial struct ThermalResistance : IQuantity<ThermalResistanceUnit>, IEqu
 
         static ThermalResistance()
         {
-            BaseDimensions = new BaseDimensions(0, -1, 3, 0, 1, 0, 0);
+            BaseDimensions = new BaseDimensions(0, -1, 3, 0, 1, 0, 0, 0);
 
             Info = new QuantityInfo<ThermalResistanceUnit>("ThermalResistance",
                 new UnitInfo<ThermalResistanceUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
index d76316d26a..74e1f399bc 100644
--- a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
@@ -48,7 +48,7 @@ public partial struct Torque : IQuantity<TorqueUnit>, IEquatable<Torque>, ICompa
 
         static Torque()
         {
-            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 1, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<TorqueUnit>("Torque",
                 new UnitInfo<TorqueUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
index db9da5351e..c40ee1f6fa 100644
--- a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
@@ -48,7 +48,7 @@ public partial struct TorquePerLength : IQuantity<TorquePerLengthUnit>, IEquatab
 
         static TorquePerLength()
         {
-            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(1, 1, -2, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<TorquePerLengthUnit>("TorquePerLength",
                 new UnitInfo<TorquePerLengthUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
index 58212e7ac5..4a8d862fd5 100644
--- a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
@@ -48,7 +48,7 @@ public partial struct Volume : IQuantity<VolumeUnit>, IEquatable<Volume>, ICompa
 
         static Volume()
         {
-            BaseDimensions = new BaseDimensions(3, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(3, 0, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<VolumeUnit>("Volume",
                 new UnitInfo<VolumeUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
index e30cd6deab..ba490a3374 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
@@ -48,7 +48,7 @@ public partial struct VolumeFlow : IQuantity<VolumeFlowUnit>, IEquatable<VolumeF
 
         static VolumeFlow()
         {
-            BaseDimensions = new BaseDimensions(3, 0, -1, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(3, 0, -1, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<VolumeFlowUnit>("VolumeFlow",
                 new UnitInfo<VolumeFlowUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
index af31a30115..5c4883f986 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
@@ -48,7 +48,7 @@ public partial struct VolumePerLength : IQuantity<VolumePerLengthUnit>, IEquatab
 
         static VolumePerLength()
         {
-            BaseDimensions = new BaseDimensions(2, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(2, 0, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<VolumePerLengthUnit>("VolumePerLength",
                 new UnitInfo<VolumePerLengthUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
index b1e1ffd9e4..057865c86b 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
@@ -51,7 +51,7 @@ public partial struct VolumetricHeatCapacity : IQuantity<VolumetricHeatCapacityU
 
         static VolumetricHeatCapacity()
         {
-            BaseDimensions = new BaseDimensions(-1, 1, -2, 0, -1, 0, 0);
+            BaseDimensions = new BaseDimensions(-1, 1, -2, 0, -1, 0, 0, 0);
 
             Info = new QuantityInfo<VolumetricHeatCapacityUnit>("VolumetricHeatCapacity",
                 new UnitInfo<VolumetricHeatCapacityUnit>[] {
diff --git a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
index ca4bcb780c..eefce6664e 100644
--- a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
@@ -48,7 +48,7 @@ public partial struct WarpingMomentOfInertia : IQuantity<WarpingMomentOfInertiaU
 
         static WarpingMomentOfInertia()
         {
-            BaseDimensions = new BaseDimensions(6, 0, 0, 0, 0, 0, 0);
+            BaseDimensions = new BaseDimensions(6, 0, 0, 0, 0, 0, 0, 0);
 
             Info = new QuantityInfo<WarpingMomentOfInertiaUnit>("WarpingMomentOfInertia",
                 new UnitInfo<WarpingMomentOfInertiaUnit>[] {