From 3b7a09873bf55f9a91aa9a15d1951099af9192c5 Mon Sep 17 00:00:00 2001
From: Andreas Gullberg Larsen <andreas.larsen84@gmail.com>
Date: Tue, 7 Jan 2020 21:34:06 +0100
Subject: [PATCH 01/15] Upgrade nugets in UnitsNet.Benchmark

---
 UnitsNet.Benchmark/UnitsNet.Benchmark.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/UnitsNet.Benchmark/UnitsNet.Benchmark.csproj b/UnitsNet.Benchmark/UnitsNet.Benchmark.csproj
index 3d4705983b..31c7f667ef 100644
--- a/UnitsNet.Benchmark/UnitsNet.Benchmark.csproj
+++ b/UnitsNet.Benchmark/UnitsNet.Benchmark.csproj
@@ -15,7 +15,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
-    <PackageReference Include="CommandLineParser" Version="2.6.0" />
+    <PackageReference Include="CommandLineParser" Version="2.7.82" />
     <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="2.9.8">
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

From f992e9d362877e07c9c26ce45c381aec94544321 Mon Sep 17 00:00:00 2001
From: Andreas Gullberg Larsen <andreas.larsen84@gmail.com>
Date: Tue, 7 Jan 2020 21:39:53 +0100
Subject: [PATCH 02/15] JsonNet/4.1.0

---
 .../UnitsNet.Serialization.JsonNet.csproj                      | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj b/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj
index 1f4061d9a7..a05f0c6c3a 100644
--- a/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj
+++ b/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj
@@ -2,7 +2,7 @@
   <!-- NuGet properties -->
   <PropertyGroup>
     <PackageId>UnitsNet.Serialization.JsonNet</PackageId>
-    <Version>4.0.0</Version>
+    <Version>4.1.0</Version>
     <Authors>Andreas Gullberg Larsen</Authors>
     <Title>Units.NET Serialization with Json.NET</Title>
     <Description>A helper library for serializing and deserializing types in Units.NET using Json.NET.</Description>
@@ -14,6 +14,7 @@
     <PackageLicenseExpression>MIT-0</PackageLicenseExpression>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>unit units measurement json Json.NET Newtonsoft serialize deserialize serialization deserialization</PackageTags>
+    <PackageReleaseNotes>Upgrade JSON.NET to 12.0.3.</PackageReleaseNotes>
   </PropertyGroup>
 
   <!-- Assembly and msbuild properties -->

From c302e3360669bd93b42d951f8526b25b66523c3f Mon Sep 17 00:00:00 2001
From: Andreas Gullberg Larsen <andreas.larsen84@gmail.com>
Date: Tue, 7 Jan 2020 21:42:22 +0100
Subject: [PATCH 03/15] JsonNet/4.1.1

Forgot to include release note about supporting arrays.
---
 .../UnitsNet.Serialization.JsonNet.csproj                     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj b/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj
index a05f0c6c3a..2835decfd8 100644
--- a/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj
+++ b/UnitsNet.Serialization.JsonNet/UnitsNet.Serialization.JsonNet.csproj
@@ -2,7 +2,7 @@
   <!-- NuGet properties -->
   <PropertyGroup>
     <PackageId>UnitsNet.Serialization.JsonNet</PackageId>
-    <Version>4.1.0</Version>
+    <Version>4.1.1</Version>
     <Authors>Andreas Gullberg Larsen</Authors>
     <Title>Units.NET Serialization with Json.NET</Title>
     <Description>A helper library for serializing and deserializing types in Units.NET using Json.NET.</Description>
@@ -14,7 +14,7 @@
     <PackageLicenseExpression>MIT-0</PackageLicenseExpression>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>unit units measurement json Json.NET Newtonsoft serialize deserialize serialization deserialization</PackageTags>
-    <PackageReleaseNotes>Upgrade JSON.NET to 12.0.3.</PackageReleaseNotes>
+    <PackageReleaseNotes>Upgrade JSON.NET to 12.0.3. Support arrays.</PackageReleaseNotes>
   </PropertyGroup>
 
   <!-- Assembly and msbuild properties -->

From 4dda46edf692fd84ca4385aeb2000a7f0d98a16d Mon Sep 17 00:00:00 2001
From: Jan Paolo Go <go.janpaolo@gmail.com>
Date: Sat, 11 Jan 2020 14:02:34 -0600
Subject: [PATCH 04/15] Add VolumePerLength yd3 / ft and ftUS (#734)

---
 Common/UnitDefinitions/VolumePerLength.json   | 24 +++++++++++++
 .../CustomCode/VolumePerLengthTests.cs        |  4 +++
 .../VolumePerLengthTestsBase.g.cs             | 20 +++++++++++
 .../Quantities/VolumePerLength.g.cs           | 34 +++++++++++++++++++
 .../GeneratedCode/UnitAbbreviationsCache.g.cs |  2 ++
 .../Units/VolumePerLengthUnit.g.cs            |  2 ++
 .../Quantities/VolumePerLength.g.cs           | 34 +++++++++++++++++++
 .../GeneratedCode/UnitAbbreviationsCache.g.cs |  2 ++
 UnitsNet/GeneratedCode/UnitConverter.g.cs     |  4 +++
 .../Units/VolumePerLengthUnit.g.cs            |  2 ++
 10 files changed, 128 insertions(+)

diff --git a/Common/UnitDefinitions/VolumePerLength.json b/Common/UnitDefinitions/VolumePerLength.json
index 5090700bbc..5818df9069 100644
--- a/Common/UnitDefinitions/VolumePerLength.json
+++ b/Common/UnitDefinitions/VolumePerLength.json
@@ -50,6 +50,30 @@
           "Abbreviations": [ "bbl/ft" ]
         }
       ]
+    },
+    {
+      "SingularName": "CubicYardPerFoot",
+      "PluralName": "CubicYardsPerFoot",
+      "FromUnitToBaseFunc": "x*2.50838208",
+      "FromBaseToUnitFunc": "x/2.50838208",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "yd³/ft" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "CubicYardPerUsSurveyFoot",
+      "PluralName": "CubicYardsPerUsSurveyFoot",
+      "FromUnitToBaseFunc": "x*2.50837706323584",
+      "FromBaseToUnitFunc": "x/2.50837706323584",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "yd³/ftUS" ]
+        }
+      ]
     }
   ]
 }
diff --git a/UnitsNet.Tests/CustomCode/VolumePerLengthTests.cs b/UnitsNet.Tests/CustomCode/VolumePerLengthTests.cs
index 8be2e9cfed..323889d02f 100644
--- a/UnitsNet.Tests/CustomCode/VolumePerLengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumePerLengthTests.cs
@@ -32,5 +32,9 @@ public class VolumePerLengthTests : VolumePerLengthTestsBase
         protected override double LitersPerMeterInOneCubicMeterPerMeter => 1000;
 
         protected override double OilBarrelsPerFootInOneCubicMeterPerMeter => 1.917134088;
+
+        protected override double CubicYardsPerFootInOneCubicMeterPerMeter => 0.3986633487670267521605;
+        
+        protected override double CubicYardsPerUsSurveyFootInOneCubicMeterPerMeter => 0.3986641460953189427984;
     }
 }
diff --git a/UnitsNet.Tests/GeneratedCode/VolumePerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumePerLengthTestsBase.g.cs
index e28c1081d4..292f0d45ad 100644
--- a/UnitsNet.Tests/GeneratedCode/VolumePerLengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/VolumePerLengthTestsBase.g.cs
@@ -35,11 +35,15 @@ namespace UnitsNet.Tests
     public abstract partial class VolumePerLengthTestsBase
     {
         protected abstract double CubicMetersPerMeterInOneCubicMeterPerMeter { get; }
+        protected abstract double CubicYardsPerFootInOneCubicMeterPerMeter { get; }
+        protected abstract double CubicYardsPerUsSurveyFootInOneCubicMeterPerMeter { get; }
         protected abstract double LitersPerMeterInOneCubicMeterPerMeter { get; }
         protected abstract double OilBarrelsPerFootInOneCubicMeterPerMeter { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double CubicMetersPerMeterTolerance { get { return 1e-5; } }
+        protected virtual double CubicYardsPerFootTolerance { get { return 1e-5; } }
+        protected virtual double CubicYardsPerUsSurveyFootTolerance { get { return 1e-5; } }
         protected virtual double LitersPerMeterTolerance { get { return 1e-5; } }
         protected virtual double OilBarrelsPerFootTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
@@ -68,6 +72,8 @@ public void CubicMeterPerMeterToVolumePerLengthUnits()
         {
             VolumePerLength cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
             AssertEx.EqualTolerance(CubicMetersPerMeterInOneCubicMeterPerMeter, cubicmeterpermeter.CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(CubicYardsPerFootInOneCubicMeterPerMeter, cubicmeterpermeter.CubicYardsPerFoot, CubicYardsPerFootTolerance);
+            AssertEx.EqualTolerance(CubicYardsPerUsSurveyFootInOneCubicMeterPerMeter, cubicmeterpermeter.CubicYardsPerUsSurveyFoot, CubicYardsPerUsSurveyFootTolerance);
             AssertEx.EqualTolerance(LitersPerMeterInOneCubicMeterPerMeter, cubicmeterpermeter.LitersPerMeter, LitersPerMeterTolerance);
             AssertEx.EqualTolerance(OilBarrelsPerFootInOneCubicMeterPerMeter, cubicmeterpermeter.OilBarrelsPerFoot, OilBarrelsPerFootTolerance);
         }
@@ -76,6 +82,8 @@ public void CubicMeterPerMeterToVolumePerLengthUnits()
         public void FromValueAndUnit()
         {
             AssertEx.EqualTolerance(1, VolumePerLength.From(1, VolumePerLengthUnit.CubicMeterPerMeter).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength.From(1, VolumePerLengthUnit.CubicYardPerFoot).CubicYardsPerFoot, CubicYardsPerFootTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength.From(1, VolumePerLengthUnit.CubicYardPerUsSurveyFoot).CubicYardsPerUsSurveyFoot, CubicYardsPerUsSurveyFootTolerance);
             AssertEx.EqualTolerance(1, VolumePerLength.From(1, VolumePerLengthUnit.LiterPerMeter).LitersPerMeter, LitersPerMeterTolerance);
             AssertEx.EqualTolerance(1, VolumePerLength.From(1, VolumePerLengthUnit.OilBarrelPerFoot).OilBarrelsPerFoot, OilBarrelsPerFootTolerance);
         }
@@ -98,6 +106,8 @@ public void As()
         {
             var cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
             AssertEx.EqualTolerance(CubicMetersPerMeterInOneCubicMeterPerMeter, cubicmeterpermeter.As(VolumePerLengthUnit.CubicMeterPerMeter), CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(CubicYardsPerFootInOneCubicMeterPerMeter, cubicmeterpermeter.As(VolumePerLengthUnit.CubicYardPerFoot), CubicYardsPerFootTolerance);
+            AssertEx.EqualTolerance(CubicYardsPerUsSurveyFootInOneCubicMeterPerMeter, cubicmeterpermeter.As(VolumePerLengthUnit.CubicYardPerUsSurveyFoot), CubicYardsPerUsSurveyFootTolerance);
             AssertEx.EqualTolerance(LitersPerMeterInOneCubicMeterPerMeter, cubicmeterpermeter.As(VolumePerLengthUnit.LiterPerMeter), LitersPerMeterTolerance);
             AssertEx.EqualTolerance(OilBarrelsPerFootInOneCubicMeterPerMeter, cubicmeterpermeter.As(VolumePerLengthUnit.OilBarrelPerFoot), OilBarrelsPerFootTolerance);
         }
@@ -111,6 +121,14 @@ public void ToUnit()
             AssertEx.EqualTolerance(CubicMetersPerMeterInOneCubicMeterPerMeter, (double)cubicmeterpermeterQuantity.Value, CubicMetersPerMeterTolerance);
             Assert.Equal(VolumePerLengthUnit.CubicMeterPerMeter, cubicmeterpermeterQuantity.Unit);
 
+            var cubicyardperfootQuantity = cubicmeterpermeter.ToUnit(VolumePerLengthUnit.CubicYardPerFoot);
+            AssertEx.EqualTolerance(CubicYardsPerFootInOneCubicMeterPerMeter, (double)cubicyardperfootQuantity.Value, CubicYardsPerFootTolerance);
+            Assert.Equal(VolumePerLengthUnit.CubicYardPerFoot, cubicyardperfootQuantity.Unit);
+
+            var cubicyardperussurveyfootQuantity = cubicmeterpermeter.ToUnit(VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
+            AssertEx.EqualTolerance(CubicYardsPerUsSurveyFootInOneCubicMeterPerMeter, (double)cubicyardperussurveyfootQuantity.Value, CubicYardsPerUsSurveyFootTolerance);
+            Assert.Equal(VolumePerLengthUnit.CubicYardPerUsSurveyFoot, cubicyardperussurveyfootQuantity.Unit);
+
             var literpermeterQuantity = cubicmeterpermeter.ToUnit(VolumePerLengthUnit.LiterPerMeter);
             AssertEx.EqualTolerance(LitersPerMeterInOneCubicMeterPerMeter, (double)literpermeterQuantity.Value, LitersPerMeterTolerance);
             Assert.Equal(VolumePerLengthUnit.LiterPerMeter, literpermeterQuantity.Unit);
@@ -125,6 +143,8 @@ public void ConversionRoundTrip()
         {
             VolumePerLength cubicmeterpermeter = VolumePerLength.FromCubicMetersPerMeter(1);
             AssertEx.EqualTolerance(1, VolumePerLength.FromCubicMetersPerMeter(cubicmeterpermeter.CubicMetersPerMeter).CubicMetersPerMeter, CubicMetersPerMeterTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength.FromCubicYardsPerFoot(cubicmeterpermeter.CubicYardsPerFoot).CubicMetersPerMeter, CubicYardsPerFootTolerance);
+            AssertEx.EqualTolerance(1, VolumePerLength.FromCubicYardsPerUsSurveyFoot(cubicmeterpermeter.CubicYardsPerUsSurveyFoot).CubicMetersPerMeter, CubicYardsPerUsSurveyFootTolerance);
             AssertEx.EqualTolerance(1, VolumePerLength.FromLitersPerMeter(cubicmeterpermeter.LitersPerMeter).CubicMetersPerMeter, LitersPerMeterTolerance);
             AssertEx.EqualTolerance(1, VolumePerLength.FromOilBarrelsPerFoot(cubicmeterpermeter.OilBarrelsPerFoot).CubicMetersPerMeter, OilBarrelsPerFootTolerance);
         }
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs
index c87f6d5cc5..fa5dd927ab 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/VolumePerLength.g.cs
@@ -160,6 +160,16 @@ private VolumePerLength(double value, VolumePerLengthUnit unit)
         /// </summary>
         public double CubicMetersPerMeter => As(VolumePerLengthUnit.CubicMeterPerMeter);
 
+        /// <summary>
+        ///     Get VolumePerLength in CubicYardsPerFoot.
+        /// </summary>
+        public double CubicYardsPerFoot => As(VolumePerLengthUnit.CubicYardPerFoot);
+
+        /// <summary>
+        ///     Get VolumePerLength in CubicYardsPerUsSurveyFoot.
+        /// </summary>
+        public double CubicYardsPerUsSurveyFoot => As(VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
+
         /// <summary>
         ///     Get VolumePerLength in LitersPerMeter.
         /// </summary>
@@ -211,6 +221,26 @@ public static VolumePerLength FromCubicMetersPerMeter(double cubicmeterspermeter
             return new VolumePerLength(value, VolumePerLengthUnit.CubicMeterPerMeter);
         }
         /// <summary>
+        ///     Get VolumePerLength from CubicYardsPerFoot.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static VolumePerLength FromCubicYardsPerFoot(double cubicyardsperfoot)
+        {
+            double value = (double) cubicyardsperfoot;
+            return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerFoot);
+        }
+        /// <summary>
+        ///     Get VolumePerLength from CubicYardsPerUsSurveyFoot.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static VolumePerLength FromCubicYardsPerUsSurveyFoot(double cubicyardsperussurveyfoot)
+        {
+            double value = (double) cubicyardsperussurveyfoot;
+            return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
+        }
+        /// <summary>
         ///     Get VolumePerLength from LitersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
@@ -522,6 +552,8 @@ private double AsBaseUnit()
             switch(Unit)
             {
                 case VolumePerLengthUnit.CubicMeterPerMeter: return _value;
+                case VolumePerLengthUnit.CubicYardPerFoot: return _value*2.50838208;
+                case VolumePerLengthUnit.CubicYardPerUsSurveyFoot: return _value*2.50837706323584;
                 case VolumePerLengthUnit.LiterPerMeter: return _value/1000;
                 case VolumePerLengthUnit.OilBarrelPerFoot: return _value/1.91713408;
                 default:
@@ -539,6 +571,8 @@ private double AsBaseNumericType(VolumePerLengthUnit unit)
             switch(unit)
             {
                 case VolumePerLengthUnit.CubicMeterPerMeter: return baseUnitValue;
+                case VolumePerLengthUnit.CubicYardPerFoot: return baseUnitValue/2.50838208;
+                case VolumePerLengthUnit.CubicYardPerUsSurveyFoot: return baseUnitValue/2.50837706323584;
                 case VolumePerLengthUnit.LiterPerMeter: return baseUnitValue*1000;
                 case VolumePerLengthUnit.OilBarrelPerFoot: return baseUnitValue*1.91713408;
                 default:
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
index b50be2ff87..9057ee16e6 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
@@ -1319,6 +1319,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin
                 ("en-US", typeof(VolumeFlowUnit), (int)VolumeFlowUnit.UsGallonPerMinute, new string[]{"gal (U.S.)/min", "GPM"}),
                 ("en-US", typeof(VolumeFlowUnit), (int)VolumeFlowUnit.UsGallonPerSecond, new string[]{"gal (U.S.)/s"}),
                 ("en-US", typeof(VolumePerLengthUnit), (int)VolumePerLengthUnit.CubicMeterPerMeter, new string[]{"m³/m"}),
+                ("en-US", typeof(VolumePerLengthUnit), (int)VolumePerLengthUnit.CubicYardPerFoot, new string[]{"yd³/ft"}),
+                ("en-US", typeof(VolumePerLengthUnit), (int)VolumePerLengthUnit.CubicYardPerUsSurveyFoot, new string[]{"yd³/ftUS"}),
                 ("en-US", typeof(VolumePerLengthUnit), (int)VolumePerLengthUnit.LiterPerMeter, new string[]{"l/m"}),
                 ("en-US", typeof(VolumePerLengthUnit), (int)VolumePerLengthUnit.OilBarrelPerFoot, new string[]{"bbl/ft"}),
             };
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/VolumePerLengthUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/VolumePerLengthUnit.g.cs
index 0f1de7c933..07ad69d995 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/VolumePerLengthUnit.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/VolumePerLengthUnit.g.cs
@@ -27,6 +27,8 @@ public enum VolumePerLengthUnit
     {
         Undefined = 0,
         CubicMeterPerMeter,
+        CubicYardPerFoot,
+        CubicYardPerUsSurveyFoot,
         LiterPerMeter,
         OilBarrelPerFoot,
     }
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
index f172de4651..d7f5fcb059 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
@@ -51,6 +51,8 @@ static VolumePerLength()
             Info = new QuantityInfo<VolumePerLengthUnit>(QuantityType.VolumePerLength,
                 new UnitInfo<VolumePerLengthUnit>[] {
                     new UnitInfo<VolumePerLengthUnit>(VolumePerLengthUnit.CubicMeterPerMeter, new BaseUnits(length: LengthUnit.Meter)),
+                    new UnitInfo<VolumePerLengthUnit>(VolumePerLengthUnit.CubicYardPerFoot, BaseUnits.Undefined),
+                    new UnitInfo<VolumePerLengthUnit>(VolumePerLengthUnit.CubicYardPerUsSurveyFoot, BaseUnits.Undefined),
                     new UnitInfo<VolumePerLengthUnit>(VolumePerLengthUnit.LiterPerMeter, new BaseUnits(length: LengthUnit.Decimeter)),
                     new UnitInfo<VolumePerLengthUnit>(VolumePerLengthUnit.OilBarrelPerFoot, BaseUnits.Undefined),
                 },
@@ -170,6 +172,16 @@ public VolumePerLength(double value, UnitSystem unitSystem)
         /// </summary>
         public double CubicMetersPerMeter => As(VolumePerLengthUnit.CubicMeterPerMeter);
 
+        /// <summary>
+        ///     Get VolumePerLength in CubicYardsPerFoot.
+        /// </summary>
+        public double CubicYardsPerFoot => As(VolumePerLengthUnit.CubicYardPerFoot);
+
+        /// <summary>
+        ///     Get VolumePerLength in CubicYardsPerUsSurveyFoot.
+        /// </summary>
+        public double CubicYardsPerUsSurveyFoot => As(VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
+
         /// <summary>
         ///     Get VolumePerLength in LitersPerMeter.
         /// </summary>
@@ -219,6 +231,24 @@ public static VolumePerLength FromCubicMetersPerMeter(QuantityValue cubicmetersp
             return new VolumePerLength(value, VolumePerLengthUnit.CubicMeterPerMeter);
         }
         /// <summary>
+        ///     Get VolumePerLength from CubicYardsPerFoot.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        public static VolumePerLength FromCubicYardsPerFoot(QuantityValue cubicyardsperfoot)
+        {
+            double value = (double) cubicyardsperfoot;
+            return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerFoot);
+        }
+        /// <summary>
+        ///     Get VolumePerLength from CubicYardsPerUsSurveyFoot.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        public static VolumePerLength FromCubicYardsPerUsSurveyFoot(QuantityValue cubicyardsperussurveyfoot)
+        {
+            double value = (double) cubicyardsperussurveyfoot;
+            return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
+        }
+        /// <summary>
         ///     Get VolumePerLength from LitersPerMeter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
@@ -666,6 +696,8 @@ private double GetValueInBaseUnit()
             switch(Unit)
             {
                 case VolumePerLengthUnit.CubicMeterPerMeter: return _value;
+                case VolumePerLengthUnit.CubicYardPerFoot: return _value*2.50838208;
+                case VolumePerLengthUnit.CubicYardPerUsSurveyFoot: return _value*2.50837706323584;
                 case VolumePerLengthUnit.LiterPerMeter: return _value/1000;
                 case VolumePerLengthUnit.OilBarrelPerFoot: return _value/1.91713408;
                 default:
@@ -694,6 +726,8 @@ private double GetValueAs(VolumePerLengthUnit unit)
             switch(unit)
             {
                 case VolumePerLengthUnit.CubicMeterPerMeter: return baseUnitValue;
+                case VolumePerLengthUnit.CubicYardPerFoot: return baseUnitValue/2.50838208;
+                case VolumePerLengthUnit.CubicYardPerUsSurveyFoot: return baseUnitValue/2.50837706323584;
                 case VolumePerLengthUnit.LiterPerMeter: return baseUnitValue*1000;
                 case VolumePerLengthUnit.OilBarrelPerFoot: return baseUnitValue*1.91713408;
                 default:
diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
index 738ce73bef..adde3764e4 100644
--- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
+++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
@@ -1319,6 +1319,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin
                 ("en-US", typeof(VolumeFlowUnit), (int)VolumeFlowUnit.UsGallonPerMinute, new string[]{"gal (U.S.)/min", "GPM"}),
                 ("en-US", typeof(VolumeFlowUnit), (int)VolumeFlowUnit.UsGallonPerSecond, new string[]{"gal (U.S.)/s"}),
                 ("en-US", typeof(VolumePerLengthUnit), (int)VolumePerLengthUnit.CubicMeterPerMeter, new string[]{"m³/m"}),
+                ("en-US", typeof(VolumePerLengthUnit), (int)VolumePerLengthUnit.CubicYardPerFoot, new string[]{"yd³/ft"}),
+                ("en-US", typeof(VolumePerLengthUnit), (int)VolumePerLengthUnit.CubicYardPerUsSurveyFoot, new string[]{"yd³/ftUS"}),
                 ("en-US", typeof(VolumePerLengthUnit), (int)VolumePerLengthUnit.LiterPerMeter, new string[]{"l/m"}),
                 ("en-US", typeof(VolumePerLengthUnit), (int)VolumePerLengthUnit.OilBarrelPerFoot, new string[]{"bbl/ft"}),
             };
diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs
index e9f11f9faa..7ad8267b87 100644
--- a/UnitsNet/GeneratedCode/UnitConverter.g.cs
+++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs
@@ -2067,6 +2067,10 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter)
             unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlow.BaseUnit, VolumeFlowUnit.UsGallonPerSecond, q => q.ToUnit(VolumeFlowUnit.UsGallonPerSecond));
             unitConverter.SetConversionFunction<VolumeFlow>(VolumeFlowUnit.UsGallonPerSecond, VolumeFlow.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLength.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLengthUnit.CubicYardPerFoot, q => q.ToUnit(VolumePerLengthUnit.CubicYardPerFoot));
+            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicYardPerFoot, VolumePerLength.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLengthUnit.CubicYardPerUsSurveyFoot, q => q.ToUnit(VolumePerLengthUnit.CubicYardPerUsSurveyFoot));
+            unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.CubicYardPerUsSurveyFoot, VolumePerLength.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLengthUnit.LiterPerMeter, q => q.ToUnit(VolumePerLengthUnit.LiterPerMeter));
             unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLengthUnit.LiterPerMeter, VolumePerLength.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<VolumePerLength>(VolumePerLength.BaseUnit, VolumePerLengthUnit.OilBarrelPerFoot, q => q.ToUnit(VolumePerLengthUnit.OilBarrelPerFoot));
diff --git a/UnitsNet/GeneratedCode/Units/VolumePerLengthUnit.g.cs b/UnitsNet/GeneratedCode/Units/VolumePerLengthUnit.g.cs
index 0f1de7c933..07ad69d995 100644
--- a/UnitsNet/GeneratedCode/Units/VolumePerLengthUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/VolumePerLengthUnit.g.cs
@@ -27,6 +27,8 @@ public enum VolumePerLengthUnit
     {
         Undefined = 0,
         CubicMeterPerMeter,
+        CubicYardPerFoot,
+        CubicYardPerUsSurveyFoot,
         LiterPerMeter,
         OilBarrelPerFoot,
     }

From a5ffe0bdefd28118a14aa9e47ffa36d72ac38d54 Mon Sep 17 00:00:00 2001
From: Andreas Gullberg Larsen <andreas.larsen84@gmail.com>
Date: Sat, 11 Jan 2020 21:03:09 +0100
Subject: [PATCH 05/15] UnitsNet: 4.43.0

---
 UnitsNet.WindowsRuntimeComponent/Properties/AssemblyInfo.cs   | 4 ++--
 .../UnitsNet.WindowsRuntimeComponent.nuspec                   | 2 +-
 UnitsNet/UnitsNet.csproj                                      | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/UnitsNet.WindowsRuntimeComponent/Properties/AssemblyInfo.cs b/UnitsNet.WindowsRuntimeComponent/Properties/AssemblyInfo.cs
index 91768455a3..a30a4d0d28 100644
--- a/UnitsNet.WindowsRuntimeComponent/Properties/AssemblyInfo.cs
+++ b/UnitsNet.WindowsRuntimeComponent/Properties/AssemblyInfo.cs
@@ -17,6 +17,6 @@
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 [assembly: NeutralResourcesLanguage("")]
-[assembly: AssemblyVersion("4.42.0")]
-[assembly: AssemblyFileVersion("4.42.0")]
+[assembly: AssemblyVersion("4.43.0")]
+[assembly: AssemblyFileVersion("4.43.0")]
 [assembly: InternalsVisibleTo("UnitsNet.WindowsRuntimeComponent.Tests")]
diff --git a/UnitsNet.WindowsRuntimeComponent/UnitsNet.WindowsRuntimeComponent.nuspec b/UnitsNet.WindowsRuntimeComponent/UnitsNet.WindowsRuntimeComponent.nuspec
index 859497a38b..f4cab887bb 100644
--- a/UnitsNet.WindowsRuntimeComponent/UnitsNet.WindowsRuntimeComponent.nuspec
+++ b/UnitsNet.WindowsRuntimeComponent/UnitsNet.WindowsRuntimeComponent.nuspec
@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2011/08/nuspec.xsd">
   <metadata>
     <id>UnitsNet.WindowsRuntimeComponent</id>
-    <version>4.42.0</version>
+    <version>4.43.0</version>
     <title>Units.NET - Windows Runtime Component</title>
     <authors>Andreas Gullberg Larsen</authors>
     <owners>Andreas Gullberg Larsen</owners>
diff --git a/UnitsNet/UnitsNet.csproj b/UnitsNet/UnitsNet.csproj
index 5650d8abd7..ca53e5abc5 100644
--- a/UnitsNet/UnitsNet.csproj
+++ b/UnitsNet/UnitsNet.csproj
@@ -2,7 +2,7 @@
   <!-- NuGet properties -->
   <PropertyGroup>
     <PackageId>UnitsNet</PackageId>
-    <Version>4.42.0</Version>
+    <Version>4.43.0</Version>
     <Authors>Andreas Gullberg Larsen</Authors>
     <Title>Units.NET</Title>
     <Description>Get all the common units of measurement and the conversions between them. It is light-weight and thoroughly tested.</Description>

From b30889536bd74424773d0098ce1971de0aa0342d Mon Sep 17 00:00:00 2001
From: Lu Li <Lu.Li@WOODGROUP.COM>
Date: Thu, 9 Jan 2020 09:57:50 -0700
Subject: [PATCH 06/15] Add NumberTo extensions back to UnitsNET.

---
 .../UnitsNetGen/NumberExtensionsGenerator.cs  |  65 +++
 CodeGen/Generators/UnitsNetGenerator.cs       |  11 +-
 UnitsNet.Tests/NumberExtensionsTest.cs        |  20 +
 .../NumberToAccelerationExtensions.g.cs       | 135 ++++++
 .../NumberToAmountOfSubstanceExtensions.g.cs  | 151 +++++++
 .../NumberToAmplitudeRatioExtensions.g.cs     |  63 +++
 .../Extensions/NumberToAngleExtensions.g.cs   | 143 ++++++
 .../NumberToApparentEnergyExtensions.g.cs     |  55 +++
 .../NumberToApparentPowerExtensions.g.cs      |  63 +++
 .../NumberToAreaDensityExtensions.g.cs        |  39 ++
 .../Extensions/NumberToAreaExtensions.g.cs    | 143 ++++++
 ...NumberToAreaMomentOfInertiaExtensions.g.cs |  79 ++++
 .../Extensions/NumberToBitRateExtensions.g.cs | 239 ++++++++++
 ...rakeSpecificFuelConsumptionExtensions.g.cs |  55 +++
 .../NumberToCapacitanceExtensions.g.cs        |  87 ++++
 ...efficientOfThermalExpansionExtensions.g.cs |  55 +++
 .../Extensions/NumberToDensityExtensions.g.cs | 351 +++++++++++++++
 .../NumberToDurationExtensions.g.cs           | 111 +++++
 .../NumberToDynamicViscosityExtensions.g.cs   | 103 +++++
 .../NumberToElectricAdmittanceExtensions.g.cs |  63 +++
 ...mberToElectricChargeDensityExtensions.g.cs |  39 ++
 .../NumberToElectricChargeExtensions.g.cs     |  71 +++
 ...NumberToElectricConductanceExtensions.g.cs |  55 +++
 ...umberToElectricConductivityExtensions.g.cs |  55 +++
 ...berToElectricCurrentDensityExtensions.g.cs |  55 +++
 .../NumberToElectricCurrentExtensions.g.cs    |  95 ++++
 ...erToElectricCurrentGradientExtensions.g.cs |  39 ++
 .../NumberToElectricFieldExtensions.g.cs      |  39 ++
 .../NumberToElectricInductanceExtensions.g.cs |  63 +++
 ...NumberToElectricPotentialAcExtensions.g.cs |  71 +++
 ...NumberToElectricPotentialDcExtensions.g.cs |  71 +++
 .../NumberToElectricPotentialExtensions.g.cs  |  71 +++
 .../NumberToElectricResistanceExtensions.g.cs |  71 +++
 ...NumberToElectricResistivityExtensions.g.cs | 143 ++++++
 ...lectricSurfaceChargeDensityExtensions.g.cs |  55 +++
 .../Extensions/NumberToEnergyExtensions.g.cs  | 239 ++++++++++
 .../Extensions/NumberToEntropyExtensions.g.cs |  87 ++++
 .../NumberToForceChangeRateExtensions.g.cs    | 119 +++++
 .../Extensions/NumberToForceExtensions.g.cs   | 135 ++++++
 .../NumberToForcePerLengthExtensions.g.cs     | 127 ++++++
 .../NumberToFrequencyExtensions.g.cs          | 103 +++++
 .../NumberToFuelEfficiencyExtensions.g.cs     |  63 +++
 .../NumberToHeatFluxExtensions.g.cs           | 175 ++++++++
 ...erToHeatTransferCoefficientExtensions.g.cs |  55 +++
 .../NumberToIlluminanceExtensions.g.cs        |  63 +++
 .../NumberToInformationExtensions.g.cs        | 239 ++++++++++
 .../NumberToIrradianceExtensions.g.cs         | 143 ++++++
 .../NumberToIrradiationExtensions.g.cs        |  87 ++++
 .../NumberToKinematicViscosityExtensions.g.cs |  95 ++++
 .../NumberToLapseRateExtensions.g.cs          |  39 ++
 .../Extensions/NumberToLengthExtensions.g.cs  | 287 ++++++++++++
 .../Extensions/NumberToLevelExtensions.g.cs   |  47 ++
 .../NumberToLinearDensityExtensions.g.cs      |  55 +++
 .../NumberToLuminosityExtensions.g.cs         | 143 ++++++
 .../NumberToLuminousFluxExtensions.g.cs       |  39 ++
 .../NumberToLuminousIntensityExtensions.g.cs  |  39 ++
 .../NumberToMagneticFieldExtensions.g.cs      |  63 +++
 .../NumberToMagneticFluxExtensions.g.cs       |  39 ++
 .../NumberToMagnetizationExtensions.g.cs      |  39 ++
 .../NumberToMassConcentrationExtensions.g.cs  | 351 +++++++++++++++
 .../Extensions/NumberToMassExtensions.g.cs    | 231 ++++++++++
 .../NumberToMassFlowExtensions.g.cs           | 295 ++++++++++++
 .../NumberToMassFluxExtensions.g.cs           |  47 ++
 .../NumberToMassFractionExtensions.g.cs       | 223 +++++++++
 ...NumberToMassMomentOfInertiaExtensions.g.cs | 255 +++++++++++
 .../NumberToMolarEnergyExtensions.g.cs        |  55 +++
 .../NumberToMolarEntropyExtensions.g.cs       |  55 +++
 .../NumberToMolarMassExtensions.g.cs          | 127 ++++++
 .../NumberToMolarityExtensions.g.cs           |  95 ++++
 .../NumberToPermeabilityExtensions.g.cs       |  39 ++
 .../NumberToPermittivityExtensions.g.cs       |  39 ++
 .../NumberToPowerDensityExtensions.g.cs       | 383 ++++++++++++++++
 .../Extensions/NumberToPowerExtensions.g.cs   | 231 ++++++++++
 .../NumberToPowerRatioExtensions.g.cs         |  47 ++
 .../NumberToPressureChangeRateExtensions.g.cs |  87 ++++
 .../NumberToPressureExtensions.g.cs           | 367 +++++++++++++++
 .../NumberToRatioChangeRateExtensions.g.cs    |  47 ++
 .../Extensions/NumberToRatioExtensions.g.cs   |  79 ++++
 .../NumberToReactiveEnergyExtensions.g.cs     |  55 +++
 .../NumberToReactivePowerExtensions.g.cs      |  63 +++
 ...berToRotationalAccelerationExtensions.g.cs |  63 +++
 .../NumberToRotationalSpeedExtensions.g.cs    | 135 ++++++
 ...NumberToRotationalStiffnessExtensions.g.cs |  55 +++
 ...otationalStiffnessPerLengthExtensions.g.cs |  55 +++
 .../NumberToSolidAngleExtensions.g.cs         |  39 ++
 .../NumberToSpecificEnergyExtensions.g.cs     | 103 +++++
 .../NumberToSpecificEntropyExtensions.g.cs    | 103 +++++
 .../NumberToSpecificVolumeExtensions.g.cs     |  55 +++
 .../NumberToSpecificWeightExtensions.g.cs     | 167 +++++++
 .../Extensions/NumberToSpeedExtensions.g.cs   | 287 ++++++++++++
 ...mberToTemperatureChangeRateExtensions.g.cs | 111 +++++
 .../NumberToTemperatureDeltaExtensions.g.cs   |  95 ++++
 .../NumberToTemperatureExtensions.g.cs        | 103 +++++
 ...NumberToThermalConductivityExtensions.g.cs |  47 ++
 .../NumberToThermalResistanceExtensions.g.cs  |  71 +++
 .../Extensions/NumberToTorqueExtensions.g.cs  | 199 ++++++++
 .../NumberToTorquePerLengthExtensions.g.cs    | 199 ++++++++
 .../NumberToVitaminAExtensions.g.cs           |  39 ++
 ...NumberToVolumeConcentrationExtensions.g.cs | 191 ++++++++
 .../Extensions/NumberToVolumeExtensions.g.cs  | 407 +++++++++++++++++
 .../NumberToVolumeFlowExtensions.g.cs         | 423 ++++++++++++++++++
 .../NumberToVolumePerLengthExtensions.g.cs    |  55 +++
 102 files changed, 11716 insertions(+), 1 deletion(-)
 create mode 100644 CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
 create mode 100644 UnitsNet.Tests/NumberExtensionsTest.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToAccelerationExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToAmountOfSubstanceExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToAmplitudeRatioExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToAngleExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToApparentEnergyExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToApparentPowerExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToAreaDensityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToAreaExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToAreaMomentOfInertiaExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToBitRateExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToCapacitanceExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToCoefficientOfThermalExpansionExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToDensityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToDurationExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToDynamicViscosityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricAdmittanceExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeDensityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricConductanceExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricConductivityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentDensityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentGradientExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricFieldExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricInductanceExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialAcExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialDcExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricResistanceExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricResistivityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToElectricSurfaceChargeDensityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToEnergyExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToEntropyExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToForceChangeRateExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToForceExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToForcePerLengthExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToFrequencyExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToFuelEfficiencyExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToHeatFluxExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToHeatTransferCoefficientExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToIlluminanceExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToInformationExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToIrradianceExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToIrradiationExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToKinematicViscosityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToLapseRateExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToLengthExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToLevelExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToLinearDensityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToLuminosityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToLuminousFluxExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToLuminousIntensityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMagneticFieldExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMagneticFluxExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMagnetizationExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMassConcentrationExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMassExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMassFlowExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMassFluxExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMassFractionExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMassMomentOfInertiaExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMolarEnergyExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMolarEntropyExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMolarMassExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToMolarityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToPermeabilityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToPermittivityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToPowerDensityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToPowerExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToPowerRatioExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToPressureChangeRateExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToPressureExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToRatioChangeRateExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToRatioExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToReactiveEnergyExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToReactivePowerExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToRotationalAccelerationExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToRotationalSpeedExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessPerLengthExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToSolidAngleExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToSpecificEnergyExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToSpecificEntropyExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToSpecificVolumeExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToSpecificWeightExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToSpeedExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToTemperatureChangeRateExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToTemperatureDeltaExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToTemperatureExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToThermalConductivityExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToThermalResistanceExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToTorqueExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToTorquePerLengthExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToVitaminAExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToVolumeConcentrationExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToVolumeExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToVolumeFlowExtensions.g.cs
 create mode 100644 UnitsNet/GeneratedCode/Extensions/NumberToVolumePerLengthExtensions.g.cs

diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
new file mode 100644
index 0000000000..9fda87baf3
--- /dev/null
+++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
@@ -0,0 +1,65 @@
+using System;
+using CodeGen.JsonTypes;
+
+namespace CodeGen.Generators.UnitsNetGen
+{
+    internal class NumberExtensionsGenerator : GeneratorBase
+    {
+        private readonly Unit[] _units;
+        private readonly string _quantityName;
+
+        public NumberExtensionsGenerator(Quantity quantity)
+        {
+            if (quantity is null)
+                throw new ArgumentNullException(nameof(quantity));
+
+            _units = quantity.Units;
+            _quantityName = quantity.Name;
+        }
+
+        public override string Generate()
+        {
+            Writer.WL(GeneratedFileHeader);
+
+            Writer.WL(
+$@"
+using System;
+                        
+namespace UnitsNet.Extensions.NumberTo{_quantityName}
+{{
+    /// <summary>
+    /// A number to {_quantityName} Extensions
+    /// </summary>
+    public static class NumberTo{_quantityName}Extensions
+    {{
+"
+            );
+
+            foreach (var unit in _units)
+            {
+                Writer.WL($@"
+        #region {unit.SingularName}
+
+        /// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(UnitsNet.QuantityValue)"" />");
+
+                Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit.ObsoleteText));
+
+                Writer.WL($@"        public static {_quantityName} {unit.PluralName}<T>(this T value) =>
+             {_quantityName}.From{unit.PluralName}(Convert.ToDouble(value));
+
+        #endregion
+");
+            }
+
+            Writer.WL(@"
+    }
+}");
+            return Writer.ToString();
+        }
+
+        private string GetObsoleteAttributeOrNull(string obsoleteText) =>
+            string.IsNullOrWhiteSpace(obsoleteText) ?
+            null :
+            $"[System.Obsolete({obsoleteText})]";
+    }
+}
diff --git a/CodeGen/Generators/UnitsNetGenerator.cs b/CodeGen/Generators/UnitsNetGenerator.cs
index b21a04771b..c52b7ecc6e 100644
--- a/CodeGen/Generators/UnitsNetGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGenerator.cs
@@ -1,4 +1,4 @@
-// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Licensed under MIT No Attribution, see LICENSE file at the root.
 // Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
 
 using System.IO;
@@ -42,6 +42,7 @@ public static void Generate(string rootDir, Quantity[] quantities)
             // Ensure output directories exist
             Directory.CreateDirectory($"{outputDir}/Quantities");
             Directory.CreateDirectory($"{outputDir}/Units");
+            Directory.CreateDirectory($"{outputDir}/Extensions");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode/TestsBase");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode/QuantityTests");
@@ -51,6 +52,7 @@ public static void Generate(string rootDir, Quantity[] quantities)
                 var sb = new StringBuilder($"{quantity.Name}:".PadRight(AlignPad));
                 GenerateQuantity(sb, quantity, $"{outputDir}/Quantities/{quantity.Name}.g.cs");
                 GenerateUnitType(sb, quantity, $"{outputDir}/Units/{quantity.Name}Unit.g.cs");
+                GenerateNumberExtensions(sb, quantity, $"{outputDir}/Extensions/NumberTo{quantity.Name}Extensions.g.cs");
 
                 // Example: CustomCode/Quantities/LengthTests inherits GeneratedCode/TestsBase/LengthTestsBase
                 // This way when new units are added to the quantity JSON definition, we auto-generate the new
@@ -96,6 +98,13 @@ private static void GenerateQuantity(StringBuilder sb, Quantity quantity, string
             sb.Append("quantity(OK) ");
         }
 
+        private static void GenerateNumberExtensions(StringBuilder sb, Quantity quantity, string filePath)
+        {
+            var content = new NumberExtensionsGenerator(quantity).Generate();
+            File.WriteAllText(filePath, content, Encoding.UTF8);
+            sb.Append("number extensions(OK) ");
+        }
+
         private static void GenerateUnitType(StringBuilder sb, Quantity quantity, string filePath)
         {
             var content = new UnitTypeGenerator(quantity).Generate();
diff --git a/UnitsNet.Tests/NumberExtensionsTest.cs b/UnitsNet.Tests/NumberExtensionsTest.cs
new file mode 100644
index 0000000000..1b1db5851d
--- /dev/null
+++ b/UnitsNet.Tests/NumberExtensionsTest.cs
@@ -0,0 +1,20 @@
+using UnitsNet.Extensions.NumberToAngle;
+using UnitsNet.Extensions.NumberToForce;
+using UnitsNet.Extensions.NumberToLength;
+using UnitsNet.Extensions.NumberToMass;
+using Xunit;
+
+namespace UnitsNet.Tests
+{
+    public class NumberExtensionsTest
+    {
+        [Fact]
+        public void SomeArbitraryExtensionMethods_CreatesCorrectValue()
+        {
+            Assert.Equal(Length.FromMeters(1), 1.Meters());
+            Assert.Equal(Mass.FromTonnes(2), 2.Tonnes());
+            Assert.Equal(Force.FromKiloPonds(3), 3.KiloPonds());
+            Assert.Equal(Angle.FromRadians(3), 3.Radians());
+        }
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAccelerationExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToAccelerationExtensions.g.cs
new file mode 100644
index 0000000000..a67f59440d
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToAccelerationExtensions.g.cs
@@ -0,0 +1,135 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToAcceleration
+{
+    /// <summary>
+    /// A number to Acceleration Extensions
+    /// </summary>
+    public static class NumberToAccelerationExtensions
+    {
+
+        #region CentimeterPerSecondSquared
+
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static Acceleration CentimetersPerSecondSquared<T>(this T value) =>
+             Acceleration.FromCentimetersPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecimeterPerSecondSquared
+
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static Acceleration DecimetersPerSecondSquared<T>(this T value) =>
+             Acceleration.FromDecimetersPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region FootPerSecondSquared
+
+        /// <inheritdoc cref="Acceleration.FromFeetPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static Acceleration FeetPerSecondSquared<T>(this T value) =>
+             Acceleration.FromFeetPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region InchPerSecondSquared
+
+        /// <inheritdoc cref="Acceleration.FromInchesPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static Acceleration InchesPerSecondSquared<T>(this T value) =>
+             Acceleration.FromInchesPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilometerPerSecondSquared
+
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static Acceleration KilometersPerSecondSquared<T>(this T value) =>
+             Acceleration.FromKilometersPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KnotPerHour
+
+        /// <inheritdoc cref="Acceleration.FromKnotsPerHour(UnitsNet.QuantityValue)" />
+        public static Acceleration KnotsPerHour<T>(this T value) =>
+             Acceleration.FromKnotsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KnotPerMinute
+
+        /// <inheritdoc cref="Acceleration.FromKnotsPerMinute(UnitsNet.QuantityValue)" />
+        public static Acceleration KnotsPerMinute<T>(this T value) =>
+             Acceleration.FromKnotsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KnotPerSecond
+
+        /// <inheritdoc cref="Acceleration.FromKnotsPerSecond(UnitsNet.QuantityValue)" />
+        public static Acceleration KnotsPerSecond<T>(this T value) =>
+             Acceleration.FromKnotsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeterPerSecondSquared
+
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static Acceleration MetersPerSecondSquared<T>(this T value) =>
+             Acceleration.FromMetersPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrometerPerSecondSquared
+
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static Acceleration MicrometersPerSecondSquared<T>(this T value) =>
+             Acceleration.FromMicrometersPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillimeterPerSecondSquared
+
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static Acceleration MillimetersPerSecondSquared<T>(this T value) =>
+             Acceleration.FromMillimetersPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanometerPerSecondSquared
+
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static Acceleration NanometersPerSecondSquared<T>(this T value) =>
+             Acceleration.FromNanometersPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region StandardGravity
+
+        /// <inheritdoc cref="Acceleration.FromStandardGravity(UnitsNet.QuantityValue)" />
+        public static Acceleration StandardGravity<T>(this T value) =>
+             Acceleration.FromStandardGravity(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAmountOfSubstanceExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToAmountOfSubstanceExtensions.g.cs
new file mode 100644
index 0000000000..8daef05c79
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToAmountOfSubstanceExtensions.g.cs
@@ -0,0 +1,151 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToAmountOfSubstance
+{
+    /// <summary>
+    /// A number to AmountOfSubstance Extensions
+    /// </summary>
+    public static class NumberToAmountOfSubstanceExtensions
+    {
+
+        #region Centimole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromCentimoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance Centimoles<T>(this T value) =>
+             AmountOfSubstance.FromCentimoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentipoundMole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromCentipoundMoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance CentipoundMoles<T>(this T value) =>
+             AmountOfSubstance.FromCentipoundMoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Decimole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromDecimoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance Decimoles<T>(this T value) =>
+             AmountOfSubstance.FromDecimoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecipoundMole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromDecipoundMoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance DecipoundMoles<T>(this T value) =>
+             AmountOfSubstance.FromDecipoundMoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilomole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromKilomoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance Kilomoles<T>(this T value) =>
+             AmountOfSubstance.FromKilomoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundMole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromKilopoundMoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance KilopoundMoles<T>(this T value) =>
+             AmountOfSubstance.FromKilopoundMoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megamole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromMegamoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance Megamoles<T>(this T value) =>
+             AmountOfSubstance.FromMegamoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Micromole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromMicromoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance Micromoles<T>(this T value) =>
+             AmountOfSubstance.FromMicromoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicropoundMole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromMicropoundMoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance MicropoundMoles<T>(this T value) =>
+             AmountOfSubstance.FromMicropoundMoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millimole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromMillimoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance Millimoles<T>(this T value) =>
+             AmountOfSubstance.FromMillimoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillipoundMole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromMillipoundMoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance MillipoundMoles<T>(this T value) =>
+             AmountOfSubstance.FromMillipoundMoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Mole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromMoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance Moles<T>(this T value) =>
+             AmountOfSubstance.FromMoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanomole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromNanomoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance Nanomoles<T>(this T value) =>
+             AmountOfSubstance.FromNanomoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanopoundMole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromNanopoundMoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance NanopoundMoles<T>(this T value) =>
+             AmountOfSubstance.FromNanopoundMoles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundMole
+
+        /// <inheritdoc cref="AmountOfSubstance.FromPoundMoles(UnitsNet.QuantityValue)" />
+        public static AmountOfSubstance PoundMoles<T>(this T value) =>
+             AmountOfSubstance.FromPoundMoles(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAmplitudeRatioExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToAmplitudeRatioExtensions.g.cs
new file mode 100644
index 0000000000..5c70c5628c
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToAmplitudeRatioExtensions.g.cs
@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToAmplitudeRatio
+{
+    /// <summary>
+    /// A number to AmplitudeRatio Extensions
+    /// </summary>
+    public static class NumberToAmplitudeRatioExtensions
+    {
+
+        #region DecibelMicrovolt
+
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMicrovolts(UnitsNet.QuantityValue)" />
+        public static AmplitudeRatio DecibelMicrovolts<T>(this T value) =>
+             AmplitudeRatio.FromDecibelMicrovolts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecibelMillivolt
+
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMillivolts(UnitsNet.QuantityValue)" />
+        public static AmplitudeRatio DecibelMillivolts<T>(this T value) =>
+             AmplitudeRatio.FromDecibelMillivolts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecibelUnloaded
+
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelsUnloaded(UnitsNet.QuantityValue)" />
+        public static AmplitudeRatio DecibelsUnloaded<T>(this T value) =>
+             AmplitudeRatio.FromDecibelsUnloaded(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecibelVolt
+
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelVolts(UnitsNet.QuantityValue)" />
+        public static AmplitudeRatio DecibelVolts<T>(this T value) =>
+             AmplitudeRatio.FromDecibelVolts(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAngleExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToAngleExtensions.g.cs
new file mode 100644
index 0000000000..2206e364a5
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToAngleExtensions.g.cs
@@ -0,0 +1,143 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToAngle
+{
+    /// <summary>
+    /// A number to Angle Extensions
+    /// </summary>
+    public static class NumberToAngleExtensions
+    {
+
+        #region Arcminute
+
+        /// <inheritdoc cref="Angle.FromArcminutes(UnitsNet.QuantityValue)" />
+        public static Angle Arcminutes<T>(this T value) =>
+             Angle.FromArcminutes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Arcsecond
+
+        /// <inheritdoc cref="Angle.FromArcseconds(UnitsNet.QuantityValue)" />
+        public static Angle Arcseconds<T>(this T value) =>
+             Angle.FromArcseconds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Centiradian
+
+        /// <inheritdoc cref="Angle.FromCentiradians(UnitsNet.QuantityValue)" />
+        public static Angle Centiradians<T>(this T value) =>
+             Angle.FromCentiradians(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Deciradian
+
+        /// <inheritdoc cref="Angle.FromDeciradians(UnitsNet.QuantityValue)" />
+        public static Angle Deciradians<T>(this T value) =>
+             Angle.FromDeciradians(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Degree
+
+        /// <inheritdoc cref="Angle.FromDegrees(UnitsNet.QuantityValue)" />
+        public static Angle Degrees<T>(this T value) =>
+             Angle.FromDegrees(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Gradian
+
+        /// <inheritdoc cref="Angle.FromGradians(UnitsNet.QuantityValue)" />
+        public static Angle Gradians<T>(this T value) =>
+             Angle.FromGradians(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microdegree
+
+        /// <inheritdoc cref="Angle.FromMicrodegrees(UnitsNet.QuantityValue)" />
+        public static Angle Microdegrees<T>(this T value) =>
+             Angle.FromMicrodegrees(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microradian
+
+        /// <inheritdoc cref="Angle.FromMicroradians(UnitsNet.QuantityValue)" />
+        public static Angle Microradians<T>(this T value) =>
+             Angle.FromMicroradians(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millidegree
+
+        /// <inheritdoc cref="Angle.FromMillidegrees(UnitsNet.QuantityValue)" />
+        public static Angle Millidegrees<T>(this T value) =>
+             Angle.FromMillidegrees(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Milliradian
+
+        /// <inheritdoc cref="Angle.FromMilliradians(UnitsNet.QuantityValue)" />
+        public static Angle Milliradians<T>(this T value) =>
+             Angle.FromMilliradians(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanodegree
+
+        /// <inheritdoc cref="Angle.FromNanodegrees(UnitsNet.QuantityValue)" />
+        public static Angle Nanodegrees<T>(this T value) =>
+             Angle.FromNanodegrees(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanoradian
+
+        /// <inheritdoc cref="Angle.FromNanoradians(UnitsNet.QuantityValue)" />
+        public static Angle Nanoradians<T>(this T value) =>
+             Angle.FromNanoradians(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Radian
+
+        /// <inheritdoc cref="Angle.FromRadians(UnitsNet.QuantityValue)" />
+        public static Angle Radians<T>(this T value) =>
+             Angle.FromRadians(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Revolution
+
+        /// <inheritdoc cref="Angle.FromRevolutions(UnitsNet.QuantityValue)" />
+        public static Angle Revolutions<T>(this T value) =>
+             Angle.FromRevolutions(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToApparentEnergyExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToApparentEnergyExtensions.g.cs
new file mode 100644
index 0000000000..ceacfcb326
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToApparentEnergyExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToApparentEnergy
+{
+    /// <summary>
+    /// A number to ApparentEnergy Extensions
+    /// </summary>
+    public static class NumberToApparentEnergyExtensions
+    {
+
+        #region KilovoltampereHour
+
+        /// <inheritdoc cref="ApparentEnergy.FromKilovoltampereHours(UnitsNet.QuantityValue)" />
+        public static ApparentEnergy KilovoltampereHours<T>(this T value) =>
+             ApparentEnergy.FromKilovoltampereHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegavoltampereHour
+
+        /// <inheritdoc cref="ApparentEnergy.FromMegavoltampereHours(UnitsNet.QuantityValue)" />
+        public static ApparentEnergy MegavoltampereHours<T>(this T value) =>
+             ApparentEnergy.FromMegavoltampereHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region VoltampereHour
+
+        /// <inheritdoc cref="ApparentEnergy.FromVoltampereHours(UnitsNet.QuantityValue)" />
+        public static ApparentEnergy VoltampereHours<T>(this T value) =>
+             ApparentEnergy.FromVoltampereHours(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToApparentPowerExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToApparentPowerExtensions.g.cs
new file mode 100644
index 0000000000..144b2a6315
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToApparentPowerExtensions.g.cs
@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToApparentPower
+{
+    /// <summary>
+    /// A number to ApparentPower Extensions
+    /// </summary>
+    public static class NumberToApparentPowerExtensions
+    {
+
+        #region Gigavoltampere
+
+        /// <inheritdoc cref="ApparentPower.FromGigavoltamperes(UnitsNet.QuantityValue)" />
+        public static ApparentPower Gigavoltamperes<T>(this T value) =>
+             ApparentPower.FromGigavoltamperes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilovoltampere
+
+        /// <inheritdoc cref="ApparentPower.FromKilovoltamperes(UnitsNet.QuantityValue)" />
+        public static ApparentPower Kilovoltamperes<T>(this T value) =>
+             ApparentPower.FromKilovoltamperes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megavoltampere
+
+        /// <inheritdoc cref="ApparentPower.FromMegavoltamperes(UnitsNet.QuantityValue)" />
+        public static ApparentPower Megavoltamperes<T>(this T value) =>
+             ApparentPower.FromMegavoltamperes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Voltampere
+
+        /// <inheritdoc cref="ApparentPower.FromVoltamperes(UnitsNet.QuantityValue)" />
+        public static ApparentPower Voltamperes<T>(this T value) =>
+             ApparentPower.FromVoltamperes(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAreaDensityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToAreaDensityExtensions.g.cs
new file mode 100644
index 0000000000..aab6cc9e76
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToAreaDensityExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToAreaDensity
+{
+    /// <summary>
+    /// A number to AreaDensity Extensions
+    /// </summary>
+    public static class NumberToAreaDensityExtensions
+    {
+
+        #region KilogramPerSquareMeter
+
+        /// <inheritdoc cref="AreaDensity.FromKilogramsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static AreaDensity KilogramsPerSquareMeter<T>(this T value) =>
+             AreaDensity.FromKilogramsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAreaExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToAreaExtensions.g.cs
new file mode 100644
index 0000000000..46e854faed
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToAreaExtensions.g.cs
@@ -0,0 +1,143 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToArea
+{
+    /// <summary>
+    /// A number to Area Extensions
+    /// </summary>
+    public static class NumberToAreaExtensions
+    {
+
+        #region Acre
+
+        /// <inheritdoc cref="Area.FromAcres(UnitsNet.QuantityValue)" />
+        public static Area Acres<T>(this T value) =>
+             Area.FromAcres(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Hectare
+
+        /// <inheritdoc cref="Area.FromHectares(UnitsNet.QuantityValue)" />
+        public static Area Hectares<T>(this T value) =>
+             Area.FromHectares(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareCentimeter
+
+        /// <inheritdoc cref="Area.FromSquareCentimeters(UnitsNet.QuantityValue)" />
+        public static Area SquareCentimeters<T>(this T value) =>
+             Area.FromSquareCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareDecimeter
+
+        /// <inheritdoc cref="Area.FromSquareDecimeters(UnitsNet.QuantityValue)" />
+        public static Area SquareDecimeters<T>(this T value) =>
+             Area.FromSquareDecimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareFoot
+
+        /// <inheritdoc cref="Area.FromSquareFeet(UnitsNet.QuantityValue)" />
+        public static Area SquareFeet<T>(this T value) =>
+             Area.FromSquareFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareInch
+
+        /// <inheritdoc cref="Area.FromSquareInches(UnitsNet.QuantityValue)" />
+        public static Area SquareInches<T>(this T value) =>
+             Area.FromSquareInches(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareKilometer
+
+        /// <inheritdoc cref="Area.FromSquareKilometers(UnitsNet.QuantityValue)" />
+        public static Area SquareKilometers<T>(this T value) =>
+             Area.FromSquareKilometers(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareMeter
+
+        /// <inheritdoc cref="Area.FromSquareMeters(UnitsNet.QuantityValue)" />
+        public static Area SquareMeters<T>(this T value) =>
+             Area.FromSquareMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareMicrometer
+
+        /// <inheritdoc cref="Area.FromSquareMicrometers(UnitsNet.QuantityValue)" />
+        public static Area SquareMicrometers<T>(this T value) =>
+             Area.FromSquareMicrometers(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareMile
+
+        /// <inheritdoc cref="Area.FromSquareMiles(UnitsNet.QuantityValue)" />
+        public static Area SquareMiles<T>(this T value) =>
+             Area.FromSquareMiles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareMillimeter
+
+        /// <inheritdoc cref="Area.FromSquareMillimeters(UnitsNet.QuantityValue)" />
+        public static Area SquareMillimeters<T>(this T value) =>
+             Area.FromSquareMillimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareNauticalMile
+
+        /// <inheritdoc cref="Area.FromSquareNauticalMiles(UnitsNet.QuantityValue)" />
+        public static Area SquareNauticalMiles<T>(this T value) =>
+             Area.FromSquareNauticalMiles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareYard
+
+        /// <inheritdoc cref="Area.FromSquareYards(UnitsNet.QuantityValue)" />
+        public static Area SquareYards<T>(this T value) =>
+             Area.FromSquareYards(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsSurveySquareFoot
+
+        /// <inheritdoc cref="Area.FromUsSurveySquareFeet(UnitsNet.QuantityValue)" />
+        public static Area UsSurveySquareFeet<T>(this T value) =>
+             Area.FromUsSurveySquareFeet(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAreaMomentOfInertiaExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToAreaMomentOfInertiaExtensions.g.cs
new file mode 100644
index 0000000000..5dfe62cc3b
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToAreaMomentOfInertiaExtensions.g.cs
@@ -0,0 +1,79 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToAreaMomentOfInertia
+{
+    /// <summary>
+    /// A number to AreaMomentOfInertia Extensions
+    /// </summary>
+    public static class NumberToAreaMomentOfInertiaExtensions
+    {
+
+        #region CentimeterToTheFourth
+
+        /// <inheritdoc cref="AreaMomentOfInertia.FromCentimetersToTheFourth(UnitsNet.QuantityValue)" />
+        public static AreaMomentOfInertia CentimetersToTheFourth<T>(this T value) =>
+             AreaMomentOfInertia.FromCentimetersToTheFourth(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecimeterToTheFourth
+
+        /// <inheritdoc cref="AreaMomentOfInertia.FromDecimetersToTheFourth(UnitsNet.QuantityValue)" />
+        public static AreaMomentOfInertia DecimetersToTheFourth<T>(this T value) =>
+             AreaMomentOfInertia.FromDecimetersToTheFourth(Convert.ToDouble(value));
+
+        #endregion
+
+        #region FootToTheFourth
+
+        /// <inheritdoc cref="AreaMomentOfInertia.FromFeetToTheFourth(UnitsNet.QuantityValue)" />
+        public static AreaMomentOfInertia FeetToTheFourth<T>(this T value) =>
+             AreaMomentOfInertia.FromFeetToTheFourth(Convert.ToDouble(value));
+
+        #endregion
+
+        #region InchToTheFourth
+
+        /// <inheritdoc cref="AreaMomentOfInertia.FromInchesToTheFourth(UnitsNet.QuantityValue)" />
+        public static AreaMomentOfInertia InchesToTheFourth<T>(this T value) =>
+             AreaMomentOfInertia.FromInchesToTheFourth(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeterToTheFourth
+
+        /// <inheritdoc cref="AreaMomentOfInertia.FromMetersToTheFourth(UnitsNet.QuantityValue)" />
+        public static AreaMomentOfInertia MetersToTheFourth<T>(this T value) =>
+             AreaMomentOfInertia.FromMetersToTheFourth(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillimeterToTheFourth
+
+        /// <inheritdoc cref="AreaMomentOfInertia.FromMillimetersToTheFourth(UnitsNet.QuantityValue)" />
+        public static AreaMomentOfInertia MillimetersToTheFourth<T>(this T value) =>
+             AreaMomentOfInertia.FromMillimetersToTheFourth(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToBitRateExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToBitRateExtensions.g.cs
new file mode 100644
index 0000000000..e3b9eab958
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToBitRateExtensions.g.cs
@@ -0,0 +1,239 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToBitRate
+{
+    /// <summary>
+    /// A number to BitRate Extensions
+    /// </summary>
+    public static class NumberToBitRateExtensions
+    {
+
+        #region BitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromBitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate BitsPerSecond<T>(this T value) =>
+             BitRate.FromBitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region BytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromBytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate BytesPerSecond<T>(this T value) =>
+             BitRate.FromBytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ExabitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromExabitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate ExabitsPerSecond<T>(this T value) =>
+             BitRate.FromExabitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ExabytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromExabytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate ExabytesPerSecond<T>(this T value) =>
+             BitRate.FromExabytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ExbibitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromExbibitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate ExbibitsPerSecond<T>(this T value) =>
+             BitRate.FromExbibitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ExbibytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromExbibytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate ExbibytesPerSecond<T>(this T value) =>
+             BitRate.FromExbibytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GibibitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromGibibitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate GibibitsPerSecond<T>(this T value) =>
+             BitRate.FromGibibitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GibibytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromGibibytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate GibibytesPerSecond<T>(this T value) =>
+             BitRate.FromGibibytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GigabitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromGigabitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate GigabitsPerSecond<T>(this T value) =>
+             BitRate.FromGigabitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GigabytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromGigabytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate GigabytesPerSecond<T>(this T value) =>
+             BitRate.FromGigabytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KibibitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromKibibitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate KibibitsPerSecond<T>(this T value) =>
+             BitRate.FromKibibitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KibibytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromKibibytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate KibibytesPerSecond<T>(this T value) =>
+             BitRate.FromKibibytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilobitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromKilobitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate KilobitsPerSecond<T>(this T value) =>
+             BitRate.FromKilobitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilobytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromKilobytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate KilobytesPerSecond<T>(this T value) =>
+             BitRate.FromKilobytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MebibitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromMebibitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate MebibitsPerSecond<T>(this T value) =>
+             BitRate.FromMebibitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MebibytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromMebibytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate MebibytesPerSecond<T>(this T value) =>
+             BitRate.FromMebibytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegabitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromMegabitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate MegabitsPerSecond<T>(this T value) =>
+             BitRate.FromMegabitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegabytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromMegabytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate MegabytesPerSecond<T>(this T value) =>
+             BitRate.FromMegabytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PebibitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromPebibitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate PebibitsPerSecond<T>(this T value) =>
+             BitRate.FromPebibitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PebibytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromPebibytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate PebibytesPerSecond<T>(this T value) =>
+             BitRate.FromPebibytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PetabitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromPetabitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate PetabitsPerSecond<T>(this T value) =>
+             BitRate.FromPetabitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PetabytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromPetabytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate PetabytesPerSecond<T>(this T value) =>
+             BitRate.FromPetabytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TebibitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromTebibitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate TebibitsPerSecond<T>(this T value) =>
+             BitRate.FromTebibitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TebibytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromTebibytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate TebibytesPerSecond<T>(this T value) =>
+             BitRate.FromTebibytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TerabitPerSecond
+
+        /// <inheritdoc cref="BitRate.FromTerabitsPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate TerabitsPerSecond<T>(this T value) =>
+             BitRate.FromTerabitsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TerabytePerSecond
+
+        /// <inheritdoc cref="BitRate.FromTerabytesPerSecond(UnitsNet.QuantityValue)" />
+        public static BitRate TerabytesPerSecond<T>(this T value) =>
+             BitRate.FromTerabytesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
new file mode 100644
index 0000000000..a59ac31744
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToBrakeSpecificFuelConsumption
+{
+    /// <summary>
+    /// A number to BrakeSpecificFuelConsumption Extensions
+    /// </summary>
+    public static class NumberToBrakeSpecificFuelConsumptionExtensions
+    {
+
+        #region GramPerKiloWattHour
+
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(UnitsNet.QuantityValue)" />
+        public static BrakeSpecificFuelConsumption GramsPerKiloWattHour<T>(this T value) =>
+             BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerJoule
+
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromKilogramsPerJoule(UnitsNet.QuantityValue)" />
+        public static BrakeSpecificFuelConsumption KilogramsPerJoule<T>(this T value) =>
+             BrakeSpecificFuelConsumption.FromKilogramsPerJoule(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerMechanicalHorsepowerHour
+
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(UnitsNet.QuantityValue)" />
+        public static BrakeSpecificFuelConsumption PoundsPerMechanicalHorsepowerHour<T>(this T value) =>
+             BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToCapacitanceExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToCapacitanceExtensions.g.cs
new file mode 100644
index 0000000000..cac147945e
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToCapacitanceExtensions.g.cs
@@ -0,0 +1,87 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToCapacitance
+{
+    /// <summary>
+    /// A number to Capacitance Extensions
+    /// </summary>
+    public static class NumberToCapacitanceExtensions
+    {
+
+        #region Farad
+
+        /// <inheritdoc cref="Capacitance.FromFarads(UnitsNet.QuantityValue)" />
+        public static Capacitance Farads<T>(this T value) =>
+             Capacitance.FromFarads(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilofarad
+
+        /// <inheritdoc cref="Capacitance.FromKilofarads(UnitsNet.QuantityValue)" />
+        public static Capacitance Kilofarads<T>(this T value) =>
+             Capacitance.FromKilofarads(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megafarad
+
+        /// <inheritdoc cref="Capacitance.FromMegafarads(UnitsNet.QuantityValue)" />
+        public static Capacitance Megafarads<T>(this T value) =>
+             Capacitance.FromMegafarads(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microfarad
+
+        /// <inheritdoc cref="Capacitance.FromMicrofarads(UnitsNet.QuantityValue)" />
+        public static Capacitance Microfarads<T>(this T value) =>
+             Capacitance.FromMicrofarads(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millifarad
+
+        /// <inheritdoc cref="Capacitance.FromMillifarads(UnitsNet.QuantityValue)" />
+        public static Capacitance Millifarads<T>(this T value) =>
+             Capacitance.FromMillifarads(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanofarad
+
+        /// <inheritdoc cref="Capacitance.FromNanofarads(UnitsNet.QuantityValue)" />
+        public static Capacitance Nanofarads<T>(this T value) =>
+             Capacitance.FromNanofarads(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Picofarad
+
+        /// <inheritdoc cref="Capacitance.FromPicofarads(UnitsNet.QuantityValue)" />
+        public static Capacitance Picofarads<T>(this T value) =>
+             Capacitance.FromPicofarads(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToCoefficientOfThermalExpansionExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToCoefficientOfThermalExpansionExtensions.g.cs
new file mode 100644
index 0000000000..b2584b4818
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToCoefficientOfThermalExpansionExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToCoefficientOfThermalExpansion
+{
+    /// <summary>
+    /// A number to CoefficientOfThermalExpansion Extensions
+    /// </summary>
+    public static class NumberToCoefficientOfThermalExpansionExtensions
+    {
+
+        #region InverseDegreeCelsius
+
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseDegreeCelsius(UnitsNet.QuantityValue)" />
+        public static CoefficientOfThermalExpansion InverseDegreeCelsius<T>(this T value) =>
+             CoefficientOfThermalExpansion.FromInverseDegreeCelsius(Convert.ToDouble(value));
+
+        #endregion
+
+        #region InverseDegreeFahrenheit
+
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(UnitsNet.QuantityValue)" />
+        public static CoefficientOfThermalExpansion InverseDegreeFahrenheit<T>(this T value) =>
+             CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(Convert.ToDouble(value));
+
+        #endregion
+
+        #region InverseKelvin
+
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseKelvin(UnitsNet.QuantityValue)" />
+        public static CoefficientOfThermalExpansion InverseKelvin<T>(this T value) =>
+             CoefficientOfThermalExpansion.FromInverseKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToDensityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToDensityExtensions.g.cs
new file mode 100644
index 0000000000..87b27e81ac
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToDensityExtensions.g.cs
@@ -0,0 +1,351 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToDensity
+{
+    /// <summary>
+    /// A number to Density Extensions
+    /// </summary>
+    public static class NumberToDensityExtensions
+    {
+
+        #region CentigramPerDeciliter
+
+        /// <inheritdoc cref="Density.FromCentigramsPerDeciLiter(UnitsNet.QuantityValue)" />
+        public static Density CentigramsPerDeciLiter<T>(this T value) =>
+             Density.FromCentigramsPerDeciLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentigramPerLiter
+
+        /// <inheritdoc cref="Density.FromCentigramsPerLiter(UnitsNet.QuantityValue)" />
+        public static Density CentigramsPerLiter<T>(this T value) =>
+             Density.FromCentigramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentigramPerMilliliter
+
+        /// <inheritdoc cref="Density.FromCentigramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static Density CentigramsPerMilliliter<T>(this T value) =>
+             Density.FromCentigramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecigramPerDeciliter
+
+        /// <inheritdoc cref="Density.FromDecigramsPerDeciLiter(UnitsNet.QuantityValue)" />
+        public static Density DecigramsPerDeciLiter<T>(this T value) =>
+             Density.FromDecigramsPerDeciLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecigramPerLiter
+
+        /// <inheritdoc cref="Density.FromDecigramsPerLiter(UnitsNet.QuantityValue)" />
+        public static Density DecigramsPerLiter<T>(this T value) =>
+             Density.FromDecigramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecigramPerMilliliter
+
+        /// <inheritdoc cref="Density.FromDecigramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static Density DecigramsPerMilliliter<T>(this T value) =>
+             Density.FromDecigramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerCubicCentimeter
+
+        /// <inheritdoc cref="Density.FromGramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        public static Density GramsPerCubicCentimeter<T>(this T value) =>
+             Density.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerCubicMeter
+
+        /// <inheritdoc cref="Density.FromGramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static Density GramsPerCubicMeter<T>(this T value) =>
+             Density.FromGramsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerCubicMillimeter
+
+        /// <inheritdoc cref="Density.FromGramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        public static Density GramsPerCubicMillimeter<T>(this T value) =>
+             Density.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerDeciliter
+
+        /// <inheritdoc cref="Density.FromGramsPerDeciLiter(UnitsNet.QuantityValue)" />
+        public static Density GramsPerDeciLiter<T>(this T value) =>
+             Density.FromGramsPerDeciLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerLiter
+
+        /// <inheritdoc cref="Density.FromGramsPerLiter(UnitsNet.QuantityValue)" />
+        public static Density GramsPerLiter<T>(this T value) =>
+             Density.FromGramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerMilliliter
+
+        /// <inheritdoc cref="Density.FromGramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static Density GramsPerMilliliter<T>(this T value) =>
+             Density.FromGramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerCubicCentimeter
+
+        /// <inheritdoc cref="Density.FromKilogramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        public static Density KilogramsPerCubicCentimeter<T>(this T value) =>
+             Density.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerCubicMeter
+
+        /// <inheritdoc cref="Density.FromKilogramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static Density KilogramsPerCubicMeter<T>(this T value) =>
+             Density.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerCubicMillimeter
+
+        /// <inheritdoc cref="Density.FromKilogramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        public static Density KilogramsPerCubicMillimeter<T>(this T value) =>
+             Density.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerLiter
+
+        /// <inheritdoc cref="Density.FromKilogramsPerLiter(UnitsNet.QuantityValue)" />
+        public static Density KilogramsPerLiter<T>(this T value) =>
+             Density.FromKilogramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundPerCubicFoot
+
+        /// <inheritdoc cref="Density.FromKilopoundsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static Density KilopoundsPerCubicFoot<T>(this T value) =>
+             Density.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundPerCubicInch
+
+        /// <inheritdoc cref="Density.FromKilopoundsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static Density KilopoundsPerCubicInch<T>(this T value) =>
+             Density.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerCubicMeter
+
+        /// <inheritdoc cref="Density.FromMicrogramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static Density MicrogramsPerCubicMeter<T>(this T value) =>
+             Density.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerDeciliter
+
+        /// <inheritdoc cref="Density.FromMicrogramsPerDeciLiter(UnitsNet.QuantityValue)" />
+        public static Density MicrogramsPerDeciLiter<T>(this T value) =>
+             Density.FromMicrogramsPerDeciLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerLiter
+
+        /// <inheritdoc cref="Density.FromMicrogramsPerLiter(UnitsNet.QuantityValue)" />
+        public static Density MicrogramsPerLiter<T>(this T value) =>
+             Density.FromMicrogramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerMilliliter
+
+        /// <inheritdoc cref="Density.FromMicrogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static Density MicrogramsPerMilliliter<T>(this T value) =>
+             Density.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerCubicMeter
+
+        /// <inheritdoc cref="Density.FromMilligramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static Density MilligramsPerCubicMeter<T>(this T value) =>
+             Density.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerDeciliter
+
+        /// <inheritdoc cref="Density.FromMilligramsPerDeciLiter(UnitsNet.QuantityValue)" />
+        public static Density MilligramsPerDeciLiter<T>(this T value) =>
+             Density.FromMilligramsPerDeciLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerLiter
+
+        /// <inheritdoc cref="Density.FromMilligramsPerLiter(UnitsNet.QuantityValue)" />
+        public static Density MilligramsPerLiter<T>(this T value) =>
+             Density.FromMilligramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerMilliliter
+
+        /// <inheritdoc cref="Density.FromMilligramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static Density MilligramsPerMilliliter<T>(this T value) =>
+             Density.FromMilligramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanogramPerDeciliter
+
+        /// <inheritdoc cref="Density.FromNanogramsPerDeciLiter(UnitsNet.QuantityValue)" />
+        public static Density NanogramsPerDeciLiter<T>(this T value) =>
+             Density.FromNanogramsPerDeciLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanogramPerLiter
+
+        /// <inheritdoc cref="Density.FromNanogramsPerLiter(UnitsNet.QuantityValue)" />
+        public static Density NanogramsPerLiter<T>(this T value) =>
+             Density.FromNanogramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanogramPerMilliliter
+
+        /// <inheritdoc cref="Density.FromNanogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static Density NanogramsPerMilliliter<T>(this T value) =>
+             Density.FromNanogramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicogramPerDeciliter
+
+        /// <inheritdoc cref="Density.FromPicogramsPerDeciLiter(UnitsNet.QuantityValue)" />
+        public static Density PicogramsPerDeciLiter<T>(this T value) =>
+             Density.FromPicogramsPerDeciLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicogramPerLiter
+
+        /// <inheritdoc cref="Density.FromPicogramsPerLiter(UnitsNet.QuantityValue)" />
+        public static Density PicogramsPerLiter<T>(this T value) =>
+             Density.FromPicogramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicogramPerMilliliter
+
+        /// <inheritdoc cref="Density.FromPicogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static Density PicogramsPerMilliliter<T>(this T value) =>
+             Density.FromPicogramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerCubicFoot
+
+        /// <inheritdoc cref="Density.FromPoundsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static Density PoundsPerCubicFoot<T>(this T value) =>
+             Density.FromPoundsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerCubicInch
+
+        /// <inheritdoc cref="Density.FromPoundsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static Density PoundsPerCubicInch<T>(this T value) =>
+             Density.FromPoundsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerImperialGallon
+
+        /// <inheritdoc cref="Density.FromPoundsPerImperialGallon(UnitsNet.QuantityValue)" />
+        public static Density PoundsPerImperialGallon<T>(this T value) =>
+             Density.FromPoundsPerImperialGallon(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerUSGallon
+
+        /// <inheritdoc cref="Density.FromPoundsPerUSGallon(UnitsNet.QuantityValue)" />
+        public static Density PoundsPerUSGallon<T>(this T value) =>
+             Density.FromPoundsPerUSGallon(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SlugPerCubicFoot
+
+        /// <inheritdoc cref="Density.FromSlugsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static Density SlugsPerCubicFoot<T>(this T value) =>
+             Density.FromSlugsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonnePerCubicCentimeter
+
+        /// <inheritdoc cref="Density.FromTonnesPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        public static Density TonnesPerCubicCentimeter<T>(this T value) =>
+             Density.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonnePerCubicMeter
+
+        /// <inheritdoc cref="Density.FromTonnesPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static Density TonnesPerCubicMeter<T>(this T value) =>
+             Density.FromTonnesPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonnePerCubicMillimeter
+
+        /// <inheritdoc cref="Density.FromTonnesPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        public static Density TonnesPerCubicMillimeter<T>(this T value) =>
+             Density.FromTonnesPerCubicMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToDurationExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToDurationExtensions.g.cs
new file mode 100644
index 0000000000..65811813b1
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToDurationExtensions.g.cs
@@ -0,0 +1,111 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToDuration
+{
+    /// <summary>
+    /// A number to Duration Extensions
+    /// </summary>
+    public static class NumberToDurationExtensions
+    {
+
+        #region Day
+
+        /// <inheritdoc cref="Duration.FromDays(UnitsNet.QuantityValue)" />
+        public static Duration Days<T>(this T value) =>
+             Duration.FromDays(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Hour
+
+        /// <inheritdoc cref="Duration.FromHours(UnitsNet.QuantityValue)" />
+        public static Duration Hours<T>(this T value) =>
+             Duration.FromHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microsecond
+
+        /// <inheritdoc cref="Duration.FromMicroseconds(UnitsNet.QuantityValue)" />
+        public static Duration Microseconds<T>(this T value) =>
+             Duration.FromMicroseconds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millisecond
+
+        /// <inheritdoc cref="Duration.FromMilliseconds(UnitsNet.QuantityValue)" />
+        public static Duration Milliseconds<T>(this T value) =>
+             Duration.FromMilliseconds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Minute
+
+        /// <inheritdoc cref="Duration.FromMinutes(UnitsNet.QuantityValue)" />
+        public static Duration Minutes<T>(this T value) =>
+             Duration.FromMinutes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Month30
+
+        /// <inheritdoc cref="Duration.FromMonths30(UnitsNet.QuantityValue)" />
+        public static Duration Months30<T>(this T value) =>
+             Duration.FromMonths30(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanosecond
+
+        /// <inheritdoc cref="Duration.FromNanoseconds(UnitsNet.QuantityValue)" />
+        public static Duration Nanoseconds<T>(this T value) =>
+             Duration.FromNanoseconds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Second
+
+        /// <inheritdoc cref="Duration.FromSeconds(UnitsNet.QuantityValue)" />
+        public static Duration Seconds<T>(this T value) =>
+             Duration.FromSeconds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Week
+
+        /// <inheritdoc cref="Duration.FromWeeks(UnitsNet.QuantityValue)" />
+        public static Duration Weeks<T>(this T value) =>
+             Duration.FromWeeks(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Year365
+
+        /// <inheritdoc cref="Duration.FromYears365(UnitsNet.QuantityValue)" />
+        public static Duration Years365<T>(this T value) =>
+             Duration.FromYears365(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToDynamicViscosityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToDynamicViscosityExtensions.g.cs
new file mode 100644
index 0000000000..a2ffe6931c
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToDynamicViscosityExtensions.g.cs
@@ -0,0 +1,103 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToDynamicViscosity
+{
+    /// <summary>
+    /// A number to DynamicViscosity Extensions
+    /// </summary>
+    public static class NumberToDynamicViscosityExtensions
+    {
+
+        #region Centipoise
+
+        /// <inheritdoc cref="DynamicViscosity.FromCentipoise(UnitsNet.QuantityValue)" />
+        public static DynamicViscosity Centipoise<T>(this T value) =>
+             DynamicViscosity.FromCentipoise(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicropascalSecond
+
+        /// <inheritdoc cref="DynamicViscosity.FromMicropascalSeconds(UnitsNet.QuantityValue)" />
+        public static DynamicViscosity MicropascalSeconds<T>(this T value) =>
+             DynamicViscosity.FromMicropascalSeconds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillipascalSecond
+
+        /// <inheritdoc cref="DynamicViscosity.FromMillipascalSeconds(UnitsNet.QuantityValue)" />
+        public static DynamicViscosity MillipascalSeconds<T>(this T value) =>
+             DynamicViscosity.FromMillipascalSeconds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonSecondPerMeterSquared
+
+        /// <inheritdoc cref="DynamicViscosity.FromNewtonSecondsPerMeterSquared(UnitsNet.QuantityValue)" />
+        public static DynamicViscosity NewtonSecondsPerMeterSquared<T>(this T value) =>
+             DynamicViscosity.FromNewtonSecondsPerMeterSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PascalSecond
+
+        /// <inheritdoc cref="DynamicViscosity.FromPascalSeconds(UnitsNet.QuantityValue)" />
+        public static DynamicViscosity PascalSeconds<T>(this T value) =>
+             DynamicViscosity.FromPascalSeconds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Poise
+
+        /// <inheritdoc cref="DynamicViscosity.FromPoise(UnitsNet.QuantityValue)" />
+        public static DynamicViscosity Poise<T>(this T value) =>
+             DynamicViscosity.FromPoise(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForceSecondPerSquareFoot
+
+        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareFoot(UnitsNet.QuantityValue)" />
+        public static DynamicViscosity PoundsForceSecondPerSquareFoot<T>(this T value) =>
+             DynamicViscosity.FromPoundsForceSecondPerSquareFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForceSecondPerSquareInch
+
+        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareInch(UnitsNet.QuantityValue)" />
+        public static DynamicViscosity PoundsForceSecondPerSquareInch<T>(this T value) =>
+             DynamicViscosity.FromPoundsForceSecondPerSquareInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Reyn
+
+        /// <inheritdoc cref="DynamicViscosity.FromReyns(UnitsNet.QuantityValue)" />
+        public static DynamicViscosity Reyns<T>(this T value) =>
+             DynamicViscosity.FromReyns(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricAdmittanceExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricAdmittanceExtensions.g.cs
new file mode 100644
index 0000000000..0c3a503050
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricAdmittanceExtensions.g.cs
@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricAdmittance
+{
+    /// <summary>
+    /// A number to ElectricAdmittance Extensions
+    /// </summary>
+    public static class NumberToElectricAdmittanceExtensions
+    {
+
+        #region Microsiemens
+
+        /// <inheritdoc cref="ElectricAdmittance.FromMicrosiemens(UnitsNet.QuantityValue)" />
+        public static ElectricAdmittance Microsiemens<T>(this T value) =>
+             ElectricAdmittance.FromMicrosiemens(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millisiemens
+
+        /// <inheritdoc cref="ElectricAdmittance.FromMillisiemens(UnitsNet.QuantityValue)" />
+        public static ElectricAdmittance Millisiemens<T>(this T value) =>
+             ElectricAdmittance.FromMillisiemens(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanosiemens
+
+        /// <inheritdoc cref="ElectricAdmittance.FromNanosiemens(UnitsNet.QuantityValue)" />
+        public static ElectricAdmittance Nanosiemens<T>(this T value) =>
+             ElectricAdmittance.FromNanosiemens(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Siemens
+
+        /// <inheritdoc cref="ElectricAdmittance.FromSiemens(UnitsNet.QuantityValue)" />
+        public static ElectricAdmittance Siemens<T>(this T value) =>
+             ElectricAdmittance.FromSiemens(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeDensityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeDensityExtensions.g.cs
new file mode 100644
index 0000000000..512041dcd8
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeDensityExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricChargeDensity
+{
+    /// <summary>
+    /// A number to ElectricChargeDensity Extensions
+    /// </summary>
+    public static class NumberToElectricChargeDensityExtensions
+    {
+
+        #region CoulombPerCubicMeter
+
+        /// <inheritdoc cref="ElectricChargeDensity.FromCoulombsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static ElectricChargeDensity CoulombsPerCubicMeter<T>(this T value) =>
+             ElectricChargeDensity.FromCoulombsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeExtensions.g.cs
new file mode 100644
index 0000000000..aad5c763b9
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeExtensions.g.cs
@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricCharge
+{
+    /// <summary>
+    /// A number to ElectricCharge Extensions
+    /// </summary>
+    public static class NumberToElectricChargeExtensions
+    {
+
+        #region AmpereHour
+
+        /// <inheritdoc cref="ElectricCharge.FromAmpereHours(UnitsNet.QuantityValue)" />
+        public static ElectricCharge AmpereHours<T>(this T value) =>
+             ElectricCharge.FromAmpereHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Coulomb
+
+        /// <inheritdoc cref="ElectricCharge.FromCoulombs(UnitsNet.QuantityValue)" />
+        public static ElectricCharge Coulombs<T>(this T value) =>
+             ElectricCharge.FromCoulombs(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KiloampereHour
+
+        /// <inheritdoc cref="ElectricCharge.FromKiloampereHours(UnitsNet.QuantityValue)" />
+        public static ElectricCharge KiloampereHours<T>(this T value) =>
+             ElectricCharge.FromKiloampereHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegaampereHour
+
+        /// <inheritdoc cref="ElectricCharge.FromMegaampereHours(UnitsNet.QuantityValue)" />
+        public static ElectricCharge MegaampereHours<T>(this T value) =>
+             ElectricCharge.FromMegaampereHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliampereHour
+
+        /// <inheritdoc cref="ElectricCharge.FromMilliampereHours(UnitsNet.QuantityValue)" />
+        public static ElectricCharge MilliampereHours<T>(this T value) =>
+             ElectricCharge.FromMilliampereHours(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricConductanceExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricConductanceExtensions.g.cs
new file mode 100644
index 0000000000..4f8e7f551b
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricConductanceExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricConductance
+{
+    /// <summary>
+    /// A number to ElectricConductance Extensions
+    /// </summary>
+    public static class NumberToElectricConductanceExtensions
+    {
+
+        #region Microsiemens
+
+        /// <inheritdoc cref="ElectricConductance.FromMicrosiemens(UnitsNet.QuantityValue)" />
+        public static ElectricConductance Microsiemens<T>(this T value) =>
+             ElectricConductance.FromMicrosiemens(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millisiemens
+
+        /// <inheritdoc cref="ElectricConductance.FromMillisiemens(UnitsNet.QuantityValue)" />
+        public static ElectricConductance Millisiemens<T>(this T value) =>
+             ElectricConductance.FromMillisiemens(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Siemens
+
+        /// <inheritdoc cref="ElectricConductance.FromSiemens(UnitsNet.QuantityValue)" />
+        public static ElectricConductance Siemens<T>(this T value) =>
+             ElectricConductance.FromSiemens(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricConductivityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricConductivityExtensions.g.cs
new file mode 100644
index 0000000000..2b8d087938
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricConductivityExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricConductivity
+{
+    /// <summary>
+    /// A number to ElectricConductivity Extensions
+    /// </summary>
+    public static class NumberToElectricConductivityExtensions
+    {
+
+        #region SiemensPerFoot
+
+        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerFoot(UnitsNet.QuantityValue)" />
+        public static ElectricConductivity SiemensPerFoot<T>(this T value) =>
+             ElectricConductivity.FromSiemensPerFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SiemensPerInch
+
+        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerInch(UnitsNet.QuantityValue)" />
+        public static ElectricConductivity SiemensPerInch<T>(this T value) =>
+             ElectricConductivity.FromSiemensPerInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SiemensPerMeter
+
+        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerMeter(UnitsNet.QuantityValue)" />
+        public static ElectricConductivity SiemensPerMeter<T>(this T value) =>
+             ElectricConductivity.FromSiemensPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentDensityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentDensityExtensions.g.cs
new file mode 100644
index 0000000000..2ffd2d2a44
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentDensityExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricCurrentDensity
+{
+    /// <summary>
+    /// A number to ElectricCurrentDensity Extensions
+    /// </summary>
+    public static class NumberToElectricCurrentDensityExtensions
+    {
+
+        #region AmperePerSquareFoot
+
+        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareFoot(UnitsNet.QuantityValue)" />
+        public static ElectricCurrentDensity AmperesPerSquareFoot<T>(this T value) =>
+             ElectricCurrentDensity.FromAmperesPerSquareFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region AmperePerSquareInch
+
+        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareInch(UnitsNet.QuantityValue)" />
+        public static ElectricCurrentDensity AmperesPerSquareInch<T>(this T value) =>
+             ElectricCurrentDensity.FromAmperesPerSquareInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region AmperePerSquareMeter
+
+        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static ElectricCurrentDensity AmperesPerSquareMeter<T>(this T value) =>
+             ElectricCurrentDensity.FromAmperesPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentExtensions.g.cs
new file mode 100644
index 0000000000..4675b5c4a8
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentExtensions.g.cs
@@ -0,0 +1,95 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricCurrent
+{
+    /// <summary>
+    /// A number to ElectricCurrent Extensions
+    /// </summary>
+    public static class NumberToElectricCurrentExtensions
+    {
+
+        #region Ampere
+
+        /// <inheritdoc cref="ElectricCurrent.FromAmperes(UnitsNet.QuantityValue)" />
+        public static ElectricCurrent Amperes<T>(this T value) =>
+             ElectricCurrent.FromAmperes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Centiampere
+
+        /// <inheritdoc cref="ElectricCurrent.FromCentiamperes(UnitsNet.QuantityValue)" />
+        public static ElectricCurrent Centiamperes<T>(this T value) =>
+             ElectricCurrent.FromCentiamperes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kiloampere
+
+        /// <inheritdoc cref="ElectricCurrent.FromKiloamperes(UnitsNet.QuantityValue)" />
+        public static ElectricCurrent Kiloamperes<T>(this T value) =>
+             ElectricCurrent.FromKiloamperes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megaampere
+
+        /// <inheritdoc cref="ElectricCurrent.FromMegaamperes(UnitsNet.QuantityValue)" />
+        public static ElectricCurrent Megaamperes<T>(this T value) =>
+             ElectricCurrent.FromMegaamperes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microampere
+
+        /// <inheritdoc cref="ElectricCurrent.FromMicroamperes(UnitsNet.QuantityValue)" />
+        public static ElectricCurrent Microamperes<T>(this T value) =>
+             ElectricCurrent.FromMicroamperes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Milliampere
+
+        /// <inheritdoc cref="ElectricCurrent.FromMilliamperes(UnitsNet.QuantityValue)" />
+        public static ElectricCurrent Milliamperes<T>(this T value) =>
+             ElectricCurrent.FromMilliamperes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanoampere
+
+        /// <inheritdoc cref="ElectricCurrent.FromNanoamperes(UnitsNet.QuantityValue)" />
+        public static ElectricCurrent Nanoamperes<T>(this T value) =>
+             ElectricCurrent.FromNanoamperes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Picoampere
+
+        /// <inheritdoc cref="ElectricCurrent.FromPicoamperes(UnitsNet.QuantityValue)" />
+        public static ElectricCurrent Picoamperes<T>(this T value) =>
+             ElectricCurrent.FromPicoamperes(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentGradientExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentGradientExtensions.g.cs
new file mode 100644
index 0000000000..5084cab8e9
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentGradientExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricCurrentGradient
+{
+    /// <summary>
+    /// A number to ElectricCurrentGradient Extensions
+    /// </summary>
+    public static class NumberToElectricCurrentGradientExtensions
+    {
+
+        #region AmperePerSecond
+
+        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerSecond(UnitsNet.QuantityValue)" />
+        public static ElectricCurrentGradient AmperesPerSecond<T>(this T value) =>
+             ElectricCurrentGradient.FromAmperesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricFieldExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricFieldExtensions.g.cs
new file mode 100644
index 0000000000..eab7e90467
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricFieldExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricField
+{
+    /// <summary>
+    /// A number to ElectricField Extensions
+    /// </summary>
+    public static class NumberToElectricFieldExtensions
+    {
+
+        #region VoltPerMeter
+
+        /// <inheritdoc cref="ElectricField.FromVoltsPerMeter(UnitsNet.QuantityValue)" />
+        public static ElectricField VoltsPerMeter<T>(this T value) =>
+             ElectricField.FromVoltsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricInductanceExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricInductanceExtensions.g.cs
new file mode 100644
index 0000000000..bea7cb7575
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricInductanceExtensions.g.cs
@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricInductance
+{
+    /// <summary>
+    /// A number to ElectricInductance Extensions
+    /// </summary>
+    public static class NumberToElectricInductanceExtensions
+    {
+
+        #region Henry
+
+        /// <inheritdoc cref="ElectricInductance.FromHenries(UnitsNet.QuantityValue)" />
+        public static ElectricInductance Henries<T>(this T value) =>
+             ElectricInductance.FromHenries(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microhenry
+
+        /// <inheritdoc cref="ElectricInductance.FromMicrohenries(UnitsNet.QuantityValue)" />
+        public static ElectricInductance Microhenries<T>(this T value) =>
+             ElectricInductance.FromMicrohenries(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millihenry
+
+        /// <inheritdoc cref="ElectricInductance.FromMillihenries(UnitsNet.QuantityValue)" />
+        public static ElectricInductance Millihenries<T>(this T value) =>
+             ElectricInductance.FromMillihenries(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanohenry
+
+        /// <inheritdoc cref="ElectricInductance.FromNanohenries(UnitsNet.QuantityValue)" />
+        public static ElectricInductance Nanohenries<T>(this T value) =>
+             ElectricInductance.FromNanohenries(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialAcExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialAcExtensions.g.cs
new file mode 100644
index 0000000000..ac7055f9c8
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialAcExtensions.g.cs
@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricPotentialAc
+{
+    /// <summary>
+    /// A number to ElectricPotentialAc Extensions
+    /// </summary>
+    public static class NumberToElectricPotentialAcExtensions
+    {
+
+        #region KilovoltAc
+
+        /// <inheritdoc cref="ElectricPotentialAc.FromKilovoltsAc(UnitsNet.QuantityValue)" />
+        public static ElectricPotentialAc KilovoltsAc<T>(this T value) =>
+             ElectricPotentialAc.FromKilovoltsAc(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegavoltAc
+
+        /// <inheritdoc cref="ElectricPotentialAc.FromMegavoltsAc(UnitsNet.QuantityValue)" />
+        public static ElectricPotentialAc MegavoltsAc<T>(this T value) =>
+             ElectricPotentialAc.FromMegavoltsAc(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrovoltAc
+
+        /// <inheritdoc cref="ElectricPotentialAc.FromMicrovoltsAc(UnitsNet.QuantityValue)" />
+        public static ElectricPotentialAc MicrovoltsAc<T>(this T value) =>
+             ElectricPotentialAc.FromMicrovoltsAc(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillivoltAc
+
+        /// <inheritdoc cref="ElectricPotentialAc.FromMillivoltsAc(UnitsNet.QuantityValue)" />
+        public static ElectricPotentialAc MillivoltsAc<T>(this T value) =>
+             ElectricPotentialAc.FromMillivoltsAc(Convert.ToDouble(value));
+
+        #endregion
+
+        #region VoltAc
+
+        /// <inheritdoc cref="ElectricPotentialAc.FromVoltsAc(UnitsNet.QuantityValue)" />
+        public static ElectricPotentialAc VoltsAc<T>(this T value) =>
+             ElectricPotentialAc.FromVoltsAc(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialDcExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialDcExtensions.g.cs
new file mode 100644
index 0000000000..f8264354bd
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialDcExtensions.g.cs
@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricPotentialDc
+{
+    /// <summary>
+    /// A number to ElectricPotentialDc Extensions
+    /// </summary>
+    public static class NumberToElectricPotentialDcExtensions
+    {
+
+        #region KilovoltDc
+
+        /// <inheritdoc cref="ElectricPotentialDc.FromKilovoltsDc(UnitsNet.QuantityValue)" />
+        public static ElectricPotentialDc KilovoltsDc<T>(this T value) =>
+             ElectricPotentialDc.FromKilovoltsDc(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegavoltDc
+
+        /// <inheritdoc cref="ElectricPotentialDc.FromMegavoltsDc(UnitsNet.QuantityValue)" />
+        public static ElectricPotentialDc MegavoltsDc<T>(this T value) =>
+             ElectricPotentialDc.FromMegavoltsDc(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrovoltDc
+
+        /// <inheritdoc cref="ElectricPotentialDc.FromMicrovoltsDc(UnitsNet.QuantityValue)" />
+        public static ElectricPotentialDc MicrovoltsDc<T>(this T value) =>
+             ElectricPotentialDc.FromMicrovoltsDc(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillivoltDc
+
+        /// <inheritdoc cref="ElectricPotentialDc.FromMillivoltsDc(UnitsNet.QuantityValue)" />
+        public static ElectricPotentialDc MillivoltsDc<T>(this T value) =>
+             ElectricPotentialDc.FromMillivoltsDc(Convert.ToDouble(value));
+
+        #endregion
+
+        #region VoltDc
+
+        /// <inheritdoc cref="ElectricPotentialDc.FromVoltsDc(UnitsNet.QuantityValue)" />
+        public static ElectricPotentialDc VoltsDc<T>(this T value) =>
+             ElectricPotentialDc.FromVoltsDc(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialExtensions.g.cs
new file mode 100644
index 0000000000..f4de2b9fe5
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialExtensions.g.cs
@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricPotential
+{
+    /// <summary>
+    /// A number to ElectricPotential Extensions
+    /// </summary>
+    public static class NumberToElectricPotentialExtensions
+    {
+
+        #region Kilovolt
+
+        /// <inheritdoc cref="ElectricPotential.FromKilovolts(UnitsNet.QuantityValue)" />
+        public static ElectricPotential Kilovolts<T>(this T value) =>
+             ElectricPotential.FromKilovolts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megavolt
+
+        /// <inheritdoc cref="ElectricPotential.FromMegavolts(UnitsNet.QuantityValue)" />
+        public static ElectricPotential Megavolts<T>(this T value) =>
+             ElectricPotential.FromMegavolts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microvolt
+
+        /// <inheritdoc cref="ElectricPotential.FromMicrovolts(UnitsNet.QuantityValue)" />
+        public static ElectricPotential Microvolts<T>(this T value) =>
+             ElectricPotential.FromMicrovolts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millivolt
+
+        /// <inheritdoc cref="ElectricPotential.FromMillivolts(UnitsNet.QuantityValue)" />
+        public static ElectricPotential Millivolts<T>(this T value) =>
+             ElectricPotential.FromMillivolts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Volt
+
+        /// <inheritdoc cref="ElectricPotential.FromVolts(UnitsNet.QuantityValue)" />
+        public static ElectricPotential Volts<T>(this T value) =>
+             ElectricPotential.FromVolts(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricResistanceExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricResistanceExtensions.g.cs
new file mode 100644
index 0000000000..d984b628a5
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricResistanceExtensions.g.cs
@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricResistance
+{
+    /// <summary>
+    /// A number to ElectricResistance Extensions
+    /// </summary>
+    public static class NumberToElectricResistanceExtensions
+    {
+
+        #region Gigaohm
+
+        /// <inheritdoc cref="ElectricResistance.FromGigaohms(UnitsNet.QuantityValue)" />
+        public static ElectricResistance Gigaohms<T>(this T value) =>
+             ElectricResistance.FromGigaohms(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kiloohm
+
+        /// <inheritdoc cref="ElectricResistance.FromKiloohms(UnitsNet.QuantityValue)" />
+        public static ElectricResistance Kiloohms<T>(this T value) =>
+             ElectricResistance.FromKiloohms(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megaohm
+
+        /// <inheritdoc cref="ElectricResistance.FromMegaohms(UnitsNet.QuantityValue)" />
+        public static ElectricResistance Megaohms<T>(this T value) =>
+             ElectricResistance.FromMegaohms(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Milliohm
+
+        /// <inheritdoc cref="ElectricResistance.FromMilliohms(UnitsNet.QuantityValue)" />
+        public static ElectricResistance Milliohms<T>(this T value) =>
+             ElectricResistance.FromMilliohms(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Ohm
+
+        /// <inheritdoc cref="ElectricResistance.FromOhms(UnitsNet.QuantityValue)" />
+        public static ElectricResistance Ohms<T>(this T value) =>
+             ElectricResistance.FromOhms(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricResistivityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricResistivityExtensions.g.cs
new file mode 100644
index 0000000000..2621f0981e
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricResistivityExtensions.g.cs
@@ -0,0 +1,143 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricResistivity
+{
+    /// <summary>
+    /// A number to ElectricResistivity Extensions
+    /// </summary>
+    public static class NumberToElectricResistivityExtensions
+    {
+
+        #region KiloohmCentimeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromKiloohmsCentimeter(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity KiloohmsCentimeter<T>(this T value) =>
+             ElectricResistivity.FromKiloohmsCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KiloohmMeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromKiloohmMeters(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity KiloohmMeters<T>(this T value) =>
+             ElectricResistivity.FromKiloohmMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegaohmCentimeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromMegaohmsCentimeter(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity MegaohmsCentimeter<T>(this T value) =>
+             ElectricResistivity.FromMegaohmsCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegaohmMeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromMegaohmMeters(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity MegaohmMeters<T>(this T value) =>
+             ElectricResistivity.FromMegaohmMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicroohmCentimeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromMicroohmsCentimeter(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity MicroohmsCentimeter<T>(this T value) =>
+             ElectricResistivity.FromMicroohmsCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicroohmMeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromMicroohmMeters(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity MicroohmMeters<T>(this T value) =>
+             ElectricResistivity.FromMicroohmMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliohmCentimeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromMilliohmsCentimeter(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity MilliohmsCentimeter<T>(this T value) =>
+             ElectricResistivity.FromMilliohmsCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliohmMeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromMilliohmMeters(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity MilliohmMeters<T>(this T value) =>
+             ElectricResistivity.FromMilliohmMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanoohmCentimeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromNanoohmsCentimeter(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity NanoohmsCentimeter<T>(this T value) =>
+             ElectricResistivity.FromNanoohmsCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanoohmMeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromNanoohmMeters(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity NanoohmMeters<T>(this T value) =>
+             ElectricResistivity.FromNanoohmMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region OhmCentimeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromOhmsCentimeter(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity OhmsCentimeter<T>(this T value) =>
+             ElectricResistivity.FromOhmsCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region OhmMeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromOhmMeters(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity OhmMeters<T>(this T value) =>
+             ElectricResistivity.FromOhmMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicoohmCentimeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromPicoohmsCentimeter(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity PicoohmsCentimeter<T>(this T value) =>
+             ElectricResistivity.FromPicoohmsCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicoohmMeter
+
+        /// <inheritdoc cref="ElectricResistivity.FromPicoohmMeters(UnitsNet.QuantityValue)" />
+        public static ElectricResistivity PicoohmMeters<T>(this T value) =>
+             ElectricResistivity.FromPicoohmMeters(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricSurfaceChargeDensityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToElectricSurfaceChargeDensityExtensions.g.cs
new file mode 100644
index 0000000000..fbfd812c3c
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToElectricSurfaceChargeDensityExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToElectricSurfaceChargeDensity
+{
+    /// <summary>
+    /// A number to ElectricSurfaceChargeDensity Extensions
+    /// </summary>
+    public static class NumberToElectricSurfaceChargeDensityExtensions
+    {
+
+        #region CoulombPerSquareCentimeter
+
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static ElectricSurfaceChargeDensity CoulombsPerSquareCentimeter<T>(this T value) =>
+             ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CoulombPerSquareInch
+
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(UnitsNet.QuantityValue)" />
+        public static ElectricSurfaceChargeDensity CoulombsPerSquareInch<T>(this T value) =>
+             ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CoulombPerSquareMeter
+
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static ElectricSurfaceChargeDensity CoulombsPerSquareMeter<T>(this T value) =>
+             ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToEnergyExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToEnergyExtensions.g.cs
new file mode 100644
index 0000000000..497bf3b2fa
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToEnergyExtensions.g.cs
@@ -0,0 +1,239 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToEnergy
+{
+    /// <summary>
+    /// A number to Energy Extensions
+    /// </summary>
+    public static class NumberToEnergyExtensions
+    {
+
+        #region BritishThermalUnit
+
+        /// <inheritdoc cref="Energy.FromBritishThermalUnits(UnitsNet.QuantityValue)" />
+        public static Energy BritishThermalUnits<T>(this T value) =>
+             Energy.FromBritishThermalUnits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Calorie
+
+        /// <inheritdoc cref="Energy.FromCalories(UnitsNet.QuantityValue)" />
+        public static Energy Calories<T>(this T value) =>
+             Energy.FromCalories(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecathermEc
+
+        /// <inheritdoc cref="Energy.FromDecathermsEc(UnitsNet.QuantityValue)" />
+        public static Energy DecathermsEc<T>(this T value) =>
+             Energy.FromDecathermsEc(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecathermImperial
+
+        /// <inheritdoc cref="Energy.FromDecathermsImperial(UnitsNet.QuantityValue)" />
+        public static Energy DecathermsImperial<T>(this T value) =>
+             Energy.FromDecathermsImperial(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecathermUs
+
+        /// <inheritdoc cref="Energy.FromDecathermsUs(UnitsNet.QuantityValue)" />
+        public static Energy DecathermsUs<T>(this T value) =>
+             Energy.FromDecathermsUs(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ElectronVolt
+
+        /// <inheritdoc cref="Energy.FromElectronVolts(UnitsNet.QuantityValue)" />
+        public static Energy ElectronVolts<T>(this T value) =>
+             Energy.FromElectronVolts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Erg
+
+        /// <inheritdoc cref="Energy.FromErgs(UnitsNet.QuantityValue)" />
+        public static Energy Ergs<T>(this T value) =>
+             Energy.FromErgs(Convert.ToDouble(value));
+
+        #endregion
+
+        #region FootPound
+
+        /// <inheritdoc cref="Energy.FromFootPounds(UnitsNet.QuantityValue)" />
+        public static Energy FootPounds<T>(this T value) =>
+             Energy.FromFootPounds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GigabritishThermalUnit
+
+        /// <inheritdoc cref="Energy.FromGigabritishThermalUnits(UnitsNet.QuantityValue)" />
+        public static Energy GigabritishThermalUnits<T>(this T value) =>
+             Energy.FromGigabritishThermalUnits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Gigajoule
+
+        /// <inheritdoc cref="Energy.FromGigajoules(UnitsNet.QuantityValue)" />
+        public static Energy Gigajoules<T>(this T value) =>
+             Energy.FromGigajoules(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GigawattHour
+
+        /// <inheritdoc cref="Energy.FromGigawattHours(UnitsNet.QuantityValue)" />
+        public static Energy GigawattHours<T>(this T value) =>
+             Energy.FromGigawattHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Joule
+
+        /// <inheritdoc cref="Energy.FromJoules(UnitsNet.QuantityValue)" />
+        public static Energy Joules<T>(this T value) =>
+             Energy.FromJoules(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilobritishThermalUnit
+
+        /// <inheritdoc cref="Energy.FromKilobritishThermalUnits(UnitsNet.QuantityValue)" />
+        public static Energy KilobritishThermalUnits<T>(this T value) =>
+             Energy.FromKilobritishThermalUnits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilocalorie
+
+        /// <inheritdoc cref="Energy.FromKilocalories(UnitsNet.QuantityValue)" />
+        public static Energy Kilocalories<T>(this T value) =>
+             Energy.FromKilocalories(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilojoule
+
+        /// <inheritdoc cref="Energy.FromKilojoules(UnitsNet.QuantityValue)" />
+        public static Energy Kilojoules<T>(this T value) =>
+             Energy.FromKilojoules(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilowattHour
+
+        /// <inheritdoc cref="Energy.FromKilowattHours(UnitsNet.QuantityValue)" />
+        public static Energy KilowattHours<T>(this T value) =>
+             Energy.FromKilowattHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegabritishThermalUnit
+
+        /// <inheritdoc cref="Energy.FromMegabritishThermalUnits(UnitsNet.QuantityValue)" />
+        public static Energy MegabritishThermalUnits<T>(this T value) =>
+             Energy.FromMegabritishThermalUnits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megacalorie
+
+        /// <inheritdoc cref="Energy.FromMegacalories(UnitsNet.QuantityValue)" />
+        public static Energy Megacalories<T>(this T value) =>
+             Energy.FromMegacalories(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megajoule
+
+        /// <inheritdoc cref="Energy.FromMegajoules(UnitsNet.QuantityValue)" />
+        public static Energy Megajoules<T>(this T value) =>
+             Energy.FromMegajoules(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegawattHour
+
+        /// <inheritdoc cref="Energy.FromMegawattHours(UnitsNet.QuantityValue)" />
+        public static Energy MegawattHours<T>(this T value) =>
+             Energy.FromMegawattHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millijoule
+
+        /// <inheritdoc cref="Energy.FromMillijoules(UnitsNet.QuantityValue)" />
+        public static Energy Millijoules<T>(this T value) =>
+             Energy.FromMillijoules(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TerawattHour
+
+        /// <inheritdoc cref="Energy.FromTerawattHours(UnitsNet.QuantityValue)" />
+        public static Energy TerawattHours<T>(this T value) =>
+             Energy.FromTerawattHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ThermEc
+
+        /// <inheritdoc cref="Energy.FromThermsEc(UnitsNet.QuantityValue)" />
+        public static Energy ThermsEc<T>(this T value) =>
+             Energy.FromThermsEc(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ThermImperial
+
+        /// <inheritdoc cref="Energy.FromThermsImperial(UnitsNet.QuantityValue)" />
+        public static Energy ThermsImperial<T>(this T value) =>
+             Energy.FromThermsImperial(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ThermUs
+
+        /// <inheritdoc cref="Energy.FromThermsUs(UnitsNet.QuantityValue)" />
+        public static Energy ThermsUs<T>(this T value) =>
+             Energy.FromThermsUs(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattHour
+
+        /// <inheritdoc cref="Energy.FromWattHours(UnitsNet.QuantityValue)" />
+        public static Energy WattHours<T>(this T value) =>
+             Energy.FromWattHours(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToEntropyExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToEntropyExtensions.g.cs
new file mode 100644
index 0000000000..870ece646e
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToEntropyExtensions.g.cs
@@ -0,0 +1,87 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToEntropy
+{
+    /// <summary>
+    /// A number to Entropy Extensions
+    /// </summary>
+    public static class NumberToEntropyExtensions
+    {
+
+        #region CaloriePerKelvin
+
+        /// <inheritdoc cref="Entropy.FromCaloriesPerKelvin(UnitsNet.QuantityValue)" />
+        public static Entropy CaloriesPerKelvin<T>(this T value) =>
+             Entropy.FromCaloriesPerKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+        #region JoulePerDegreeCelsius
+
+        /// <inheritdoc cref="Entropy.FromJoulesPerDegreeCelsius(UnitsNet.QuantityValue)" />
+        public static Entropy JoulesPerDegreeCelsius<T>(this T value) =>
+             Entropy.FromJoulesPerDegreeCelsius(Convert.ToDouble(value));
+
+        #endregion
+
+        #region JoulePerKelvin
+
+        /// <inheritdoc cref="Entropy.FromJoulesPerKelvin(UnitsNet.QuantityValue)" />
+        public static Entropy JoulesPerKelvin<T>(this T value) =>
+             Entropy.FromJoulesPerKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilocaloriePerKelvin
+
+        /// <inheritdoc cref="Entropy.FromKilocaloriesPerKelvin(UnitsNet.QuantityValue)" />
+        public static Entropy KilocaloriesPerKelvin<T>(this T value) =>
+             Entropy.FromKilocaloriesPerKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilojoulePerDegreeCelsius
+
+        /// <inheritdoc cref="Entropy.FromKilojoulesPerDegreeCelsius(UnitsNet.QuantityValue)" />
+        public static Entropy KilojoulesPerDegreeCelsius<T>(this T value) =>
+             Entropy.FromKilojoulesPerDegreeCelsius(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilojoulePerKelvin
+
+        /// <inheritdoc cref="Entropy.FromKilojoulesPerKelvin(UnitsNet.QuantityValue)" />
+        public static Entropy KilojoulesPerKelvin<T>(this T value) =>
+             Entropy.FromKilojoulesPerKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegajoulePerKelvin
+
+        /// <inheritdoc cref="Entropy.FromMegajoulesPerKelvin(UnitsNet.QuantityValue)" />
+        public static Entropy MegajoulesPerKelvin<T>(this T value) =>
+             Entropy.FromMegajoulesPerKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToForceChangeRateExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToForceChangeRateExtensions.g.cs
new file mode 100644
index 0000000000..fd752acf59
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToForceChangeRateExtensions.g.cs
@@ -0,0 +1,119 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToForceChangeRate
+{
+    /// <summary>
+    /// A number to ForceChangeRate Extensions
+    /// </summary>
+    public static class NumberToForceChangeRateExtensions
+    {
+
+        #region CentinewtonPerSecond
+
+        /// <inheritdoc cref="ForceChangeRate.FromCentinewtonsPerSecond(UnitsNet.QuantityValue)" />
+        public static ForceChangeRate CentinewtonsPerSecond<T>(this T value) =>
+             ForceChangeRate.FromCentinewtonsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecanewtonPerMinute
+
+        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerMinute(UnitsNet.QuantityValue)" />
+        public static ForceChangeRate DecanewtonsPerMinute<T>(this T value) =>
+             ForceChangeRate.FromDecanewtonsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecanewtonPerSecond
+
+        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerSecond(UnitsNet.QuantityValue)" />
+        public static ForceChangeRate DecanewtonsPerSecond<T>(this T value) =>
+             ForceChangeRate.FromDecanewtonsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecinewtonPerSecond
+
+        /// <inheritdoc cref="ForceChangeRate.FromDecinewtonsPerSecond(UnitsNet.QuantityValue)" />
+        public static ForceChangeRate DecinewtonsPerSecond<T>(this T value) =>
+             ForceChangeRate.FromDecinewtonsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonPerMinute
+
+        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerMinute(UnitsNet.QuantityValue)" />
+        public static ForceChangeRate KilonewtonsPerMinute<T>(this T value) =>
+             ForceChangeRate.FromKilonewtonsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonPerSecond
+
+        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerSecond(UnitsNet.QuantityValue)" />
+        public static ForceChangeRate KilonewtonsPerSecond<T>(this T value) =>
+             ForceChangeRate.FromKilonewtonsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicronewtonPerSecond
+
+        /// <inheritdoc cref="ForceChangeRate.FromMicronewtonsPerSecond(UnitsNet.QuantityValue)" />
+        public static ForceChangeRate MicronewtonsPerSecond<T>(this T value) =>
+             ForceChangeRate.FromMicronewtonsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillinewtonPerSecond
+
+        /// <inheritdoc cref="ForceChangeRate.FromMillinewtonsPerSecond(UnitsNet.QuantityValue)" />
+        public static ForceChangeRate MillinewtonsPerSecond<T>(this T value) =>
+             ForceChangeRate.FromMillinewtonsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanonewtonPerSecond
+
+        /// <inheritdoc cref="ForceChangeRate.FromNanonewtonsPerSecond(UnitsNet.QuantityValue)" />
+        public static ForceChangeRate NanonewtonsPerSecond<T>(this T value) =>
+             ForceChangeRate.FromNanonewtonsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonPerMinute
+
+        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerMinute(UnitsNet.QuantityValue)" />
+        public static ForceChangeRate NewtonsPerMinute<T>(this T value) =>
+             ForceChangeRate.FromNewtonsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonPerSecond
+
+        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerSecond(UnitsNet.QuantityValue)" />
+        public static ForceChangeRate NewtonsPerSecond<T>(this T value) =>
+             ForceChangeRate.FromNewtonsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToForceExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToForceExtensions.g.cs
new file mode 100644
index 0000000000..c731af802d
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToForceExtensions.g.cs
@@ -0,0 +1,135 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToForce
+{
+    /// <summary>
+    /// A number to Force Extensions
+    /// </summary>
+    public static class NumberToForceExtensions
+    {
+
+        #region Decanewton
+
+        /// <inheritdoc cref="Force.FromDecanewtons(UnitsNet.QuantityValue)" />
+        public static Force Decanewtons<T>(this T value) =>
+             Force.FromDecanewtons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Dyn
+
+        /// <inheritdoc cref="Force.FromDyne(UnitsNet.QuantityValue)" />
+        public static Force Dyne<T>(this T value) =>
+             Force.FromDyne(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramForce
+
+        /// <inheritdoc cref="Force.FromKilogramsForce(UnitsNet.QuantityValue)" />
+        public static Force KilogramsForce<T>(this T value) =>
+             Force.FromKilogramsForce(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilonewton
+
+        /// <inheritdoc cref="Force.FromKilonewtons(UnitsNet.QuantityValue)" />
+        public static Force Kilonewtons<T>(this T value) =>
+             Force.FromKilonewtons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KiloPond
+
+        /// <inheritdoc cref="Force.FromKiloPonds(UnitsNet.QuantityValue)" />
+        public static Force KiloPonds<T>(this T value) =>
+             Force.FromKiloPonds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Meganewton
+
+        /// <inheritdoc cref="Force.FromMeganewtons(UnitsNet.QuantityValue)" />
+        public static Force Meganewtons<T>(this T value) =>
+             Force.FromMeganewtons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Micronewton
+
+        /// <inheritdoc cref="Force.FromMicronewtons(UnitsNet.QuantityValue)" />
+        public static Force Micronewtons<T>(this T value) =>
+             Force.FromMicronewtons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millinewton
+
+        /// <inheritdoc cref="Force.FromMillinewtons(UnitsNet.QuantityValue)" />
+        public static Force Millinewtons<T>(this T value) =>
+             Force.FromMillinewtons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Newton
+
+        /// <inheritdoc cref="Force.FromNewtons(UnitsNet.QuantityValue)" />
+        public static Force Newtons<T>(this T value) =>
+             Force.FromNewtons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region OunceForce
+
+        /// <inheritdoc cref="Force.FromOunceForce(UnitsNet.QuantityValue)" />
+        public static Force OunceForce<T>(this T value) =>
+             Force.FromOunceForce(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Poundal
+
+        /// <inheritdoc cref="Force.FromPoundals(UnitsNet.QuantityValue)" />
+        public static Force Poundals<T>(this T value) =>
+             Force.FromPoundals(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForce
+
+        /// <inheritdoc cref="Force.FromPoundsForce(UnitsNet.QuantityValue)" />
+        public static Force PoundsForce<T>(this T value) =>
+             Force.FromPoundsForce(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForce
+
+        /// <inheritdoc cref="Force.FromTonnesForce(UnitsNet.QuantityValue)" />
+        public static Force TonnesForce<T>(this T value) =>
+             Force.FromTonnesForce(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToForcePerLengthExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToForcePerLengthExtensions.g.cs
new file mode 100644
index 0000000000..89753bf110
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToForcePerLengthExtensions.g.cs
@@ -0,0 +1,127 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToForcePerLength
+{
+    /// <summary>
+    /// A number to ForcePerLength Extensions
+    /// </summary>
+    public static class NumberToForcePerLengthExtensions
+    {
+
+        #region CentinewtonPerMeter
+
+        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMeter(UnitsNet.QuantityValue)" />
+        public static ForcePerLength CentinewtonsPerMeter<T>(this T value) =>
+             ForcePerLength.FromCentinewtonsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecinewtonPerMeter
+
+        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMeter(UnitsNet.QuantityValue)" />
+        public static ForcePerLength DecinewtonsPerMeter<T>(this T value) =>
+             ForcePerLength.FromDecinewtonsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramForcePerMeter
+
+        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMeter(UnitsNet.QuantityValue)" />
+        public static ForcePerLength KilogramsForcePerMeter<T>(this T value) =>
+             ForcePerLength.FromKilogramsForcePerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonPerMeter
+
+        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMeter(UnitsNet.QuantityValue)" />
+        public static ForcePerLength KilonewtonsPerMeter<T>(this T value) =>
+             ForcePerLength.FromKilonewtonsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeganewtonPerMeter
+
+        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMeter(UnitsNet.QuantityValue)" />
+        public static ForcePerLength MeganewtonsPerMeter<T>(this T value) =>
+             ForcePerLength.FromMeganewtonsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicronewtonPerMeter
+
+        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMeter(UnitsNet.QuantityValue)" />
+        public static ForcePerLength MicronewtonsPerMeter<T>(this T value) =>
+             ForcePerLength.FromMicronewtonsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillinewtonPerMeter
+
+        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMeter(UnitsNet.QuantityValue)" />
+        public static ForcePerLength MillinewtonsPerMeter<T>(this T value) =>
+             ForcePerLength.FromMillinewtonsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanonewtonPerMeter
+
+        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMeter(UnitsNet.QuantityValue)" />
+        public static ForcePerLength NanonewtonsPerMeter<T>(this T value) =>
+             ForcePerLength.FromNanonewtonsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonPerMeter
+
+        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMeter(UnitsNet.QuantityValue)" />
+        public static ForcePerLength NewtonsPerMeter<T>(this T value) =>
+             ForcePerLength.FromNewtonsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForcePerFoot
+
+        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerFoot(UnitsNet.QuantityValue)" />
+        public static ForcePerLength PoundsForcePerFoot<T>(this T value) =>
+             ForcePerLength.FromPoundsForcePerFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForcePerInch
+
+        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerInch(UnitsNet.QuantityValue)" />
+        public static ForcePerLength PoundsForcePerInch<T>(this T value) =>
+             ForcePerLength.FromPoundsForcePerInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForcePerYard
+
+        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerYard(UnitsNet.QuantityValue)" />
+        public static ForcePerLength PoundsForcePerYard<T>(this T value) =>
+             ForcePerLength.FromPoundsForcePerYard(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToFrequencyExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToFrequencyExtensions.g.cs
new file mode 100644
index 0000000000..3f12c1bc39
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToFrequencyExtensions.g.cs
@@ -0,0 +1,103 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToFrequency
+{
+    /// <summary>
+    /// A number to Frequency Extensions
+    /// </summary>
+    public static class NumberToFrequencyExtensions
+    {
+
+        #region BeatPerMinute
+
+        /// <inheritdoc cref="Frequency.FromBeatsPerMinute(UnitsNet.QuantityValue)" />
+        public static Frequency BeatsPerMinute<T>(this T value) =>
+             Frequency.FromBeatsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CyclePerHour
+
+        /// <inheritdoc cref="Frequency.FromCyclesPerHour(UnitsNet.QuantityValue)" />
+        public static Frequency CyclesPerHour<T>(this T value) =>
+             Frequency.FromCyclesPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CyclePerMinute
+
+        /// <inheritdoc cref="Frequency.FromCyclesPerMinute(UnitsNet.QuantityValue)" />
+        public static Frequency CyclesPerMinute<T>(this T value) =>
+             Frequency.FromCyclesPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Gigahertz
+
+        /// <inheritdoc cref="Frequency.FromGigahertz(UnitsNet.QuantityValue)" />
+        public static Frequency Gigahertz<T>(this T value) =>
+             Frequency.FromGigahertz(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Hertz
+
+        /// <inheritdoc cref="Frequency.FromHertz(UnitsNet.QuantityValue)" />
+        public static Frequency Hertz<T>(this T value) =>
+             Frequency.FromHertz(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilohertz
+
+        /// <inheritdoc cref="Frequency.FromKilohertz(UnitsNet.QuantityValue)" />
+        public static Frequency Kilohertz<T>(this T value) =>
+             Frequency.FromKilohertz(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megahertz
+
+        /// <inheritdoc cref="Frequency.FromMegahertz(UnitsNet.QuantityValue)" />
+        public static Frequency Megahertz<T>(this T value) =>
+             Frequency.FromMegahertz(Convert.ToDouble(value));
+
+        #endregion
+
+        #region RadianPerSecond
+
+        /// <inheritdoc cref="Frequency.FromRadiansPerSecond(UnitsNet.QuantityValue)" />
+        public static Frequency RadiansPerSecond<T>(this T value) =>
+             Frequency.FromRadiansPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Terahertz
+
+        /// <inheritdoc cref="Frequency.FromTerahertz(UnitsNet.QuantityValue)" />
+        public static Frequency Terahertz<T>(this T value) =>
+             Frequency.FromTerahertz(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToFuelEfficiencyExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToFuelEfficiencyExtensions.g.cs
new file mode 100644
index 0000000000..b8b420f3e0
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToFuelEfficiencyExtensions.g.cs
@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToFuelEfficiency
+{
+    /// <summary>
+    /// A number to FuelEfficiency Extensions
+    /// </summary>
+    public static class NumberToFuelEfficiencyExtensions
+    {
+
+        #region KilometerPerLiter
+
+        /// <inheritdoc cref="FuelEfficiency.FromKilometersPerLiters(UnitsNet.QuantityValue)" />
+        public static FuelEfficiency KilometersPerLiters<T>(this T value) =>
+             FuelEfficiency.FromKilometersPerLiters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region LiterPer100Kilometers
+
+        /// <inheritdoc cref="FuelEfficiency.FromLitersPer100Kilometers(UnitsNet.QuantityValue)" />
+        public static FuelEfficiency LitersPer100Kilometers<T>(this T value) =>
+             FuelEfficiency.FromLitersPer100Kilometers(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilePerUkGallon
+
+        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUkGallon(UnitsNet.QuantityValue)" />
+        public static FuelEfficiency MilesPerUkGallon<T>(this T value) =>
+             FuelEfficiency.FromMilesPerUkGallon(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilePerUsGallon
+
+        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUsGallon(UnitsNet.QuantityValue)" />
+        public static FuelEfficiency MilesPerUsGallon<T>(this T value) =>
+             FuelEfficiency.FromMilesPerUsGallon(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToHeatFluxExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToHeatFluxExtensions.g.cs
new file mode 100644
index 0000000000..c413d84c08
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToHeatFluxExtensions.g.cs
@@ -0,0 +1,175 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToHeatFlux
+{
+    /// <summary>
+    /// A number to HeatFlux Extensions
+    /// </summary>
+    public static class NumberToHeatFluxExtensions
+    {
+
+        #region BtuPerHourSquareFoot
+
+        /// <inheritdoc cref="HeatFlux.FromBtusPerHourSquareFoot(UnitsNet.QuantityValue)" />
+        public static HeatFlux BtusPerHourSquareFoot<T>(this T value) =>
+             HeatFlux.FromBtusPerHourSquareFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region BtuPerMinuteSquareFoot
+
+        /// <inheritdoc cref="HeatFlux.FromBtusPerMinuteSquareFoot(UnitsNet.QuantityValue)" />
+        public static HeatFlux BtusPerMinuteSquareFoot<T>(this T value) =>
+             HeatFlux.FromBtusPerMinuteSquareFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region BtuPerSecondSquareFoot
+
+        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareFoot(UnitsNet.QuantityValue)" />
+        public static HeatFlux BtusPerSecondSquareFoot<T>(this T value) =>
+             HeatFlux.FromBtusPerSecondSquareFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region BtuPerSecondSquareInch
+
+        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareInch(UnitsNet.QuantityValue)" />
+        public static HeatFlux BtusPerSecondSquareInch<T>(this T value) =>
+             HeatFlux.FromBtusPerSecondSquareInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CaloriePerSecondSquareCentimeter
+
+        /// <inheritdoc cref="HeatFlux.FromCaloriesPerSecondSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static HeatFlux CaloriesPerSecondSquareCentimeter<T>(this T value) =>
+             HeatFlux.FromCaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentiwattPerSquareMeter
+
+        /// <inheritdoc cref="HeatFlux.FromCentiwattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static HeatFlux CentiwattsPerSquareMeter<T>(this T value) =>
+             HeatFlux.FromCentiwattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DeciwattPerSquareMeter
+
+        /// <inheritdoc cref="HeatFlux.FromDeciwattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static HeatFlux DeciwattsPerSquareMeter<T>(this T value) =>
+             HeatFlux.FromDeciwattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilocaloriePerHourSquareMeter
+
+        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerHourSquareMeter(UnitsNet.QuantityValue)" />
+        public static HeatFlux KilocaloriesPerHourSquareMeter<T>(this T value) =>
+             HeatFlux.FromKilocaloriesPerHourSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilocaloriePerSecondSquareCentimeter
+
+        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static HeatFlux KilocaloriesPerSecondSquareCentimeter<T>(this T value) =>
+             HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilowattPerSquareMeter
+
+        /// <inheritdoc cref="HeatFlux.FromKilowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static HeatFlux KilowattsPerSquareMeter<T>(this T value) =>
+             HeatFlux.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrowattPerSquareMeter
+
+        /// <inheritdoc cref="HeatFlux.FromMicrowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static HeatFlux MicrowattsPerSquareMeter<T>(this T value) =>
+             HeatFlux.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliwattPerSquareMeter
+
+        /// <inheritdoc cref="HeatFlux.FromMilliwattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static HeatFlux MilliwattsPerSquareMeter<T>(this T value) =>
+             HeatFlux.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanowattPerSquareMeter
+
+        /// <inheritdoc cref="HeatFlux.FromNanowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static HeatFlux NanowattsPerSquareMeter<T>(this T value) =>
+             HeatFlux.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForcePerFootSecond
+
+        /// <inheritdoc cref="HeatFlux.FromPoundsForcePerFootSecond(UnitsNet.QuantityValue)" />
+        public static HeatFlux PoundsForcePerFootSecond<T>(this T value) =>
+             HeatFlux.FromPoundsForcePerFootSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerSecondCubed
+
+        /// <inheritdoc cref="HeatFlux.FromPoundsPerSecondCubed(UnitsNet.QuantityValue)" />
+        public static HeatFlux PoundsPerSecondCubed<T>(this T value) =>
+             HeatFlux.FromPoundsPerSecondCubed(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerSquareFoot
+
+        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareFoot(UnitsNet.QuantityValue)" />
+        public static HeatFlux WattsPerSquareFoot<T>(this T value) =>
+             HeatFlux.FromWattsPerSquareFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerSquareInch
+
+        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareInch(UnitsNet.QuantityValue)" />
+        public static HeatFlux WattsPerSquareInch<T>(this T value) =>
+             HeatFlux.FromWattsPerSquareInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerSquareMeter
+
+        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static HeatFlux WattsPerSquareMeter<T>(this T value) =>
+             HeatFlux.FromWattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToHeatTransferCoefficientExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToHeatTransferCoefficientExtensions.g.cs
new file mode 100644
index 0000000000..a8112c9d6b
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToHeatTransferCoefficientExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToHeatTransferCoefficient
+{
+    /// <summary>
+    /// A number to HeatTransferCoefficient Extensions
+    /// </summary>
+    public static class NumberToHeatTransferCoefficientExtensions
+    {
+
+        #region BtuPerSquareFootDegreeFahrenheit
+
+        /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(UnitsNet.QuantityValue)" />
+        public static HeatTransferCoefficient BtusPerSquareFootDegreeFahrenheit<T>(this T value) =>
+             HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerSquareMeterCelsius
+
+        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(UnitsNet.QuantityValue)" />
+        public static HeatTransferCoefficient WattsPerSquareMeterCelsius<T>(this T value) =>
+             HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerSquareMeterKelvin
+
+        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(UnitsNet.QuantityValue)" />
+        public static HeatTransferCoefficient WattsPerSquareMeterKelvin<T>(this T value) =>
+             HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToIlluminanceExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToIlluminanceExtensions.g.cs
new file mode 100644
index 0000000000..8ea3a42f1b
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToIlluminanceExtensions.g.cs
@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToIlluminance
+{
+    /// <summary>
+    /// A number to Illuminance Extensions
+    /// </summary>
+    public static class NumberToIlluminanceExtensions
+    {
+
+        #region Kilolux
+
+        /// <inheritdoc cref="Illuminance.FromKilolux(UnitsNet.QuantityValue)" />
+        public static Illuminance Kilolux<T>(this T value) =>
+             Illuminance.FromKilolux(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Lux
+
+        /// <inheritdoc cref="Illuminance.FromLux(UnitsNet.QuantityValue)" />
+        public static Illuminance Lux<T>(this T value) =>
+             Illuminance.FromLux(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megalux
+
+        /// <inheritdoc cref="Illuminance.FromMegalux(UnitsNet.QuantityValue)" />
+        public static Illuminance Megalux<T>(this T value) =>
+             Illuminance.FromMegalux(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millilux
+
+        /// <inheritdoc cref="Illuminance.FromMillilux(UnitsNet.QuantityValue)" />
+        public static Illuminance Millilux<T>(this T value) =>
+             Illuminance.FromMillilux(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToInformationExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToInformationExtensions.g.cs
new file mode 100644
index 0000000000..9841e7761f
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToInformationExtensions.g.cs
@@ -0,0 +1,239 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToInformation
+{
+    /// <summary>
+    /// A number to Information Extensions
+    /// </summary>
+    public static class NumberToInformationExtensions
+    {
+
+        #region Bit
+
+        /// <inheritdoc cref="Information.FromBits(UnitsNet.QuantityValue)" />
+        public static Information Bits<T>(this T value) =>
+             Information.FromBits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Byte
+
+        /// <inheritdoc cref="Information.FromBytes(UnitsNet.QuantityValue)" />
+        public static Information Bytes<T>(this T value) =>
+             Information.FromBytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Exabit
+
+        /// <inheritdoc cref="Information.FromExabits(UnitsNet.QuantityValue)" />
+        public static Information Exabits<T>(this T value) =>
+             Information.FromExabits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Exabyte
+
+        /// <inheritdoc cref="Information.FromExabytes(UnitsNet.QuantityValue)" />
+        public static Information Exabytes<T>(this T value) =>
+             Information.FromExabytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Exbibit
+
+        /// <inheritdoc cref="Information.FromExbibits(UnitsNet.QuantityValue)" />
+        public static Information Exbibits<T>(this T value) =>
+             Information.FromExbibits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Exbibyte
+
+        /// <inheritdoc cref="Information.FromExbibytes(UnitsNet.QuantityValue)" />
+        public static Information Exbibytes<T>(this T value) =>
+             Information.FromExbibytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Gibibit
+
+        /// <inheritdoc cref="Information.FromGibibits(UnitsNet.QuantityValue)" />
+        public static Information Gibibits<T>(this T value) =>
+             Information.FromGibibits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Gibibyte
+
+        /// <inheritdoc cref="Information.FromGibibytes(UnitsNet.QuantityValue)" />
+        public static Information Gibibytes<T>(this T value) =>
+             Information.FromGibibytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Gigabit
+
+        /// <inheritdoc cref="Information.FromGigabits(UnitsNet.QuantityValue)" />
+        public static Information Gigabits<T>(this T value) =>
+             Information.FromGigabits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Gigabyte
+
+        /// <inheritdoc cref="Information.FromGigabytes(UnitsNet.QuantityValue)" />
+        public static Information Gigabytes<T>(this T value) =>
+             Information.FromGigabytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kibibit
+
+        /// <inheritdoc cref="Information.FromKibibits(UnitsNet.QuantityValue)" />
+        public static Information Kibibits<T>(this T value) =>
+             Information.FromKibibits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kibibyte
+
+        /// <inheritdoc cref="Information.FromKibibytes(UnitsNet.QuantityValue)" />
+        public static Information Kibibytes<T>(this T value) =>
+             Information.FromKibibytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilobit
+
+        /// <inheritdoc cref="Information.FromKilobits(UnitsNet.QuantityValue)" />
+        public static Information Kilobits<T>(this T value) =>
+             Information.FromKilobits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilobyte
+
+        /// <inheritdoc cref="Information.FromKilobytes(UnitsNet.QuantityValue)" />
+        public static Information Kilobytes<T>(this T value) =>
+             Information.FromKilobytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Mebibit
+
+        /// <inheritdoc cref="Information.FromMebibits(UnitsNet.QuantityValue)" />
+        public static Information Mebibits<T>(this T value) =>
+             Information.FromMebibits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Mebibyte
+
+        /// <inheritdoc cref="Information.FromMebibytes(UnitsNet.QuantityValue)" />
+        public static Information Mebibytes<T>(this T value) =>
+             Information.FromMebibytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megabit
+
+        /// <inheritdoc cref="Information.FromMegabits(UnitsNet.QuantityValue)" />
+        public static Information Megabits<T>(this T value) =>
+             Information.FromMegabits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megabyte
+
+        /// <inheritdoc cref="Information.FromMegabytes(UnitsNet.QuantityValue)" />
+        public static Information Megabytes<T>(this T value) =>
+             Information.FromMegabytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Pebibit
+
+        /// <inheritdoc cref="Information.FromPebibits(UnitsNet.QuantityValue)" />
+        public static Information Pebibits<T>(this T value) =>
+             Information.FromPebibits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Pebibyte
+
+        /// <inheritdoc cref="Information.FromPebibytes(UnitsNet.QuantityValue)" />
+        public static Information Pebibytes<T>(this T value) =>
+             Information.FromPebibytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Petabit
+
+        /// <inheritdoc cref="Information.FromPetabits(UnitsNet.QuantityValue)" />
+        public static Information Petabits<T>(this T value) =>
+             Information.FromPetabits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Petabyte
+
+        /// <inheritdoc cref="Information.FromPetabytes(UnitsNet.QuantityValue)" />
+        public static Information Petabytes<T>(this T value) =>
+             Information.FromPetabytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Tebibit
+
+        /// <inheritdoc cref="Information.FromTebibits(UnitsNet.QuantityValue)" />
+        public static Information Tebibits<T>(this T value) =>
+             Information.FromTebibits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Tebibyte
+
+        /// <inheritdoc cref="Information.FromTebibytes(UnitsNet.QuantityValue)" />
+        public static Information Tebibytes<T>(this T value) =>
+             Information.FromTebibytes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Terabit
+
+        /// <inheritdoc cref="Information.FromTerabits(UnitsNet.QuantityValue)" />
+        public static Information Terabits<T>(this T value) =>
+             Information.FromTerabits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Terabyte
+
+        /// <inheritdoc cref="Information.FromTerabytes(UnitsNet.QuantityValue)" />
+        public static Information Terabytes<T>(this T value) =>
+             Information.FromTerabytes(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToIrradianceExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToIrradianceExtensions.g.cs
new file mode 100644
index 0000000000..cb374c4c13
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToIrradianceExtensions.g.cs
@@ -0,0 +1,143 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToIrradiance
+{
+    /// <summary>
+    /// A number to Irradiance Extensions
+    /// </summary>
+    public static class NumberToIrradianceExtensions
+    {
+
+        #region KilowattPerSquareCentimeter
+
+        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Irradiance KilowattsPerSquareCentimeter<T>(this T value) =>
+             Irradiance.FromKilowattsPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilowattPerSquareMeter
+
+        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Irradiance KilowattsPerSquareMeter<T>(this T value) =>
+             Irradiance.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegawattPerSquareCentimeter
+
+        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Irradiance MegawattsPerSquareCentimeter<T>(this T value) =>
+             Irradiance.FromMegawattsPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegawattPerSquareMeter
+
+        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Irradiance MegawattsPerSquareMeter<T>(this T value) =>
+             Irradiance.FromMegawattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrowattPerSquareCentimeter
+
+        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Irradiance MicrowattsPerSquareCentimeter<T>(this T value) =>
+             Irradiance.FromMicrowattsPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrowattPerSquareMeter
+
+        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Irradiance MicrowattsPerSquareMeter<T>(this T value) =>
+             Irradiance.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliwattPerSquareCentimeter
+
+        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Irradiance MilliwattsPerSquareCentimeter<T>(this T value) =>
+             Irradiance.FromMilliwattsPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliwattPerSquareMeter
+
+        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Irradiance MilliwattsPerSquareMeter<T>(this T value) =>
+             Irradiance.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanowattPerSquareCentimeter
+
+        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Irradiance NanowattsPerSquareCentimeter<T>(this T value) =>
+             Irradiance.FromNanowattsPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanowattPerSquareMeter
+
+        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Irradiance NanowattsPerSquareMeter<T>(this T value) =>
+             Irradiance.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicowattPerSquareCentimeter
+
+        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Irradiance PicowattsPerSquareCentimeter<T>(this T value) =>
+             Irradiance.FromPicowattsPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicowattPerSquareMeter
+
+        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Irradiance PicowattsPerSquareMeter<T>(this T value) =>
+             Irradiance.FromPicowattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerSquareCentimeter
+
+        /// <inheritdoc cref="Irradiance.FromWattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Irradiance WattsPerSquareCentimeter<T>(this T value) =>
+             Irradiance.FromWattsPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerSquareMeter
+
+        /// <inheritdoc cref="Irradiance.FromWattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Irradiance WattsPerSquareMeter<T>(this T value) =>
+             Irradiance.FromWattsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToIrradiationExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToIrradiationExtensions.g.cs
new file mode 100644
index 0000000000..a8ccc6d840
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToIrradiationExtensions.g.cs
@@ -0,0 +1,87 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToIrradiation
+{
+    /// <summary>
+    /// A number to Irradiation Extensions
+    /// </summary>
+    public static class NumberToIrradiationExtensions
+    {
+
+        #region JoulePerSquareCentimeter
+
+        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Irradiation JoulesPerSquareCentimeter<T>(this T value) =>
+             Irradiation.FromJoulesPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region JoulePerSquareMeter
+
+        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Irradiation JoulesPerSquareMeter<T>(this T value) =>
+             Irradiation.FromJoulesPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region JoulePerSquareMillimeter
+
+        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMillimeter(UnitsNet.QuantityValue)" />
+        public static Irradiation JoulesPerSquareMillimeter<T>(this T value) =>
+             Irradiation.FromJoulesPerSquareMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilojoulePerSquareMeter
+
+        /// <inheritdoc cref="Irradiation.FromKilojoulesPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Irradiation KilojoulesPerSquareMeter<T>(this T value) =>
+             Irradiation.FromKilojoulesPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilowattHourPerSquareMeter
+
+        /// <inheritdoc cref="Irradiation.FromKilowattHoursPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Irradiation KilowattHoursPerSquareMeter<T>(this T value) =>
+             Irradiation.FromKilowattHoursPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillijoulePerSquareCentimeter
+
+        /// <inheritdoc cref="Irradiation.FromMillijoulesPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Irradiation MillijoulesPerSquareCentimeter<T>(this T value) =>
+             Irradiation.FromMillijoulesPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattHourPerSquareMeter
+
+        /// <inheritdoc cref="Irradiation.FromWattHoursPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Irradiation WattHoursPerSquareMeter<T>(this T value) =>
+             Irradiation.FromWattHoursPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToKinematicViscosityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToKinematicViscosityExtensions.g.cs
new file mode 100644
index 0000000000..212bd8fd45
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToKinematicViscosityExtensions.g.cs
@@ -0,0 +1,95 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToKinematicViscosity
+{
+    /// <summary>
+    /// A number to KinematicViscosity Extensions
+    /// </summary>
+    public static class NumberToKinematicViscosityExtensions
+    {
+
+        #region Centistokes
+
+        /// <inheritdoc cref="KinematicViscosity.FromCentistokes(UnitsNet.QuantityValue)" />
+        public static KinematicViscosity Centistokes<T>(this T value) =>
+             KinematicViscosity.FromCentistokes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Decistokes
+
+        /// <inheritdoc cref="KinematicViscosity.FromDecistokes(UnitsNet.QuantityValue)" />
+        public static KinematicViscosity Decistokes<T>(this T value) =>
+             KinematicViscosity.FromDecistokes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilostokes
+
+        /// <inheritdoc cref="KinematicViscosity.FromKilostokes(UnitsNet.QuantityValue)" />
+        public static KinematicViscosity Kilostokes<T>(this T value) =>
+             KinematicViscosity.FromKilostokes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microstokes
+
+        /// <inheritdoc cref="KinematicViscosity.FromMicrostokes(UnitsNet.QuantityValue)" />
+        public static KinematicViscosity Microstokes<T>(this T value) =>
+             KinematicViscosity.FromMicrostokes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millistokes
+
+        /// <inheritdoc cref="KinematicViscosity.FromMillistokes(UnitsNet.QuantityValue)" />
+        public static KinematicViscosity Millistokes<T>(this T value) =>
+             KinematicViscosity.FromMillistokes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanostokes
+
+        /// <inheritdoc cref="KinematicViscosity.FromNanostokes(UnitsNet.QuantityValue)" />
+        public static KinematicViscosity Nanostokes<T>(this T value) =>
+             KinematicViscosity.FromNanostokes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareMeterPerSecond
+
+        /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(UnitsNet.QuantityValue)" />
+        public static KinematicViscosity SquareMetersPerSecond<T>(this T value) =>
+             KinematicViscosity.FromSquareMetersPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Stokes
+
+        /// <inheritdoc cref="KinematicViscosity.FromStokes(UnitsNet.QuantityValue)" />
+        public static KinematicViscosity Stokes<T>(this T value) =>
+             KinematicViscosity.FromStokes(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLapseRateExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToLapseRateExtensions.g.cs
new file mode 100644
index 0000000000..e3309ca74f
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToLapseRateExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToLapseRate
+{
+    /// <summary>
+    /// A number to LapseRate Extensions
+    /// </summary>
+    public static class NumberToLapseRateExtensions
+    {
+
+        #region DegreeCelsiusPerKilometer
+
+        /// <inheritdoc cref="LapseRate.FromDegreesCelciusPerKilometer(UnitsNet.QuantityValue)" />
+        public static LapseRate DegreesCelciusPerKilometer<T>(this T value) =>
+             LapseRate.FromDegreesCelciusPerKilometer(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLengthExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToLengthExtensions.g.cs
new file mode 100644
index 0000000000..5f6bcb5787
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToLengthExtensions.g.cs
@@ -0,0 +1,287 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToLength
+{
+    /// <summary>
+    /// A number to Length Extensions
+    /// </summary>
+    public static class NumberToLengthExtensions
+    {
+
+        #region AstronomicalUnit
+
+        /// <inheritdoc cref="Length.FromAstronomicalUnits(UnitsNet.QuantityValue)" />
+        public static Length AstronomicalUnits<T>(this T value) =>
+             Length.FromAstronomicalUnits(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Centimeter
+
+        /// <inheritdoc cref="Length.FromCentimeters(UnitsNet.QuantityValue)" />
+        public static Length Centimeters<T>(this T value) =>
+             Length.FromCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Decimeter
+
+        /// <inheritdoc cref="Length.FromDecimeters(UnitsNet.QuantityValue)" />
+        public static Length Decimeters<T>(this T value) =>
+             Length.FromDecimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DtpPica
+
+        /// <inheritdoc cref="Length.FromDtpPicas(UnitsNet.QuantityValue)" />
+        public static Length DtpPicas<T>(this T value) =>
+             Length.FromDtpPicas(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DtpPoint
+
+        /// <inheritdoc cref="Length.FromDtpPoints(UnitsNet.QuantityValue)" />
+        public static Length DtpPoints<T>(this T value) =>
+             Length.FromDtpPoints(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Fathom
+
+        /// <inheritdoc cref="Length.FromFathoms(UnitsNet.QuantityValue)" />
+        public static Length Fathoms<T>(this T value) =>
+             Length.FromFathoms(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Foot
+
+        /// <inheritdoc cref="Length.FromFeet(UnitsNet.QuantityValue)" />
+        public static Length Feet<T>(this T value) =>
+             Length.FromFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Hand
+
+        /// <inheritdoc cref="Length.FromHands(UnitsNet.QuantityValue)" />
+        public static Length Hands<T>(this T value) =>
+             Length.FromHands(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Hectometer
+
+        /// <inheritdoc cref="Length.FromHectometers(UnitsNet.QuantityValue)" />
+        public static Length Hectometers<T>(this T value) =>
+             Length.FromHectometers(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Inch
+
+        /// <inheritdoc cref="Length.FromInches(UnitsNet.QuantityValue)" />
+        public static Length Inches<T>(this T value) =>
+             Length.FromInches(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilolightYear
+
+        /// <inheritdoc cref="Length.FromKilolightYears(UnitsNet.QuantityValue)" />
+        public static Length KilolightYears<T>(this T value) =>
+             Length.FromKilolightYears(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilometer
+
+        /// <inheritdoc cref="Length.FromKilometers(UnitsNet.QuantityValue)" />
+        public static Length Kilometers<T>(this T value) =>
+             Length.FromKilometers(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kiloparsec
+
+        /// <inheritdoc cref="Length.FromKiloparsecs(UnitsNet.QuantityValue)" />
+        public static Length Kiloparsecs<T>(this T value) =>
+             Length.FromKiloparsecs(Convert.ToDouble(value));
+
+        #endregion
+
+        #region LightYear
+
+        /// <inheritdoc cref="Length.FromLightYears(UnitsNet.QuantityValue)" />
+        public static Length LightYears<T>(this T value) =>
+             Length.FromLightYears(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegalightYear
+
+        /// <inheritdoc cref="Length.FromMegalightYears(UnitsNet.QuantityValue)" />
+        public static Length MegalightYears<T>(this T value) =>
+             Length.FromMegalightYears(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megaparsec
+
+        /// <inheritdoc cref="Length.FromMegaparsecs(UnitsNet.QuantityValue)" />
+        public static Length Megaparsecs<T>(this T value) =>
+             Length.FromMegaparsecs(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Meter
+
+        /// <inheritdoc cref="Length.FromMeters(UnitsNet.QuantityValue)" />
+        public static Length Meters<T>(this T value) =>
+             Length.FromMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microinch
+
+        /// <inheritdoc cref="Length.FromMicroinches(UnitsNet.QuantityValue)" />
+        public static Length Microinches<T>(this T value) =>
+             Length.FromMicroinches(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Micrometer
+
+        /// <inheritdoc cref="Length.FromMicrometers(UnitsNet.QuantityValue)" />
+        public static Length Micrometers<T>(this T value) =>
+             Length.FromMicrometers(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Mil
+
+        /// <inheritdoc cref="Length.FromMils(UnitsNet.QuantityValue)" />
+        public static Length Mils<T>(this T value) =>
+             Length.FromMils(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Mile
+
+        /// <inheritdoc cref="Length.FromMiles(UnitsNet.QuantityValue)" />
+        public static Length Miles<T>(this T value) =>
+             Length.FromMiles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millimeter
+
+        /// <inheritdoc cref="Length.FromMillimeters(UnitsNet.QuantityValue)" />
+        public static Length Millimeters<T>(this T value) =>
+             Length.FromMillimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanometer
+
+        /// <inheritdoc cref="Length.FromNanometers(UnitsNet.QuantityValue)" />
+        public static Length Nanometers<T>(this T value) =>
+             Length.FromNanometers(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NauticalMile
+
+        /// <inheritdoc cref="Length.FromNauticalMiles(UnitsNet.QuantityValue)" />
+        public static Length NauticalMiles<T>(this T value) =>
+             Length.FromNauticalMiles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Parsec
+
+        /// <inheritdoc cref="Length.FromParsecs(UnitsNet.QuantityValue)" />
+        public static Length Parsecs<T>(this T value) =>
+             Length.FromParsecs(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PrinterPica
+
+        /// <inheritdoc cref="Length.FromPrinterPicas(UnitsNet.QuantityValue)" />
+        public static Length PrinterPicas<T>(this T value) =>
+             Length.FromPrinterPicas(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PrinterPoint
+
+        /// <inheritdoc cref="Length.FromPrinterPoints(UnitsNet.QuantityValue)" />
+        public static Length PrinterPoints<T>(this T value) =>
+             Length.FromPrinterPoints(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Shackle
+
+        /// <inheritdoc cref="Length.FromShackles(UnitsNet.QuantityValue)" />
+        public static Length Shackles<T>(this T value) =>
+             Length.FromShackles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SolarRadius
+
+        /// <inheritdoc cref="Length.FromSolarRadiuses(UnitsNet.QuantityValue)" />
+        public static Length SolarRadiuses<T>(this T value) =>
+             Length.FromSolarRadiuses(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Twip
+
+        /// <inheritdoc cref="Length.FromTwips(UnitsNet.QuantityValue)" />
+        public static Length Twips<T>(this T value) =>
+             Length.FromTwips(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsSurveyFoot
+
+        /// <inheritdoc cref="Length.FromUsSurveyFeet(UnitsNet.QuantityValue)" />
+        public static Length UsSurveyFeet<T>(this T value) =>
+             Length.FromUsSurveyFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Yard
+
+        /// <inheritdoc cref="Length.FromYards(UnitsNet.QuantityValue)" />
+        public static Length Yards<T>(this T value) =>
+             Length.FromYards(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLevelExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToLevelExtensions.g.cs
new file mode 100644
index 0000000000..1420e13a87
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToLevelExtensions.g.cs
@@ -0,0 +1,47 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToLevel
+{
+    /// <summary>
+    /// A number to Level Extensions
+    /// </summary>
+    public static class NumberToLevelExtensions
+    {
+
+        #region Decibel
+
+        /// <inheritdoc cref="Level.FromDecibels(UnitsNet.QuantityValue)" />
+        public static Level Decibels<T>(this T value) =>
+             Level.FromDecibels(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Neper
+
+        /// <inheritdoc cref="Level.FromNepers(UnitsNet.QuantityValue)" />
+        public static Level Nepers<T>(this T value) =>
+             Level.FromNepers(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLinearDensityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToLinearDensityExtensions.g.cs
new file mode 100644
index 0000000000..3984925a0a
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToLinearDensityExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToLinearDensity
+{
+    /// <summary>
+    /// A number to LinearDensity Extensions
+    /// </summary>
+    public static class NumberToLinearDensityExtensions
+    {
+
+        #region GramPerMeter
+
+        /// <inheritdoc cref="LinearDensity.FromGramsPerMeter(UnitsNet.QuantityValue)" />
+        public static LinearDensity GramsPerMeter<T>(this T value) =>
+             LinearDensity.FromGramsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerMeter
+
+        /// <inheritdoc cref="LinearDensity.FromKilogramsPerMeter(UnitsNet.QuantityValue)" />
+        public static LinearDensity KilogramsPerMeter<T>(this T value) =>
+             LinearDensity.FromKilogramsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerFoot
+
+        /// <inheritdoc cref="LinearDensity.FromPoundsPerFoot(UnitsNet.QuantityValue)" />
+        public static LinearDensity PoundsPerFoot<T>(this T value) =>
+             LinearDensity.FromPoundsPerFoot(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLuminosityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToLuminosityExtensions.g.cs
new file mode 100644
index 0000000000..75a5195d72
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToLuminosityExtensions.g.cs
@@ -0,0 +1,143 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToLuminosity
+{
+    /// <summary>
+    /// A number to Luminosity Extensions
+    /// </summary>
+    public static class NumberToLuminosityExtensions
+    {
+
+        #region Decawatt
+
+        /// <inheritdoc cref="Luminosity.FromDecawatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Decawatts<T>(this T value) =>
+             Luminosity.FromDecawatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Deciwatt
+
+        /// <inheritdoc cref="Luminosity.FromDeciwatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Deciwatts<T>(this T value) =>
+             Luminosity.FromDeciwatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Femtowatt
+
+        /// <inheritdoc cref="Luminosity.FromFemtowatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Femtowatts<T>(this T value) =>
+             Luminosity.FromFemtowatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Gigawatt
+
+        /// <inheritdoc cref="Luminosity.FromGigawatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Gigawatts<T>(this T value) =>
+             Luminosity.FromGigawatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilowatt
+
+        /// <inheritdoc cref="Luminosity.FromKilowatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Kilowatts<T>(this T value) =>
+             Luminosity.FromKilowatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megawatt
+
+        /// <inheritdoc cref="Luminosity.FromMegawatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Megawatts<T>(this T value) =>
+             Luminosity.FromMegawatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microwatt
+
+        /// <inheritdoc cref="Luminosity.FromMicrowatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Microwatts<T>(this T value) =>
+             Luminosity.FromMicrowatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Milliwatt
+
+        /// <inheritdoc cref="Luminosity.FromMilliwatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Milliwatts<T>(this T value) =>
+             Luminosity.FromMilliwatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanowatt
+
+        /// <inheritdoc cref="Luminosity.FromNanowatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Nanowatts<T>(this T value) =>
+             Luminosity.FromNanowatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Petawatt
+
+        /// <inheritdoc cref="Luminosity.FromPetawatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Petawatts<T>(this T value) =>
+             Luminosity.FromPetawatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Picowatt
+
+        /// <inheritdoc cref="Luminosity.FromPicowatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Picowatts<T>(this T value) =>
+             Luminosity.FromPicowatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SolarLuminosity
+
+        /// <inheritdoc cref="Luminosity.FromSolarLuminosities(UnitsNet.QuantityValue)" />
+        public static Luminosity SolarLuminosities<T>(this T value) =>
+             Luminosity.FromSolarLuminosities(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Terawatt
+
+        /// <inheritdoc cref="Luminosity.FromTerawatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Terawatts<T>(this T value) =>
+             Luminosity.FromTerawatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Watt
+
+        /// <inheritdoc cref="Luminosity.FromWatts(UnitsNet.QuantityValue)" />
+        public static Luminosity Watts<T>(this T value) =>
+             Luminosity.FromWatts(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLuminousFluxExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToLuminousFluxExtensions.g.cs
new file mode 100644
index 0000000000..d451ee9b3a
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToLuminousFluxExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToLuminousFlux
+{
+    /// <summary>
+    /// A number to LuminousFlux Extensions
+    /// </summary>
+    public static class NumberToLuminousFluxExtensions
+    {
+
+        #region Lumen
+
+        /// <inheritdoc cref="LuminousFlux.FromLumens(UnitsNet.QuantityValue)" />
+        public static LuminousFlux Lumens<T>(this T value) =>
+             LuminousFlux.FromLumens(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLuminousIntensityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToLuminousIntensityExtensions.g.cs
new file mode 100644
index 0000000000..5b649ed116
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToLuminousIntensityExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToLuminousIntensity
+{
+    /// <summary>
+    /// A number to LuminousIntensity Extensions
+    /// </summary>
+    public static class NumberToLuminousIntensityExtensions
+    {
+
+        #region Candela
+
+        /// <inheritdoc cref="LuminousIntensity.FromCandela(UnitsNet.QuantityValue)" />
+        public static LuminousIntensity Candela<T>(this T value) =>
+             LuminousIntensity.FromCandela(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMagneticFieldExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMagneticFieldExtensions.g.cs
new file mode 100644
index 0000000000..329ccaff0e
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMagneticFieldExtensions.g.cs
@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMagneticField
+{
+    /// <summary>
+    /// A number to MagneticField Extensions
+    /// </summary>
+    public static class NumberToMagneticFieldExtensions
+    {
+
+        #region Microtesla
+
+        /// <inheritdoc cref="MagneticField.FromMicroteslas(UnitsNet.QuantityValue)" />
+        public static MagneticField Microteslas<T>(this T value) =>
+             MagneticField.FromMicroteslas(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millitesla
+
+        /// <inheritdoc cref="MagneticField.FromMilliteslas(UnitsNet.QuantityValue)" />
+        public static MagneticField Milliteslas<T>(this T value) =>
+             MagneticField.FromMilliteslas(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanotesla
+
+        /// <inheritdoc cref="MagneticField.FromNanoteslas(UnitsNet.QuantityValue)" />
+        public static MagneticField Nanoteslas<T>(this T value) =>
+             MagneticField.FromNanoteslas(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Tesla
+
+        /// <inheritdoc cref="MagneticField.FromTeslas(UnitsNet.QuantityValue)" />
+        public static MagneticField Teslas<T>(this T value) =>
+             MagneticField.FromTeslas(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMagneticFluxExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMagneticFluxExtensions.g.cs
new file mode 100644
index 0000000000..d6a410fa55
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMagneticFluxExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMagneticFlux
+{
+    /// <summary>
+    /// A number to MagneticFlux Extensions
+    /// </summary>
+    public static class NumberToMagneticFluxExtensions
+    {
+
+        #region Weber
+
+        /// <inheritdoc cref="MagneticFlux.FromWebers(UnitsNet.QuantityValue)" />
+        public static MagneticFlux Webers<T>(this T value) =>
+             MagneticFlux.FromWebers(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMagnetizationExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMagnetizationExtensions.g.cs
new file mode 100644
index 0000000000..7bff2646f5
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMagnetizationExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMagnetization
+{
+    /// <summary>
+    /// A number to Magnetization Extensions
+    /// </summary>
+    public static class NumberToMagnetizationExtensions
+    {
+
+        #region AmperePerMeter
+
+        /// <inheritdoc cref="Magnetization.FromAmperesPerMeter(UnitsNet.QuantityValue)" />
+        public static Magnetization AmperesPerMeter<T>(this T value) =>
+             Magnetization.FromAmperesPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassConcentrationExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMassConcentrationExtensions.g.cs
new file mode 100644
index 0000000000..1904a1b535
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMassConcentrationExtensions.g.cs
@@ -0,0 +1,351 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMassConcentration
+{
+    /// <summary>
+    /// A number to MassConcentration Extensions
+    /// </summary>
+    public static class NumberToMassConcentrationExtensions
+    {
+
+        #region CentigramPerDeciliter
+
+        /// <inheritdoc cref="MassConcentration.FromCentigramsPerDeciliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration CentigramsPerDeciliter<T>(this T value) =>
+             MassConcentration.FromCentigramsPerDeciliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentigramPerLiter
+
+        /// <inheritdoc cref="MassConcentration.FromCentigramsPerLiter(UnitsNet.QuantityValue)" />
+        public static MassConcentration CentigramsPerLiter<T>(this T value) =>
+             MassConcentration.FromCentigramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentigramPerMilliliter
+
+        /// <inheritdoc cref="MassConcentration.FromCentigramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration CentigramsPerMilliliter<T>(this T value) =>
+             MassConcentration.FromCentigramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecigramPerDeciliter
+
+        /// <inheritdoc cref="MassConcentration.FromDecigramsPerDeciliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration DecigramsPerDeciliter<T>(this T value) =>
+             MassConcentration.FromDecigramsPerDeciliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecigramPerLiter
+
+        /// <inheritdoc cref="MassConcentration.FromDecigramsPerLiter(UnitsNet.QuantityValue)" />
+        public static MassConcentration DecigramsPerLiter<T>(this T value) =>
+             MassConcentration.FromDecigramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecigramPerMilliliter
+
+        /// <inheritdoc cref="MassConcentration.FromDecigramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration DecigramsPerMilliliter<T>(this T value) =>
+             MassConcentration.FromDecigramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerCubicCentimeter
+
+        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        public static MassConcentration GramsPerCubicCentimeter<T>(this T value) =>
+             MassConcentration.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerCubicMeter
+
+        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static MassConcentration GramsPerCubicMeter<T>(this T value) =>
+             MassConcentration.FromGramsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerCubicMillimeter
+
+        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        public static MassConcentration GramsPerCubicMillimeter<T>(this T value) =>
+             MassConcentration.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerDeciliter
+
+        /// <inheritdoc cref="MassConcentration.FromGramsPerDeciliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration GramsPerDeciliter<T>(this T value) =>
+             MassConcentration.FromGramsPerDeciliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerLiter
+
+        /// <inheritdoc cref="MassConcentration.FromGramsPerLiter(UnitsNet.QuantityValue)" />
+        public static MassConcentration GramsPerLiter<T>(this T value) =>
+             MassConcentration.FromGramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerMilliliter
+
+        /// <inheritdoc cref="MassConcentration.FromGramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration GramsPerMilliliter<T>(this T value) =>
+             MassConcentration.FromGramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerCubicCentimeter
+
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        public static MassConcentration KilogramsPerCubicCentimeter<T>(this T value) =>
+             MassConcentration.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerCubicMeter
+
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static MassConcentration KilogramsPerCubicMeter<T>(this T value) =>
+             MassConcentration.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerCubicMillimeter
+
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        public static MassConcentration KilogramsPerCubicMillimeter<T>(this T value) =>
+             MassConcentration.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerLiter
+
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerLiter(UnitsNet.QuantityValue)" />
+        public static MassConcentration KilogramsPerLiter<T>(this T value) =>
+             MassConcentration.FromKilogramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundPerCubicFoot
+
+        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static MassConcentration KilopoundsPerCubicFoot<T>(this T value) =>
+             MassConcentration.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundPerCubicInch
+
+        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static MassConcentration KilopoundsPerCubicInch<T>(this T value) =>
+             MassConcentration.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerCubicMeter
+
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static MassConcentration MicrogramsPerCubicMeter<T>(this T value) =>
+             MassConcentration.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerDeciliter
+
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerDeciliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration MicrogramsPerDeciliter<T>(this T value) =>
+             MassConcentration.FromMicrogramsPerDeciliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerLiter
+
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerLiter(UnitsNet.QuantityValue)" />
+        public static MassConcentration MicrogramsPerLiter<T>(this T value) =>
+             MassConcentration.FromMicrogramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerMilliliter
+
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration MicrogramsPerMilliliter<T>(this T value) =>
+             MassConcentration.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerCubicMeter
+
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static MassConcentration MilligramsPerCubicMeter<T>(this T value) =>
+             MassConcentration.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerDeciliter
+
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerDeciliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration MilligramsPerDeciliter<T>(this T value) =>
+             MassConcentration.FromMilligramsPerDeciliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerLiter
+
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerLiter(UnitsNet.QuantityValue)" />
+        public static MassConcentration MilligramsPerLiter<T>(this T value) =>
+             MassConcentration.FromMilligramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerMilliliter
+
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration MilligramsPerMilliliter<T>(this T value) =>
+             MassConcentration.FromMilligramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanogramPerDeciliter
+
+        /// <inheritdoc cref="MassConcentration.FromNanogramsPerDeciliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration NanogramsPerDeciliter<T>(this T value) =>
+             MassConcentration.FromNanogramsPerDeciliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanogramPerLiter
+
+        /// <inheritdoc cref="MassConcentration.FromNanogramsPerLiter(UnitsNet.QuantityValue)" />
+        public static MassConcentration NanogramsPerLiter<T>(this T value) =>
+             MassConcentration.FromNanogramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanogramPerMilliliter
+
+        /// <inheritdoc cref="MassConcentration.FromNanogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration NanogramsPerMilliliter<T>(this T value) =>
+             MassConcentration.FromNanogramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicogramPerDeciliter
+
+        /// <inheritdoc cref="MassConcentration.FromPicogramsPerDeciliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration PicogramsPerDeciliter<T>(this T value) =>
+             MassConcentration.FromPicogramsPerDeciliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicogramPerLiter
+
+        /// <inheritdoc cref="MassConcentration.FromPicogramsPerLiter(UnitsNet.QuantityValue)" />
+        public static MassConcentration PicogramsPerLiter<T>(this T value) =>
+             MassConcentration.FromPicogramsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicogramPerMilliliter
+
+        /// <inheritdoc cref="MassConcentration.FromPicogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        public static MassConcentration PicogramsPerMilliliter<T>(this T value) =>
+             MassConcentration.FromPicogramsPerMilliliter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerCubicFoot
+
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static MassConcentration PoundsPerCubicFoot<T>(this T value) =>
+             MassConcentration.FromPoundsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerCubicInch
+
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static MassConcentration PoundsPerCubicInch<T>(this T value) =>
+             MassConcentration.FromPoundsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerImperialGallon
+
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerImperialGallon(UnitsNet.QuantityValue)" />
+        public static MassConcentration PoundsPerImperialGallon<T>(this T value) =>
+             MassConcentration.FromPoundsPerImperialGallon(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerUSGallon
+
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerUSGallon(UnitsNet.QuantityValue)" />
+        public static MassConcentration PoundsPerUSGallon<T>(this T value) =>
+             MassConcentration.FromPoundsPerUSGallon(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SlugPerCubicFoot
+
+        /// <inheritdoc cref="MassConcentration.FromSlugsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static MassConcentration SlugsPerCubicFoot<T>(this T value) =>
+             MassConcentration.FromSlugsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonnePerCubicCentimeter
+
+        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        public static MassConcentration TonnesPerCubicCentimeter<T>(this T value) =>
+             MassConcentration.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonnePerCubicMeter
+
+        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static MassConcentration TonnesPerCubicMeter<T>(this T value) =>
+             MassConcentration.FromTonnesPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonnePerCubicMillimeter
+
+        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        public static MassConcentration TonnesPerCubicMillimeter<T>(this T value) =>
+             MassConcentration.FromTonnesPerCubicMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMassExtensions.g.cs
new file mode 100644
index 0000000000..4fe792ca1f
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMassExtensions.g.cs
@@ -0,0 +1,231 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMass
+{
+    /// <summary>
+    /// A number to Mass Extensions
+    /// </summary>
+    public static class NumberToMassExtensions
+    {
+
+        #region Centigram
+
+        /// <inheritdoc cref="Mass.FromCentigrams(UnitsNet.QuantityValue)" />
+        public static Mass Centigrams<T>(this T value) =>
+             Mass.FromCentigrams(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Decagram
+
+        /// <inheritdoc cref="Mass.FromDecagrams(UnitsNet.QuantityValue)" />
+        public static Mass Decagrams<T>(this T value) =>
+             Mass.FromDecagrams(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Decigram
+
+        /// <inheritdoc cref="Mass.FromDecigrams(UnitsNet.QuantityValue)" />
+        public static Mass Decigrams<T>(this T value) =>
+             Mass.FromDecigrams(Convert.ToDouble(value));
+
+        #endregion
+
+        #region EarthMass
+
+        /// <inheritdoc cref="Mass.FromEarthMasses(UnitsNet.QuantityValue)" />
+        public static Mass EarthMasses<T>(this T value) =>
+             Mass.FromEarthMasses(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Grain
+
+        /// <inheritdoc cref="Mass.FromGrains(UnitsNet.QuantityValue)" />
+        public static Mass Grains<T>(this T value) =>
+             Mass.FromGrains(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Gram
+
+        /// <inheritdoc cref="Mass.FromGrams(UnitsNet.QuantityValue)" />
+        public static Mass Grams<T>(this T value) =>
+             Mass.FromGrams(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Hectogram
+
+        /// <inheritdoc cref="Mass.FromHectograms(UnitsNet.QuantityValue)" />
+        public static Mass Hectograms<T>(this T value) =>
+             Mass.FromHectograms(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilogram
+
+        /// <inheritdoc cref="Mass.FromKilograms(UnitsNet.QuantityValue)" />
+        public static Mass Kilograms<T>(this T value) =>
+             Mass.FromKilograms(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilopound
+
+        /// <inheritdoc cref="Mass.FromKilopounds(UnitsNet.QuantityValue)" />
+        public static Mass Kilopounds<T>(this T value) =>
+             Mass.FromKilopounds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilotonne
+
+        /// <inheritdoc cref="Mass.FromKilotonnes(UnitsNet.QuantityValue)" />
+        public static Mass Kilotonnes<T>(this T value) =>
+             Mass.FromKilotonnes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region LongHundredweight
+
+        /// <inheritdoc cref="Mass.FromLongHundredweight(UnitsNet.QuantityValue)" />
+        public static Mass LongHundredweight<T>(this T value) =>
+             Mass.FromLongHundredweight(Convert.ToDouble(value));
+
+        #endregion
+
+        #region LongTon
+
+        /// <inheritdoc cref="Mass.FromLongTons(UnitsNet.QuantityValue)" />
+        public static Mass LongTons<T>(this T value) =>
+             Mass.FromLongTons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megapound
+
+        /// <inheritdoc cref="Mass.FromMegapounds(UnitsNet.QuantityValue)" />
+        public static Mass Megapounds<T>(this T value) =>
+             Mass.FromMegapounds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megatonne
+
+        /// <inheritdoc cref="Mass.FromMegatonnes(UnitsNet.QuantityValue)" />
+        public static Mass Megatonnes<T>(this T value) =>
+             Mass.FromMegatonnes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microgram
+
+        /// <inheritdoc cref="Mass.FromMicrograms(UnitsNet.QuantityValue)" />
+        public static Mass Micrograms<T>(this T value) =>
+             Mass.FromMicrograms(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Milligram
+
+        /// <inheritdoc cref="Mass.FromMilligrams(UnitsNet.QuantityValue)" />
+        public static Mass Milligrams<T>(this T value) =>
+             Mass.FromMilligrams(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanogram
+
+        /// <inheritdoc cref="Mass.FromNanograms(UnitsNet.QuantityValue)" />
+        public static Mass Nanograms<T>(this T value) =>
+             Mass.FromNanograms(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Ounce
+
+        /// <inheritdoc cref="Mass.FromOunces(UnitsNet.QuantityValue)" />
+        public static Mass Ounces<T>(this T value) =>
+             Mass.FromOunces(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Pound
+
+        /// <inheritdoc cref="Mass.FromPounds(UnitsNet.QuantityValue)" />
+        public static Mass Pounds<T>(this T value) =>
+             Mass.FromPounds(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ShortHundredweight
+
+        /// <inheritdoc cref="Mass.FromShortHundredweight(UnitsNet.QuantityValue)" />
+        public static Mass ShortHundredweight<T>(this T value) =>
+             Mass.FromShortHundredweight(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ShortTon
+
+        /// <inheritdoc cref="Mass.FromShortTons(UnitsNet.QuantityValue)" />
+        public static Mass ShortTons<T>(this T value) =>
+             Mass.FromShortTons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Slug
+
+        /// <inheritdoc cref="Mass.FromSlugs(UnitsNet.QuantityValue)" />
+        public static Mass Slugs<T>(this T value) =>
+             Mass.FromSlugs(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SolarMass
+
+        /// <inheritdoc cref="Mass.FromSolarMasses(UnitsNet.QuantityValue)" />
+        public static Mass SolarMasses<T>(this T value) =>
+             Mass.FromSolarMasses(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Stone
+
+        /// <inheritdoc cref="Mass.FromStone(UnitsNet.QuantityValue)" />
+        public static Mass Stone<T>(this T value) =>
+             Mass.FromStone(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Tonne
+
+        /// <inheritdoc cref="Mass.FromTonnes(UnitsNet.QuantityValue)" />
+        public static Mass Tonnes<T>(this T value) =>
+             Mass.FromTonnes(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassFlowExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMassFlowExtensions.g.cs
new file mode 100644
index 0000000000..a3fe413a95
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMassFlowExtensions.g.cs
@@ -0,0 +1,295 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMassFlow
+{
+    /// <summary>
+    /// A number to MassFlow Extensions
+    /// </summary>
+    public static class NumberToMassFlowExtensions
+    {
+
+        #region CentigramPerDay
+
+        /// <inheritdoc cref="MassFlow.FromCentigramsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow CentigramsPerDay<T>(this T value) =>
+             MassFlow.FromCentigramsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentigramPerSecond
+
+        /// <inheritdoc cref="MassFlow.FromCentigramsPerSecond(UnitsNet.QuantityValue)" />
+        public static MassFlow CentigramsPerSecond<T>(this T value) =>
+             MassFlow.FromCentigramsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecagramPerDay
+
+        /// <inheritdoc cref="MassFlow.FromDecagramsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow DecagramsPerDay<T>(this T value) =>
+             MassFlow.FromDecagramsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecagramPerSecond
+
+        /// <inheritdoc cref="MassFlow.FromDecagramsPerSecond(UnitsNet.QuantityValue)" />
+        public static MassFlow DecagramsPerSecond<T>(this T value) =>
+             MassFlow.FromDecagramsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecigramPerDay
+
+        /// <inheritdoc cref="MassFlow.FromDecigramsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow DecigramsPerDay<T>(this T value) =>
+             MassFlow.FromDecigramsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecigramPerSecond
+
+        /// <inheritdoc cref="MassFlow.FromDecigramsPerSecond(UnitsNet.QuantityValue)" />
+        public static MassFlow DecigramsPerSecond<T>(this T value) =>
+             MassFlow.FromDecigramsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerDay
+
+        /// <inheritdoc cref="MassFlow.FromGramsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow GramsPerDay<T>(this T value) =>
+             MassFlow.FromGramsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerHour
+
+        /// <inheritdoc cref="MassFlow.FromGramsPerHour(UnitsNet.QuantityValue)" />
+        public static MassFlow GramsPerHour<T>(this T value) =>
+             MassFlow.FromGramsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerSecond
+
+        /// <inheritdoc cref="MassFlow.FromGramsPerSecond(UnitsNet.QuantityValue)" />
+        public static MassFlow GramsPerSecond<T>(this T value) =>
+             MassFlow.FromGramsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region HectogramPerDay
+
+        /// <inheritdoc cref="MassFlow.FromHectogramsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow HectogramsPerDay<T>(this T value) =>
+             MassFlow.FromHectogramsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region HectogramPerSecond
+
+        /// <inheritdoc cref="MassFlow.FromHectogramsPerSecond(UnitsNet.QuantityValue)" />
+        public static MassFlow HectogramsPerSecond<T>(this T value) =>
+             MassFlow.FromHectogramsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerDay
+
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow KilogramsPerDay<T>(this T value) =>
+             MassFlow.FromKilogramsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerHour
+
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerHour(UnitsNet.QuantityValue)" />
+        public static MassFlow KilogramsPerHour<T>(this T value) =>
+             MassFlow.FromKilogramsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerMinute
+
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerMinute(UnitsNet.QuantityValue)" />
+        public static MassFlow KilogramsPerMinute<T>(this T value) =>
+             MassFlow.FromKilogramsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerSecond
+
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerSecond(UnitsNet.QuantityValue)" />
+        public static MassFlow KilogramsPerSecond<T>(this T value) =>
+             MassFlow.FromKilogramsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegagramPerDay
+
+        /// <inheritdoc cref="MassFlow.FromMegagramsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow MegagramsPerDay<T>(this T value) =>
+             MassFlow.FromMegagramsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegapoundPerDay
+
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow MegapoundsPerDay<T>(this T value) =>
+             MassFlow.FromMegapoundsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegapoundPerHour
+
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerHour(UnitsNet.QuantityValue)" />
+        public static MassFlow MegapoundsPerHour<T>(this T value) =>
+             MassFlow.FromMegapoundsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegapoundPerMinute
+
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerMinute(UnitsNet.QuantityValue)" />
+        public static MassFlow MegapoundsPerMinute<T>(this T value) =>
+             MassFlow.FromMegapoundsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegapoundPerSecond
+
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerSecond(UnitsNet.QuantityValue)" />
+        public static MassFlow MegapoundsPerSecond<T>(this T value) =>
+             MassFlow.FromMegapoundsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerDay
+
+        /// <inheritdoc cref="MassFlow.FromMicrogramsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow MicrogramsPerDay<T>(this T value) =>
+             MassFlow.FromMicrogramsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerSecond
+
+        /// <inheritdoc cref="MassFlow.FromMicrogramsPerSecond(UnitsNet.QuantityValue)" />
+        public static MassFlow MicrogramsPerSecond<T>(this T value) =>
+             MassFlow.FromMicrogramsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerDay
+
+        /// <inheritdoc cref="MassFlow.FromMilligramsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow MilligramsPerDay<T>(this T value) =>
+             MassFlow.FromMilligramsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerSecond
+
+        /// <inheritdoc cref="MassFlow.FromMilligramsPerSecond(UnitsNet.QuantityValue)" />
+        public static MassFlow MilligramsPerSecond<T>(this T value) =>
+             MassFlow.FromMilligramsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanogramPerDay
+
+        /// <inheritdoc cref="MassFlow.FromNanogramsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow NanogramsPerDay<T>(this T value) =>
+             MassFlow.FromNanogramsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanogramPerSecond
+
+        /// <inheritdoc cref="MassFlow.FromNanogramsPerSecond(UnitsNet.QuantityValue)" />
+        public static MassFlow NanogramsPerSecond<T>(this T value) =>
+             MassFlow.FromNanogramsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerDay
+
+        /// <inheritdoc cref="MassFlow.FromPoundsPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow PoundsPerDay<T>(this T value) =>
+             MassFlow.FromPoundsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerHour
+
+        /// <inheritdoc cref="MassFlow.FromPoundsPerHour(UnitsNet.QuantityValue)" />
+        public static MassFlow PoundsPerHour<T>(this T value) =>
+             MassFlow.FromPoundsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerMinute
+
+        /// <inheritdoc cref="MassFlow.FromPoundsPerMinute(UnitsNet.QuantityValue)" />
+        public static MassFlow PoundsPerMinute<T>(this T value) =>
+             MassFlow.FromPoundsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerSecond
+
+        /// <inheritdoc cref="MassFlow.FromPoundsPerSecond(UnitsNet.QuantityValue)" />
+        public static MassFlow PoundsPerSecond<T>(this T value) =>
+             MassFlow.FromPoundsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ShortTonPerHour
+
+        /// <inheritdoc cref="MassFlow.FromShortTonsPerHour(UnitsNet.QuantityValue)" />
+        public static MassFlow ShortTonsPerHour<T>(this T value) =>
+             MassFlow.FromShortTonsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonnePerDay
+
+        /// <inheritdoc cref="MassFlow.FromTonnesPerDay(UnitsNet.QuantityValue)" />
+        public static MassFlow TonnesPerDay<T>(this T value) =>
+             MassFlow.FromTonnesPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonnePerHour
+
+        /// <inheritdoc cref="MassFlow.FromTonnesPerHour(UnitsNet.QuantityValue)" />
+        public static MassFlow TonnesPerHour<T>(this T value) =>
+             MassFlow.FromTonnesPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassFluxExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMassFluxExtensions.g.cs
new file mode 100644
index 0000000000..96a1713ab6
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMassFluxExtensions.g.cs
@@ -0,0 +1,47 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMassFlux
+{
+    /// <summary>
+    /// A number to MassFlux Extensions
+    /// </summary>
+    public static class NumberToMassFluxExtensions
+    {
+
+        #region GramPerSecondPerSquareMeter
+
+        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static MassFlux GramsPerSecondPerSquareMeter<T>(this T value) =>
+             MassFlux.FromGramsPerSecondPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerSecondPerSquareMeter
+
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static MassFlux KilogramsPerSecondPerSquareMeter<T>(this T value) =>
+             MassFlux.FromKilogramsPerSecondPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassFractionExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMassFractionExtensions.g.cs
new file mode 100644
index 0000000000..1d84b87eac
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMassFractionExtensions.g.cs
@@ -0,0 +1,223 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMassFraction
+{
+    /// <summary>
+    /// A number to MassFraction Extensions
+    /// </summary>
+    public static class NumberToMassFractionExtensions
+    {
+
+        #region CentigramPerGram
+
+        /// <inheritdoc cref="MassFraction.FromCentigramsPerGram(UnitsNet.QuantityValue)" />
+        public static MassFraction CentigramsPerGram<T>(this T value) =>
+             MassFraction.FromCentigramsPerGram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentigramPerKilogram
+
+        /// <inheritdoc cref="MassFraction.FromCentigramsPerKilogram(UnitsNet.QuantityValue)" />
+        public static MassFraction CentigramsPerKilogram<T>(this T value) =>
+             MassFraction.FromCentigramsPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecagramPerGram
+
+        /// <inheritdoc cref="MassFraction.FromDecagramsPerGram(UnitsNet.QuantityValue)" />
+        public static MassFraction DecagramsPerGram<T>(this T value) =>
+             MassFraction.FromDecagramsPerGram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecagramPerKilogram
+
+        /// <inheritdoc cref="MassFraction.FromDecagramsPerKilogram(UnitsNet.QuantityValue)" />
+        public static MassFraction DecagramsPerKilogram<T>(this T value) =>
+             MassFraction.FromDecagramsPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecigramPerGram
+
+        /// <inheritdoc cref="MassFraction.FromDecigramsPerGram(UnitsNet.QuantityValue)" />
+        public static MassFraction DecigramsPerGram<T>(this T value) =>
+             MassFraction.FromDecigramsPerGram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecigramPerKilogram
+
+        /// <inheritdoc cref="MassFraction.FromDecigramsPerKilogram(UnitsNet.QuantityValue)" />
+        public static MassFraction DecigramsPerKilogram<T>(this T value) =>
+             MassFraction.FromDecigramsPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecimalFraction
+
+        /// <inheritdoc cref="MassFraction.FromDecimalFractions(UnitsNet.QuantityValue)" />
+        public static MassFraction DecimalFractions<T>(this T value) =>
+             MassFraction.FromDecimalFractions(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerGram
+
+        /// <inheritdoc cref="MassFraction.FromGramsPerGram(UnitsNet.QuantityValue)" />
+        public static MassFraction GramsPerGram<T>(this T value) =>
+             MassFraction.FromGramsPerGram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerKilogram
+
+        /// <inheritdoc cref="MassFraction.FromGramsPerKilogram(UnitsNet.QuantityValue)" />
+        public static MassFraction GramsPerKilogram<T>(this T value) =>
+             MassFraction.FromGramsPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region HectogramPerGram
+
+        /// <inheritdoc cref="MassFraction.FromHectogramsPerGram(UnitsNet.QuantityValue)" />
+        public static MassFraction HectogramsPerGram<T>(this T value) =>
+             MassFraction.FromHectogramsPerGram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region HectogramPerKilogram
+
+        /// <inheritdoc cref="MassFraction.FromHectogramsPerKilogram(UnitsNet.QuantityValue)" />
+        public static MassFraction HectogramsPerKilogram<T>(this T value) =>
+             MassFraction.FromHectogramsPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerGram
+
+        /// <inheritdoc cref="MassFraction.FromKilogramsPerGram(UnitsNet.QuantityValue)" />
+        public static MassFraction KilogramsPerGram<T>(this T value) =>
+             MassFraction.FromKilogramsPerGram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerKilogram
+
+        /// <inheritdoc cref="MassFraction.FromKilogramsPerKilogram(UnitsNet.QuantityValue)" />
+        public static MassFraction KilogramsPerKilogram<T>(this T value) =>
+             MassFraction.FromKilogramsPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerGram
+
+        /// <inheritdoc cref="MassFraction.FromMicrogramsPerGram(UnitsNet.QuantityValue)" />
+        public static MassFraction MicrogramsPerGram<T>(this T value) =>
+             MassFraction.FromMicrogramsPerGram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerKilogram
+
+        /// <inheritdoc cref="MassFraction.FromMicrogramsPerKilogram(UnitsNet.QuantityValue)" />
+        public static MassFraction MicrogramsPerKilogram<T>(this T value) =>
+             MassFraction.FromMicrogramsPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerGram
+
+        /// <inheritdoc cref="MassFraction.FromMilligramsPerGram(UnitsNet.QuantityValue)" />
+        public static MassFraction MilligramsPerGram<T>(this T value) =>
+             MassFraction.FromMilligramsPerGram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerKilogram
+
+        /// <inheritdoc cref="MassFraction.FromMilligramsPerKilogram(UnitsNet.QuantityValue)" />
+        public static MassFraction MilligramsPerKilogram<T>(this T value) =>
+             MassFraction.FromMilligramsPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanogramPerGram
+
+        /// <inheritdoc cref="MassFraction.FromNanogramsPerGram(UnitsNet.QuantityValue)" />
+        public static MassFraction NanogramsPerGram<T>(this T value) =>
+             MassFraction.FromNanogramsPerGram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanogramPerKilogram
+
+        /// <inheritdoc cref="MassFraction.FromNanogramsPerKilogram(UnitsNet.QuantityValue)" />
+        public static MassFraction NanogramsPerKilogram<T>(this T value) =>
+             MassFraction.FromNanogramsPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerBillion
+
+        /// <inheritdoc cref="MassFraction.FromPartsPerBillion(UnitsNet.QuantityValue)" />
+        public static MassFraction PartsPerBillion<T>(this T value) =>
+             MassFraction.FromPartsPerBillion(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerMillion
+
+        /// <inheritdoc cref="MassFraction.FromPartsPerMillion(UnitsNet.QuantityValue)" />
+        public static MassFraction PartsPerMillion<T>(this T value) =>
+             MassFraction.FromPartsPerMillion(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerThousand
+
+        /// <inheritdoc cref="MassFraction.FromPartsPerThousand(UnitsNet.QuantityValue)" />
+        public static MassFraction PartsPerThousand<T>(this T value) =>
+             MassFraction.FromPartsPerThousand(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerTrillion
+
+        /// <inheritdoc cref="MassFraction.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
+        public static MassFraction PartsPerTrillion<T>(this T value) =>
+             MassFraction.FromPartsPerTrillion(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Percent
+
+        /// <inheritdoc cref="MassFraction.FromPercent(UnitsNet.QuantityValue)" />
+        public static MassFraction Percent<T>(this T value) =>
+             MassFraction.FromPercent(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassMomentOfInertiaExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMassMomentOfInertiaExtensions.g.cs
new file mode 100644
index 0000000000..9f1d8a614c
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMassMomentOfInertiaExtensions.g.cs
@@ -0,0 +1,255 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMassMomentOfInertia
+{
+    /// <summary>
+    /// A number to MassMomentOfInertia Extensions
+    /// </summary>
+    public static class NumberToMassMomentOfInertiaExtensions
+    {
+
+        #region GramSquareCentimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareCentimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia GramSquareCentimeters<T>(this T value) =>
+             MassMomentOfInertia.FromGramSquareCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramSquareDecimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareDecimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia GramSquareDecimeters<T>(this T value) =>
+             MassMomentOfInertia.FromGramSquareDecimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramSquareMeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia GramSquareMeters<T>(this T value) =>
+             MassMomentOfInertia.FromGramSquareMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramSquareMillimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMillimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia GramSquareMillimeters<T>(this T value) =>
+             MassMomentOfInertia.FromGramSquareMillimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramSquareCentimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareCentimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia KilogramSquareCentimeters<T>(this T value) =>
+             MassMomentOfInertia.FromKilogramSquareCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramSquareDecimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareDecimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia KilogramSquareDecimeters<T>(this T value) =>
+             MassMomentOfInertia.FromKilogramSquareDecimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramSquareMeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia KilogramSquareMeters<T>(this T value) =>
+             MassMomentOfInertia.FromKilogramSquareMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramSquareMillimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMillimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia KilogramSquareMillimeters<T>(this T value) =>
+             MassMomentOfInertia.FromKilogramSquareMillimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilotonneSquareCentimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareCentimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia KilotonneSquareCentimeters<T>(this T value) =>
+             MassMomentOfInertia.FromKilotonneSquareCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilotonneSquareDecimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareDecimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia KilotonneSquareDecimeters<T>(this T value) =>
+             MassMomentOfInertia.FromKilotonneSquareDecimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilotonneSquareMeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia KilotonneSquareMeters<T>(this T value) =>
+             MassMomentOfInertia.FromKilotonneSquareMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilotonneSquareMilimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMilimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia KilotonneSquareMilimeters<T>(this T value) =>
+             MassMomentOfInertia.FromKilotonneSquareMilimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegatonneSquareCentimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareCentimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia MegatonneSquareCentimeters<T>(this T value) =>
+             MassMomentOfInertia.FromMegatonneSquareCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegatonneSquareDecimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareDecimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia MegatonneSquareDecimeters<T>(this T value) =>
+             MassMomentOfInertia.FromMegatonneSquareDecimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegatonneSquareMeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia MegatonneSquareMeters<T>(this T value) =>
+             MassMomentOfInertia.FromMegatonneSquareMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegatonneSquareMilimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMilimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia MegatonneSquareMilimeters<T>(this T value) =>
+             MassMomentOfInertia.FromMegatonneSquareMilimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramSquareCentimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareCentimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia MilligramSquareCentimeters<T>(this T value) =>
+             MassMomentOfInertia.FromMilligramSquareCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramSquareDecimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareDecimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia MilligramSquareDecimeters<T>(this T value) =>
+             MassMomentOfInertia.FromMilligramSquareDecimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramSquareMeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia MilligramSquareMeters<T>(this T value) =>
+             MassMomentOfInertia.FromMilligramSquareMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramSquareMillimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMillimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia MilligramSquareMillimeters<T>(this T value) =>
+             MassMomentOfInertia.FromMilligramSquareMillimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundSquareFoot
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareFeet(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia PoundSquareFeet<T>(this T value) =>
+             MassMomentOfInertia.FromPoundSquareFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundSquareInch
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareInches(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia PoundSquareInches<T>(this T value) =>
+             MassMomentOfInertia.FromPoundSquareInches(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SlugSquareFoot
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareFeet(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia SlugSquareFeet<T>(this T value) =>
+             MassMomentOfInertia.FromSlugSquareFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SlugSquareInch
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareInches(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia SlugSquareInches<T>(this T value) =>
+             MassMomentOfInertia.FromSlugSquareInches(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneSquareCentimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareCentimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia TonneSquareCentimeters<T>(this T value) =>
+             MassMomentOfInertia.FromTonneSquareCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneSquareDecimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareDecimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia TonneSquareDecimeters<T>(this T value) =>
+             MassMomentOfInertia.FromTonneSquareDecimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneSquareMeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia TonneSquareMeters<T>(this T value) =>
+             MassMomentOfInertia.FromTonneSquareMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneSquareMilimeter
+
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMilimeters(UnitsNet.QuantityValue)" />
+        public static MassMomentOfInertia TonneSquareMilimeters<T>(this T value) =>
+             MassMomentOfInertia.FromTonneSquareMilimeters(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMolarEnergyExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMolarEnergyExtensions.g.cs
new file mode 100644
index 0000000000..5b23d135ce
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMolarEnergyExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMolarEnergy
+{
+    /// <summary>
+    /// A number to MolarEnergy Extensions
+    /// </summary>
+    public static class NumberToMolarEnergyExtensions
+    {
+
+        #region JoulePerMole
+
+        /// <inheritdoc cref="MolarEnergy.FromJoulesPerMole(UnitsNet.QuantityValue)" />
+        public static MolarEnergy JoulesPerMole<T>(this T value) =>
+             MolarEnergy.FromJoulesPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilojoulePerMole
+
+        /// <inheritdoc cref="MolarEnergy.FromKilojoulesPerMole(UnitsNet.QuantityValue)" />
+        public static MolarEnergy KilojoulesPerMole<T>(this T value) =>
+             MolarEnergy.FromKilojoulesPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegajoulePerMole
+
+        /// <inheritdoc cref="MolarEnergy.FromMegajoulesPerMole(UnitsNet.QuantityValue)" />
+        public static MolarEnergy MegajoulesPerMole<T>(this T value) =>
+             MolarEnergy.FromMegajoulesPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMolarEntropyExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMolarEntropyExtensions.g.cs
new file mode 100644
index 0000000000..2af90d96ee
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMolarEntropyExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMolarEntropy
+{
+    /// <summary>
+    /// A number to MolarEntropy Extensions
+    /// </summary>
+    public static class NumberToMolarEntropyExtensions
+    {
+
+        #region JoulePerMoleKelvin
+
+        /// <inheritdoc cref="MolarEntropy.FromJoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
+        public static MolarEntropy JoulesPerMoleKelvin<T>(this T value) =>
+             MolarEntropy.FromJoulesPerMoleKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilojoulePerMoleKelvin
+
+        /// <inheritdoc cref="MolarEntropy.FromKilojoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
+        public static MolarEntropy KilojoulesPerMoleKelvin<T>(this T value) =>
+             MolarEntropy.FromKilojoulesPerMoleKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegajoulePerMoleKelvin
+
+        /// <inheritdoc cref="MolarEntropy.FromMegajoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
+        public static MolarEntropy MegajoulesPerMoleKelvin<T>(this T value) =>
+             MolarEntropy.FromMegajoulesPerMoleKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMolarMassExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMolarMassExtensions.g.cs
new file mode 100644
index 0000000000..0ff8fa5865
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMolarMassExtensions.g.cs
@@ -0,0 +1,127 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMolarMass
+{
+    /// <summary>
+    /// A number to MolarMass Extensions
+    /// </summary>
+    public static class NumberToMolarMassExtensions
+    {
+
+        #region CentigramPerMole
+
+        /// <inheritdoc cref="MolarMass.FromCentigramsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass CentigramsPerMole<T>(this T value) =>
+             MolarMass.FromCentigramsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecagramPerMole
+
+        /// <inheritdoc cref="MolarMass.FromDecagramsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass DecagramsPerMole<T>(this T value) =>
+             MolarMass.FromDecagramsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecigramPerMole
+
+        /// <inheritdoc cref="MolarMass.FromDecigramsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass DecigramsPerMole<T>(this T value) =>
+             MolarMass.FromDecigramsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GramPerMole
+
+        /// <inheritdoc cref="MolarMass.FromGramsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass GramsPerMole<T>(this T value) =>
+             MolarMass.FromGramsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region HectogramPerMole
+
+        /// <inheritdoc cref="MolarMass.FromHectogramsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass HectogramsPerMole<T>(this T value) =>
+             MolarMass.FromHectogramsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramPerMole
+
+        /// <inheritdoc cref="MolarMass.FromKilogramsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass KilogramsPerMole<T>(this T value) =>
+             MolarMass.FromKilogramsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundPerMole
+
+        /// <inheritdoc cref="MolarMass.FromKilopoundsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass KilopoundsPerMole<T>(this T value) =>
+             MolarMass.FromKilopoundsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegapoundPerMole
+
+        /// <inheritdoc cref="MolarMass.FromMegapoundsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass MegapoundsPerMole<T>(this T value) =>
+             MolarMass.FromMegapoundsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrogramPerMole
+
+        /// <inheritdoc cref="MolarMass.FromMicrogramsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass MicrogramsPerMole<T>(this T value) =>
+             MolarMass.FromMicrogramsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilligramPerMole
+
+        /// <inheritdoc cref="MolarMass.FromMilligramsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass MilligramsPerMole<T>(this T value) =>
+             MolarMass.FromMilligramsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanogramPerMole
+
+        /// <inheritdoc cref="MolarMass.FromNanogramsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass NanogramsPerMole<T>(this T value) =>
+             MolarMass.FromNanogramsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerMole
+
+        /// <inheritdoc cref="MolarMass.FromPoundsPerMole(UnitsNet.QuantityValue)" />
+        public static MolarMass PoundsPerMole<T>(this T value) =>
+             MolarMass.FromPoundsPerMole(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMolarityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToMolarityExtensions.g.cs
new file mode 100644
index 0000000000..7a6355feb9
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToMolarityExtensions.g.cs
@@ -0,0 +1,95 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToMolarity
+{
+    /// <summary>
+    /// A number to Molarity Extensions
+    /// </summary>
+    public static class NumberToMolarityExtensions
+    {
+
+        #region CentimolesPerLiter
+
+        /// <inheritdoc cref="Molarity.FromCentimolesPerLiter(UnitsNet.QuantityValue)" />
+        public static Molarity CentimolesPerLiter<T>(this T value) =>
+             Molarity.FromCentimolesPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecimolesPerLiter
+
+        /// <inheritdoc cref="Molarity.FromDecimolesPerLiter(UnitsNet.QuantityValue)" />
+        public static Molarity DecimolesPerLiter<T>(this T value) =>
+             Molarity.FromDecimolesPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicromolesPerLiter
+
+        /// <inheritdoc cref="Molarity.FromMicromolesPerLiter(UnitsNet.QuantityValue)" />
+        public static Molarity MicromolesPerLiter<T>(this T value) =>
+             Molarity.FromMicromolesPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillimolesPerLiter
+
+        /// <inheritdoc cref="Molarity.FromMillimolesPerLiter(UnitsNet.QuantityValue)" />
+        public static Molarity MillimolesPerLiter<T>(this T value) =>
+             Molarity.FromMillimolesPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MolesPerCubicMeter
+
+        /// <inheritdoc cref="Molarity.FromMolesPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static Molarity MolesPerCubicMeter<T>(this T value) =>
+             Molarity.FromMolesPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MolesPerLiter
+
+        /// <inheritdoc cref="Molarity.FromMolesPerLiter(UnitsNet.QuantityValue)" />
+        public static Molarity MolesPerLiter<T>(this T value) =>
+             Molarity.FromMolesPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanomolesPerLiter
+
+        /// <inheritdoc cref="Molarity.FromNanomolesPerLiter(UnitsNet.QuantityValue)" />
+        public static Molarity NanomolesPerLiter<T>(this T value) =>
+             Molarity.FromNanomolesPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicomolesPerLiter
+
+        /// <inheritdoc cref="Molarity.FromPicomolesPerLiter(UnitsNet.QuantityValue)" />
+        public static Molarity PicomolesPerLiter<T>(this T value) =>
+             Molarity.FromPicomolesPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPermeabilityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToPermeabilityExtensions.g.cs
new file mode 100644
index 0000000000..70a3216973
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToPermeabilityExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToPermeability
+{
+    /// <summary>
+    /// A number to Permeability Extensions
+    /// </summary>
+    public static class NumberToPermeabilityExtensions
+    {
+
+        #region HenryPerMeter
+
+        /// <inheritdoc cref="Permeability.FromHenriesPerMeter(UnitsNet.QuantityValue)" />
+        public static Permeability HenriesPerMeter<T>(this T value) =>
+             Permeability.FromHenriesPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPermittivityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToPermittivityExtensions.g.cs
new file mode 100644
index 0000000000..2ef7046f62
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToPermittivityExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToPermittivity
+{
+    /// <summary>
+    /// A number to Permittivity Extensions
+    /// </summary>
+    public static class NumberToPermittivityExtensions
+    {
+
+        #region FaradPerMeter
+
+        /// <inheritdoc cref="Permittivity.FromFaradsPerMeter(UnitsNet.QuantityValue)" />
+        public static Permittivity FaradsPerMeter<T>(this T value) =>
+             Permittivity.FromFaradsPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPowerDensityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToPowerDensityExtensions.g.cs
new file mode 100644
index 0000000000..0f6fdaa417
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToPowerDensityExtensions.g.cs
@@ -0,0 +1,383 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToPowerDensity
+{
+    /// <summary>
+    /// A number to PowerDensity Extensions
+    /// </summary>
+    public static class NumberToPowerDensityExtensions
+    {
+
+        #region DecawattPerCubicFoot
+
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static PowerDensity DecawattsPerCubicFoot<T>(this T value) =>
+             PowerDensity.FromDecawattsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecawattPerCubicInch
+
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static PowerDensity DecawattsPerCubicInch<T>(this T value) =>
+             PowerDensity.FromDecawattsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecawattPerCubicMeter
+
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static PowerDensity DecawattsPerCubicMeter<T>(this T value) =>
+             PowerDensity.FromDecawattsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecawattPerLiter
+
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerLiter(UnitsNet.QuantityValue)" />
+        public static PowerDensity DecawattsPerLiter<T>(this T value) =>
+             PowerDensity.FromDecawattsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DeciwattPerCubicFoot
+
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static PowerDensity DeciwattsPerCubicFoot<T>(this T value) =>
+             PowerDensity.FromDeciwattsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DeciwattPerCubicInch
+
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static PowerDensity DeciwattsPerCubicInch<T>(this T value) =>
+             PowerDensity.FromDeciwattsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DeciwattPerCubicMeter
+
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static PowerDensity DeciwattsPerCubicMeter<T>(this T value) =>
+             PowerDensity.FromDeciwattsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DeciwattPerLiter
+
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerLiter(UnitsNet.QuantityValue)" />
+        public static PowerDensity DeciwattsPerLiter<T>(this T value) =>
+             PowerDensity.FromDeciwattsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GigawattPerCubicFoot
+
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static PowerDensity GigawattsPerCubicFoot<T>(this T value) =>
+             PowerDensity.FromGigawattsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GigawattPerCubicInch
+
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static PowerDensity GigawattsPerCubicInch<T>(this T value) =>
+             PowerDensity.FromGigawattsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GigawattPerCubicMeter
+
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static PowerDensity GigawattsPerCubicMeter<T>(this T value) =>
+             PowerDensity.FromGigawattsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GigawattPerLiter
+
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerLiter(UnitsNet.QuantityValue)" />
+        public static PowerDensity GigawattsPerLiter<T>(this T value) =>
+             PowerDensity.FromGigawattsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilowattPerCubicFoot
+
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static PowerDensity KilowattsPerCubicFoot<T>(this T value) =>
+             PowerDensity.FromKilowattsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilowattPerCubicInch
+
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static PowerDensity KilowattsPerCubicInch<T>(this T value) =>
+             PowerDensity.FromKilowattsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilowattPerCubicMeter
+
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static PowerDensity KilowattsPerCubicMeter<T>(this T value) =>
+             PowerDensity.FromKilowattsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilowattPerLiter
+
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerLiter(UnitsNet.QuantityValue)" />
+        public static PowerDensity KilowattsPerLiter<T>(this T value) =>
+             PowerDensity.FromKilowattsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegawattPerCubicFoot
+
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static PowerDensity MegawattsPerCubicFoot<T>(this T value) =>
+             PowerDensity.FromMegawattsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegawattPerCubicInch
+
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static PowerDensity MegawattsPerCubicInch<T>(this T value) =>
+             PowerDensity.FromMegawattsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegawattPerCubicMeter
+
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static PowerDensity MegawattsPerCubicMeter<T>(this T value) =>
+             PowerDensity.FromMegawattsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegawattPerLiter
+
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerLiter(UnitsNet.QuantityValue)" />
+        public static PowerDensity MegawattsPerLiter<T>(this T value) =>
+             PowerDensity.FromMegawattsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrowattPerCubicFoot
+
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static PowerDensity MicrowattsPerCubicFoot<T>(this T value) =>
+             PowerDensity.FromMicrowattsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrowattPerCubicInch
+
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static PowerDensity MicrowattsPerCubicInch<T>(this T value) =>
+             PowerDensity.FromMicrowattsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrowattPerCubicMeter
+
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static PowerDensity MicrowattsPerCubicMeter<T>(this T value) =>
+             PowerDensity.FromMicrowattsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrowattPerLiter
+
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerLiter(UnitsNet.QuantityValue)" />
+        public static PowerDensity MicrowattsPerLiter<T>(this T value) =>
+             PowerDensity.FromMicrowattsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliwattPerCubicFoot
+
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static PowerDensity MilliwattsPerCubicFoot<T>(this T value) =>
+             PowerDensity.FromMilliwattsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliwattPerCubicInch
+
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static PowerDensity MilliwattsPerCubicInch<T>(this T value) =>
+             PowerDensity.FromMilliwattsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliwattPerCubicMeter
+
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static PowerDensity MilliwattsPerCubicMeter<T>(this T value) =>
+             PowerDensity.FromMilliwattsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliwattPerLiter
+
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerLiter(UnitsNet.QuantityValue)" />
+        public static PowerDensity MilliwattsPerLiter<T>(this T value) =>
+             PowerDensity.FromMilliwattsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanowattPerCubicFoot
+
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static PowerDensity NanowattsPerCubicFoot<T>(this T value) =>
+             PowerDensity.FromNanowattsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanowattPerCubicInch
+
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static PowerDensity NanowattsPerCubicInch<T>(this T value) =>
+             PowerDensity.FromNanowattsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanowattPerCubicMeter
+
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static PowerDensity NanowattsPerCubicMeter<T>(this T value) =>
+             PowerDensity.FromNanowattsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanowattPerLiter
+
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerLiter(UnitsNet.QuantityValue)" />
+        public static PowerDensity NanowattsPerLiter<T>(this T value) =>
+             PowerDensity.FromNanowattsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicowattPerCubicFoot
+
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static PowerDensity PicowattsPerCubicFoot<T>(this T value) =>
+             PowerDensity.FromPicowattsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicowattPerCubicInch
+
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static PowerDensity PicowattsPerCubicInch<T>(this T value) =>
+             PowerDensity.FromPicowattsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicowattPerCubicMeter
+
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static PowerDensity PicowattsPerCubicMeter<T>(this T value) =>
+             PowerDensity.FromPicowattsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicowattPerLiter
+
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerLiter(UnitsNet.QuantityValue)" />
+        public static PowerDensity PicowattsPerLiter<T>(this T value) =>
+             PowerDensity.FromPicowattsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TerawattPerCubicFoot
+
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static PowerDensity TerawattsPerCubicFoot<T>(this T value) =>
+             PowerDensity.FromTerawattsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TerawattPerCubicInch
+
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static PowerDensity TerawattsPerCubicInch<T>(this T value) =>
+             PowerDensity.FromTerawattsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TerawattPerCubicMeter
+
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static PowerDensity TerawattsPerCubicMeter<T>(this T value) =>
+             PowerDensity.FromTerawattsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TerawattPerLiter
+
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerLiter(UnitsNet.QuantityValue)" />
+        public static PowerDensity TerawattsPerLiter<T>(this T value) =>
+             PowerDensity.FromTerawattsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerCubicFoot
+
+        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        public static PowerDensity WattsPerCubicFoot<T>(this T value) =>
+             PowerDensity.FromWattsPerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerCubicInch
+
+        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicInch(UnitsNet.QuantityValue)" />
+        public static PowerDensity WattsPerCubicInch<T>(this T value) =>
+             PowerDensity.FromWattsPerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerCubicMeter
+
+        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static PowerDensity WattsPerCubicMeter<T>(this T value) =>
+             PowerDensity.FromWattsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerLiter
+
+        /// <inheritdoc cref="PowerDensity.FromWattsPerLiter(UnitsNet.QuantityValue)" />
+        public static PowerDensity WattsPerLiter<T>(this T value) =>
+             PowerDensity.FromWattsPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPowerExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToPowerExtensions.g.cs
new file mode 100644
index 0000000000..73742b726d
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToPowerExtensions.g.cs
@@ -0,0 +1,231 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToPower
+{
+    /// <summary>
+    /// A number to Power Extensions
+    /// </summary>
+    public static class NumberToPowerExtensions
+    {
+
+        #region BoilerHorsepower
+
+        /// <inheritdoc cref="Power.FromBoilerHorsepower(UnitsNet.QuantityValue)" />
+        public static Power BoilerHorsepower<T>(this T value) =>
+             Power.FromBoilerHorsepower(Convert.ToDouble(value));
+
+        #endregion
+
+        #region BritishThermalUnitPerHour
+
+        /// <inheritdoc cref="Power.FromBritishThermalUnitsPerHour(UnitsNet.QuantityValue)" />
+        public static Power BritishThermalUnitsPerHour<T>(this T value) =>
+             Power.FromBritishThermalUnitsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Decawatt
+
+        /// <inheritdoc cref="Power.FromDecawatts(UnitsNet.QuantityValue)" />
+        public static Power Decawatts<T>(this T value) =>
+             Power.FromDecawatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Deciwatt
+
+        /// <inheritdoc cref="Power.FromDeciwatts(UnitsNet.QuantityValue)" />
+        public static Power Deciwatts<T>(this T value) =>
+             Power.FromDeciwatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ElectricalHorsepower
+
+        /// <inheritdoc cref="Power.FromElectricalHorsepower(UnitsNet.QuantityValue)" />
+        public static Power ElectricalHorsepower<T>(this T value) =>
+             Power.FromElectricalHorsepower(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Femtowatt
+
+        /// <inheritdoc cref="Power.FromFemtowatts(UnitsNet.QuantityValue)" />
+        public static Power Femtowatts<T>(this T value) =>
+             Power.FromFemtowatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region GigajoulePerHour
+
+        /// <inheritdoc cref="Power.FromGigajoulesPerHour(UnitsNet.QuantityValue)" />
+        public static Power GigajoulesPerHour<T>(this T value) =>
+             Power.FromGigajoulesPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Gigawatt
+
+        /// <inheritdoc cref="Power.FromGigawatts(UnitsNet.QuantityValue)" />
+        public static Power Gigawatts<T>(this T value) =>
+             Power.FromGigawatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region HydraulicHorsepower
+
+        /// <inheritdoc cref="Power.FromHydraulicHorsepower(UnitsNet.QuantityValue)" />
+        public static Power HydraulicHorsepower<T>(this T value) =>
+             Power.FromHydraulicHorsepower(Convert.ToDouble(value));
+
+        #endregion
+
+        #region JoulePerHour
+
+        /// <inheritdoc cref="Power.FromJoulesPerHour(UnitsNet.QuantityValue)" />
+        public static Power JoulesPerHour<T>(this T value) =>
+             Power.FromJoulesPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilobritishThermalUnitPerHour
+
+        /// <inheritdoc cref="Power.FromKilobritishThermalUnitsPerHour(UnitsNet.QuantityValue)" />
+        public static Power KilobritishThermalUnitsPerHour<T>(this T value) =>
+             Power.FromKilobritishThermalUnitsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilojoulePerHour
+
+        /// <inheritdoc cref="Power.FromKilojoulesPerHour(UnitsNet.QuantityValue)" />
+        public static Power KilojoulesPerHour<T>(this T value) =>
+             Power.FromKilojoulesPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilowatt
+
+        /// <inheritdoc cref="Power.FromKilowatts(UnitsNet.QuantityValue)" />
+        public static Power Kilowatts<T>(this T value) =>
+             Power.FromKilowatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MechanicalHorsepower
+
+        /// <inheritdoc cref="Power.FromMechanicalHorsepower(UnitsNet.QuantityValue)" />
+        public static Power MechanicalHorsepower<T>(this T value) =>
+             Power.FromMechanicalHorsepower(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegajoulePerHour
+
+        /// <inheritdoc cref="Power.FromMegajoulesPerHour(UnitsNet.QuantityValue)" />
+        public static Power MegajoulesPerHour<T>(this T value) =>
+             Power.FromMegajoulesPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megawatt
+
+        /// <inheritdoc cref="Power.FromMegawatts(UnitsNet.QuantityValue)" />
+        public static Power Megawatts<T>(this T value) =>
+             Power.FromMegawatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MetricHorsepower
+
+        /// <inheritdoc cref="Power.FromMetricHorsepower(UnitsNet.QuantityValue)" />
+        public static Power MetricHorsepower<T>(this T value) =>
+             Power.FromMetricHorsepower(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microwatt
+
+        /// <inheritdoc cref="Power.FromMicrowatts(UnitsNet.QuantityValue)" />
+        public static Power Microwatts<T>(this T value) =>
+             Power.FromMicrowatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillijoulePerHour
+
+        /// <inheritdoc cref="Power.FromMillijoulesPerHour(UnitsNet.QuantityValue)" />
+        public static Power MillijoulesPerHour<T>(this T value) =>
+             Power.FromMillijoulesPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Milliwatt
+
+        /// <inheritdoc cref="Power.FromMilliwatts(UnitsNet.QuantityValue)" />
+        public static Power Milliwatts<T>(this T value) =>
+             Power.FromMilliwatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Nanowatt
+
+        /// <inheritdoc cref="Power.FromNanowatts(UnitsNet.QuantityValue)" />
+        public static Power Nanowatts<T>(this T value) =>
+             Power.FromNanowatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Petawatt
+
+        /// <inheritdoc cref="Power.FromPetawatts(UnitsNet.QuantityValue)" />
+        public static Power Petawatts<T>(this T value) =>
+             Power.FromPetawatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Picowatt
+
+        /// <inheritdoc cref="Power.FromPicowatts(UnitsNet.QuantityValue)" />
+        public static Power Picowatts<T>(this T value) =>
+             Power.FromPicowatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Terawatt
+
+        /// <inheritdoc cref="Power.FromTerawatts(UnitsNet.QuantityValue)" />
+        public static Power Terawatts<T>(this T value) =>
+             Power.FromTerawatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Watt
+
+        /// <inheritdoc cref="Power.FromWatts(UnitsNet.QuantityValue)" />
+        public static Power Watts<T>(this T value) =>
+             Power.FromWatts(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPowerRatioExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToPowerRatioExtensions.g.cs
new file mode 100644
index 0000000000..5c3be00223
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToPowerRatioExtensions.g.cs
@@ -0,0 +1,47 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToPowerRatio
+{
+    /// <summary>
+    /// A number to PowerRatio Extensions
+    /// </summary>
+    public static class NumberToPowerRatioExtensions
+    {
+
+        #region DecibelMilliwatt
+
+        /// <inheritdoc cref="PowerRatio.FromDecibelMilliwatts(UnitsNet.QuantityValue)" />
+        public static PowerRatio DecibelMilliwatts<T>(this T value) =>
+             PowerRatio.FromDecibelMilliwatts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecibelWatt
+
+        /// <inheritdoc cref="PowerRatio.FromDecibelWatts(UnitsNet.QuantityValue)" />
+        public static PowerRatio DecibelWatts<T>(this T value) =>
+             PowerRatio.FromDecibelWatts(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPressureChangeRateExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToPressureChangeRateExtensions.g.cs
new file mode 100644
index 0000000000..08a6c59f2d
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToPressureChangeRateExtensions.g.cs
@@ -0,0 +1,87 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToPressureChangeRate
+{
+    /// <summary>
+    /// A number to PressureChangeRate Extensions
+    /// </summary>
+    public static class NumberToPressureChangeRateExtensions
+    {
+
+        #region AtmospherePerSecond
+
+        /// <inheritdoc cref="PressureChangeRate.FromAtmospheresPerSecond(UnitsNet.QuantityValue)" />
+        public static PressureChangeRate AtmospheresPerSecond<T>(this T value) =>
+             PressureChangeRate.FromAtmospheresPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopascalPerMinute
+
+        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerMinute(UnitsNet.QuantityValue)" />
+        public static PressureChangeRate KilopascalsPerMinute<T>(this T value) =>
+             PressureChangeRate.FromKilopascalsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopascalPerSecond
+
+        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerSecond(UnitsNet.QuantityValue)" />
+        public static PressureChangeRate KilopascalsPerSecond<T>(this T value) =>
+             PressureChangeRate.FromKilopascalsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegapascalPerMinute
+
+        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerMinute(UnitsNet.QuantityValue)" />
+        public static PressureChangeRate MegapascalsPerMinute<T>(this T value) =>
+             PressureChangeRate.FromMegapascalsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegapascalPerSecond
+
+        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerSecond(UnitsNet.QuantityValue)" />
+        public static PressureChangeRate MegapascalsPerSecond<T>(this T value) =>
+             PressureChangeRate.FromMegapascalsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PascalPerMinute
+
+        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerMinute(UnitsNet.QuantityValue)" />
+        public static PressureChangeRate PascalsPerMinute<T>(this T value) =>
+             PressureChangeRate.FromPascalsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PascalPerSecond
+
+        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerSecond(UnitsNet.QuantityValue)" />
+        public static PressureChangeRate PascalsPerSecond<T>(this T value) =>
+             PressureChangeRate.FromPascalsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPressureExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToPressureExtensions.g.cs
new file mode 100644
index 0000000000..27bb301e3c
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToPressureExtensions.g.cs
@@ -0,0 +1,367 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToPressure
+{
+    /// <summary>
+    /// A number to Pressure Extensions
+    /// </summary>
+    public static class NumberToPressureExtensions
+    {
+
+        #region Atmosphere
+
+        /// <inheritdoc cref="Pressure.FromAtmospheres(UnitsNet.QuantityValue)" />
+        public static Pressure Atmospheres<T>(this T value) =>
+             Pressure.FromAtmospheres(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Bar
+
+        /// <inheritdoc cref="Pressure.FromBars(UnitsNet.QuantityValue)" />
+        public static Pressure Bars<T>(this T value) =>
+             Pressure.FromBars(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Centibar
+
+        /// <inheritdoc cref="Pressure.FromCentibars(UnitsNet.QuantityValue)" />
+        public static Pressure Centibars<T>(this T value) =>
+             Pressure.FromCentibars(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Decapascal
+
+        /// <inheritdoc cref="Pressure.FromDecapascals(UnitsNet.QuantityValue)" />
+        public static Pressure Decapascals<T>(this T value) =>
+             Pressure.FromDecapascals(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Decibar
+
+        /// <inheritdoc cref="Pressure.FromDecibars(UnitsNet.QuantityValue)" />
+        public static Pressure Decibars<T>(this T value) =>
+             Pressure.FromDecibars(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DynePerSquareCentimeter
+
+        /// <inheritdoc cref="Pressure.FromDynesPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Pressure DynesPerSquareCentimeter<T>(this T value) =>
+             Pressure.FromDynesPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region FootOfHead
+
+        /// <inheritdoc cref="Pressure.FromFeetOfHead(UnitsNet.QuantityValue)" />
+        public static Pressure FeetOfHead<T>(this T value) =>
+             Pressure.FromFeetOfHead(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Gigapascal
+
+        /// <inheritdoc cref="Pressure.FromGigapascals(UnitsNet.QuantityValue)" />
+        public static Pressure Gigapascals<T>(this T value) =>
+             Pressure.FromGigapascals(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Hectopascal
+
+        /// <inheritdoc cref="Pressure.FromHectopascals(UnitsNet.QuantityValue)" />
+        public static Pressure Hectopascals<T>(this T value) =>
+             Pressure.FromHectopascals(Convert.ToDouble(value));
+
+        #endregion
+
+        #region InchOfMercury
+
+        /// <inheritdoc cref="Pressure.FromInchesOfMercury(UnitsNet.QuantityValue)" />
+        public static Pressure InchesOfMercury<T>(this T value) =>
+             Pressure.FromInchesOfMercury(Convert.ToDouble(value));
+
+        #endregion
+
+        #region InchOfWaterColumn
+
+        /// <inheritdoc cref="Pressure.FromInchesOfWaterColumn(UnitsNet.QuantityValue)" />
+        public static Pressure InchesOfWaterColumn<T>(this T value) =>
+             Pressure.FromInchesOfWaterColumn(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilobar
+
+        /// <inheritdoc cref="Pressure.FromKilobars(UnitsNet.QuantityValue)" />
+        public static Pressure Kilobars<T>(this T value) =>
+             Pressure.FromKilobars(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramForcePerSquareCentimeter
+
+        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Pressure KilogramsForcePerSquareCentimeter<T>(this T value) =>
+             Pressure.FromKilogramsForcePerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramForcePerSquareMeter
+
+        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Pressure KilogramsForcePerSquareMeter<T>(this T value) =>
+             Pressure.FromKilogramsForcePerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramForcePerSquareMillimeter
+
+        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMillimeter(UnitsNet.QuantityValue)" />
+        public static Pressure KilogramsForcePerSquareMillimeter<T>(this T value) =>
+             Pressure.FromKilogramsForcePerSquareMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonPerSquareCentimeter
+
+        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Pressure KilonewtonsPerSquareCentimeter<T>(this T value) =>
+             Pressure.FromKilonewtonsPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonPerSquareMeter
+
+        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Pressure KilonewtonsPerSquareMeter<T>(this T value) =>
+             Pressure.FromKilonewtonsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonPerSquareMillimeter
+
+        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMillimeter(UnitsNet.QuantityValue)" />
+        public static Pressure KilonewtonsPerSquareMillimeter<T>(this T value) =>
+             Pressure.FromKilonewtonsPerSquareMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kilopascal
+
+        /// <inheritdoc cref="Pressure.FromKilopascals(UnitsNet.QuantityValue)" />
+        public static Pressure Kilopascals<T>(this T value) =>
+             Pressure.FromKilopascals(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundForcePerSquareFoot
+
+        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareFoot(UnitsNet.QuantityValue)" />
+        public static Pressure KilopoundsForcePerSquareFoot<T>(this T value) =>
+             Pressure.FromKilopoundsForcePerSquareFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundForcePerSquareInch
+
+        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareInch(UnitsNet.QuantityValue)" />
+        public static Pressure KilopoundsForcePerSquareInch<T>(this T value) =>
+             Pressure.FromKilopoundsForcePerSquareInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megabar
+
+        /// <inheritdoc cref="Pressure.FromMegabars(UnitsNet.QuantityValue)" />
+        public static Pressure Megabars<T>(this T value) =>
+             Pressure.FromMegabars(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeganewtonPerSquareMeter
+
+        /// <inheritdoc cref="Pressure.FromMeganewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Pressure MeganewtonsPerSquareMeter<T>(this T value) =>
+             Pressure.FromMeganewtonsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megapascal
+
+        /// <inheritdoc cref="Pressure.FromMegapascals(UnitsNet.QuantityValue)" />
+        public static Pressure Megapascals<T>(this T value) =>
+             Pressure.FromMegapascals(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeterOfHead
+
+        /// <inheritdoc cref="Pressure.FromMetersOfHead(UnitsNet.QuantityValue)" />
+        public static Pressure MetersOfHead<T>(this T value) =>
+             Pressure.FromMetersOfHead(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microbar
+
+        /// <inheritdoc cref="Pressure.FromMicrobars(UnitsNet.QuantityValue)" />
+        public static Pressure Microbars<T>(this T value) =>
+             Pressure.FromMicrobars(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Micropascal
+
+        /// <inheritdoc cref="Pressure.FromMicropascals(UnitsNet.QuantityValue)" />
+        public static Pressure Micropascals<T>(this T value) =>
+             Pressure.FromMicropascals(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millibar
+
+        /// <inheritdoc cref="Pressure.FromMillibars(UnitsNet.QuantityValue)" />
+        public static Pressure Millibars<T>(this T value) =>
+             Pressure.FromMillibars(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillimeterOfMercury
+
+        /// <inheritdoc cref="Pressure.FromMillimetersOfMercury(UnitsNet.QuantityValue)" />
+        public static Pressure MillimetersOfMercury<T>(this T value) =>
+             Pressure.FromMillimetersOfMercury(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Millipascal
+
+        /// <inheritdoc cref="Pressure.FromMillipascals(UnitsNet.QuantityValue)" />
+        public static Pressure Millipascals<T>(this T value) =>
+             Pressure.FromMillipascals(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonPerSquareCentimeter
+
+        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Pressure NewtonsPerSquareCentimeter<T>(this T value) =>
+             Pressure.FromNewtonsPerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonPerSquareMeter
+
+        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Pressure NewtonsPerSquareMeter<T>(this T value) =>
+             Pressure.FromNewtonsPerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonPerSquareMillimeter
+
+        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMillimeter(UnitsNet.QuantityValue)" />
+        public static Pressure NewtonsPerSquareMillimeter<T>(this T value) =>
+             Pressure.FromNewtonsPerSquareMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Pascal
+
+        /// <inheritdoc cref="Pressure.FromPascals(UnitsNet.QuantityValue)" />
+        public static Pressure Pascals<T>(this T value) =>
+             Pressure.FromPascals(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForcePerSquareFoot
+
+        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareFoot(UnitsNet.QuantityValue)" />
+        public static Pressure PoundsForcePerSquareFoot<T>(this T value) =>
+             Pressure.FromPoundsForcePerSquareFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForcePerSquareInch
+
+        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareInch(UnitsNet.QuantityValue)" />
+        public static Pressure PoundsForcePerSquareInch<T>(this T value) =>
+             Pressure.FromPoundsForcePerSquareInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundPerInchSecondSquared
+
+        /// <inheritdoc cref="Pressure.FromPoundsPerInchSecondSquared(UnitsNet.QuantityValue)" />
+        public static Pressure PoundsPerInchSecondSquared<T>(this T value) =>
+             Pressure.FromPoundsPerInchSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TechnicalAtmosphere
+
+        /// <inheritdoc cref="Pressure.FromTechnicalAtmospheres(UnitsNet.QuantityValue)" />
+        public static Pressure TechnicalAtmospheres<T>(this T value) =>
+             Pressure.FromTechnicalAtmospheres(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForcePerSquareCentimeter
+
+        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareCentimeter(UnitsNet.QuantityValue)" />
+        public static Pressure TonnesForcePerSquareCentimeter<T>(this T value) =>
+             Pressure.FromTonnesForcePerSquareCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForcePerSquareMeter
+
+        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMeter(UnitsNet.QuantityValue)" />
+        public static Pressure TonnesForcePerSquareMeter<T>(this T value) =>
+             Pressure.FromTonnesForcePerSquareMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForcePerSquareMillimeter
+
+        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMillimeter(UnitsNet.QuantityValue)" />
+        public static Pressure TonnesForcePerSquareMillimeter<T>(this T value) =>
+             Pressure.FromTonnesForcePerSquareMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Torr
+
+        /// <inheritdoc cref="Pressure.FromTorrs(UnitsNet.QuantityValue)" />
+        public static Pressure Torrs<T>(this T value) =>
+             Pressure.FromTorrs(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRatioChangeRateExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToRatioChangeRateExtensions.g.cs
new file mode 100644
index 0000000000..8d955f80f2
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToRatioChangeRateExtensions.g.cs
@@ -0,0 +1,47 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToRatioChangeRate
+{
+    /// <summary>
+    /// A number to RatioChangeRate Extensions
+    /// </summary>
+    public static class NumberToRatioChangeRateExtensions
+    {
+
+        #region DecimalFractionPerSecond
+
+        /// <inheritdoc cref="RatioChangeRate.FromDecimalFractionsPerSecond(UnitsNet.QuantityValue)" />
+        public static RatioChangeRate DecimalFractionsPerSecond<T>(this T value) =>
+             RatioChangeRate.FromDecimalFractionsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PercentPerSecond
+
+        /// <inheritdoc cref="RatioChangeRate.FromPercentsPerSecond(UnitsNet.QuantityValue)" />
+        public static RatioChangeRate PercentsPerSecond<T>(this T value) =>
+             RatioChangeRate.FromPercentsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRatioExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToRatioExtensions.g.cs
new file mode 100644
index 0000000000..ad2fc1be4b
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToRatioExtensions.g.cs
@@ -0,0 +1,79 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToRatio
+{
+    /// <summary>
+    /// A number to Ratio Extensions
+    /// </summary>
+    public static class NumberToRatioExtensions
+    {
+
+        #region DecimalFraction
+
+        /// <inheritdoc cref="Ratio.FromDecimalFractions(UnitsNet.QuantityValue)" />
+        public static Ratio DecimalFractions<T>(this T value) =>
+             Ratio.FromDecimalFractions(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerBillion
+
+        /// <inheritdoc cref="Ratio.FromPartsPerBillion(UnitsNet.QuantityValue)" />
+        public static Ratio PartsPerBillion<T>(this T value) =>
+             Ratio.FromPartsPerBillion(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerMillion
+
+        /// <inheritdoc cref="Ratio.FromPartsPerMillion(UnitsNet.QuantityValue)" />
+        public static Ratio PartsPerMillion<T>(this T value) =>
+             Ratio.FromPartsPerMillion(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerThousand
+
+        /// <inheritdoc cref="Ratio.FromPartsPerThousand(UnitsNet.QuantityValue)" />
+        public static Ratio PartsPerThousand<T>(this T value) =>
+             Ratio.FromPartsPerThousand(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerTrillion
+
+        /// <inheritdoc cref="Ratio.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
+        public static Ratio PartsPerTrillion<T>(this T value) =>
+             Ratio.FromPartsPerTrillion(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Percent
+
+        /// <inheritdoc cref="Ratio.FromPercent(UnitsNet.QuantityValue)" />
+        public static Ratio Percent<T>(this T value) =>
+             Ratio.FromPercent(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToReactiveEnergyExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToReactiveEnergyExtensions.g.cs
new file mode 100644
index 0000000000..1829b11da0
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToReactiveEnergyExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToReactiveEnergy
+{
+    /// <summary>
+    /// A number to ReactiveEnergy Extensions
+    /// </summary>
+    public static class NumberToReactiveEnergyExtensions
+    {
+
+        #region KilovoltampereReactiveHour
+
+        /// <inheritdoc cref="ReactiveEnergy.FromKilovoltampereReactiveHours(UnitsNet.QuantityValue)" />
+        public static ReactiveEnergy KilovoltampereReactiveHours<T>(this T value) =>
+             ReactiveEnergy.FromKilovoltampereReactiveHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegavoltampereReactiveHour
+
+        /// <inheritdoc cref="ReactiveEnergy.FromMegavoltampereReactiveHours(UnitsNet.QuantityValue)" />
+        public static ReactiveEnergy MegavoltampereReactiveHours<T>(this T value) =>
+             ReactiveEnergy.FromMegavoltampereReactiveHours(Convert.ToDouble(value));
+
+        #endregion
+
+        #region VoltampereReactiveHour
+
+        /// <inheritdoc cref="ReactiveEnergy.FromVoltampereReactiveHours(UnitsNet.QuantityValue)" />
+        public static ReactiveEnergy VoltampereReactiveHours<T>(this T value) =>
+             ReactiveEnergy.FromVoltampereReactiveHours(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToReactivePowerExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToReactivePowerExtensions.g.cs
new file mode 100644
index 0000000000..aeffb9cb2b
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToReactivePowerExtensions.g.cs
@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToReactivePower
+{
+    /// <summary>
+    /// A number to ReactivePower Extensions
+    /// </summary>
+    public static class NumberToReactivePowerExtensions
+    {
+
+        #region GigavoltampereReactive
+
+        /// <inheritdoc cref="ReactivePower.FromGigavoltamperesReactive(UnitsNet.QuantityValue)" />
+        public static ReactivePower GigavoltamperesReactive<T>(this T value) =>
+             ReactivePower.FromGigavoltamperesReactive(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilovoltampereReactive
+
+        /// <inheritdoc cref="ReactivePower.FromKilovoltamperesReactive(UnitsNet.QuantityValue)" />
+        public static ReactivePower KilovoltamperesReactive<T>(this T value) =>
+             ReactivePower.FromKilovoltamperesReactive(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegavoltampereReactive
+
+        /// <inheritdoc cref="ReactivePower.FromMegavoltamperesReactive(UnitsNet.QuantityValue)" />
+        public static ReactivePower MegavoltamperesReactive<T>(this T value) =>
+             ReactivePower.FromMegavoltamperesReactive(Convert.ToDouble(value));
+
+        #endregion
+
+        #region VoltampereReactive
+
+        /// <inheritdoc cref="ReactivePower.FromVoltamperesReactive(UnitsNet.QuantityValue)" />
+        public static ReactivePower VoltamperesReactive<T>(this T value) =>
+             ReactivePower.FromVoltamperesReactive(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRotationalAccelerationExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToRotationalAccelerationExtensions.g.cs
new file mode 100644
index 0000000000..ba9ba6b474
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToRotationalAccelerationExtensions.g.cs
@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToRotationalAcceleration
+{
+    /// <summary>
+    /// A number to RotationalAcceleration Extensions
+    /// </summary>
+    public static class NumberToRotationalAccelerationExtensions
+    {
+
+        #region DegreePerSecondSquared
+
+        /// <inheritdoc cref="RotationalAcceleration.FromDegreesPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static RotationalAcceleration DegreesPerSecondSquared<T>(this T value) =>
+             RotationalAcceleration.FromDegreesPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region RadianPerSecondSquared
+
+        /// <inheritdoc cref="RotationalAcceleration.FromRadiansPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static RotationalAcceleration RadiansPerSecondSquared<T>(this T value) =>
+             RotationalAcceleration.FromRadiansPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+        #region RevolutionPerMinutePerSecond
+
+        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerMinutePerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalAcceleration RevolutionsPerMinutePerSecond<T>(this T value) =>
+             RotationalAcceleration.FromRevolutionsPerMinutePerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region RevolutionPerSecondSquared
+
+        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerSecondSquared(UnitsNet.QuantityValue)" />
+        public static RotationalAcceleration RevolutionsPerSecondSquared<T>(this T value) =>
+             RotationalAcceleration.FromRevolutionsPerSecondSquared(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRotationalSpeedExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToRotationalSpeedExtensions.g.cs
new file mode 100644
index 0000000000..6b80a889ac
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToRotationalSpeedExtensions.g.cs
@@ -0,0 +1,135 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToRotationalSpeed
+{
+    /// <summary>
+    /// A number to RotationalSpeed Extensions
+    /// </summary>
+    public static class NumberToRotationalSpeedExtensions
+    {
+
+        #region CentiradianPerSecond
+
+        /// <inheritdoc cref="RotationalSpeed.FromCentiradiansPerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed CentiradiansPerSecond<T>(this T value) =>
+             RotationalSpeed.FromCentiradiansPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DeciradianPerSecond
+
+        /// <inheritdoc cref="RotationalSpeed.FromDeciradiansPerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed DeciradiansPerSecond<T>(this T value) =>
+             RotationalSpeed.FromDeciradiansPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreePerMinute
+
+        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerMinute(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed DegreesPerMinute<T>(this T value) =>
+             RotationalSpeed.FromDegreesPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreePerSecond
+
+        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed DegreesPerSecond<T>(this T value) =>
+             RotationalSpeed.FromDegreesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrodegreePerSecond
+
+        /// <inheritdoc cref="RotationalSpeed.FromMicrodegreesPerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed MicrodegreesPerSecond<T>(this T value) =>
+             RotationalSpeed.FromMicrodegreesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicroradianPerSecond
+
+        /// <inheritdoc cref="RotationalSpeed.FromMicroradiansPerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed MicroradiansPerSecond<T>(this T value) =>
+             RotationalSpeed.FromMicroradiansPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillidegreePerSecond
+
+        /// <inheritdoc cref="RotationalSpeed.FromMillidegreesPerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed MillidegreesPerSecond<T>(this T value) =>
+             RotationalSpeed.FromMillidegreesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliradianPerSecond
+
+        /// <inheritdoc cref="RotationalSpeed.FromMilliradiansPerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed MilliradiansPerSecond<T>(this T value) =>
+             RotationalSpeed.FromMilliradiansPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanodegreePerSecond
+
+        /// <inheritdoc cref="RotationalSpeed.FromNanodegreesPerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed NanodegreesPerSecond<T>(this T value) =>
+             RotationalSpeed.FromNanodegreesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanoradianPerSecond
+
+        /// <inheritdoc cref="RotationalSpeed.FromNanoradiansPerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed NanoradiansPerSecond<T>(this T value) =>
+             RotationalSpeed.FromNanoradiansPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region RadianPerSecond
+
+        /// <inheritdoc cref="RotationalSpeed.FromRadiansPerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed RadiansPerSecond<T>(this T value) =>
+             RotationalSpeed.FromRadiansPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region RevolutionPerMinute
+
+        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed RevolutionsPerMinute<T>(this T value) =>
+             RotationalSpeed.FromRevolutionsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region RevolutionPerSecond
+
+        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerSecond(UnitsNet.QuantityValue)" />
+        public static RotationalSpeed RevolutionsPerSecond<T>(this T value) =>
+             RotationalSpeed.FromRevolutionsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessExtensions.g.cs
new file mode 100644
index 0000000000..4283d240f0
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToRotationalStiffness
+{
+    /// <summary>
+    /// A number to RotationalStiffness Extensions
+    /// </summary>
+    public static class NumberToRotationalStiffnessExtensions
+    {
+
+        #region KilonewtonMeterPerRadian
+
+        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerRadian(UnitsNet.QuantityValue)" />
+        public static RotationalStiffness KilonewtonMetersPerRadian<T>(this T value) =>
+             RotationalStiffness.FromKilonewtonMetersPerRadian(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeganewtonMeterPerRadian
+
+        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerRadian(UnitsNet.QuantityValue)" />
+        public static RotationalStiffness MeganewtonMetersPerRadian<T>(this T value) =>
+             RotationalStiffness.FromMeganewtonMetersPerRadian(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonMeterPerRadian
+
+        /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerRadian(UnitsNet.QuantityValue)" />
+        public static RotationalStiffness NewtonMetersPerRadian<T>(this T value) =>
+             RotationalStiffness.FromNewtonMetersPerRadian(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessPerLengthExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessPerLengthExtensions.g.cs
new file mode 100644
index 0000000000..f377b5aeb9
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessPerLengthExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToRotationalStiffnessPerLength
+{
+    /// <summary>
+    /// A number to RotationalStiffnessPerLength Extensions
+    /// </summary>
+    public static class NumberToRotationalStiffnessPerLengthExtensions
+    {
+
+        #region KilonewtonMeterPerRadianPerMeter
+
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
+        public static RotationalStiffnessPerLength KilonewtonMetersPerRadianPerMeter<T>(this T value) =>
+             RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeganewtonMeterPerRadianPerMeter
+
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
+        public static RotationalStiffnessPerLength MeganewtonMetersPerRadianPerMeter<T>(this T value) =>
+             RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonMeterPerRadianPerMeter
+
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
+        public static RotationalStiffnessPerLength NewtonMetersPerRadianPerMeter<T>(this T value) =>
+             RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSolidAngleExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToSolidAngleExtensions.g.cs
new file mode 100644
index 0000000000..c36bf1a0d4
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToSolidAngleExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToSolidAngle
+{
+    /// <summary>
+    /// A number to SolidAngle Extensions
+    /// </summary>
+    public static class NumberToSolidAngleExtensions
+    {
+
+        #region Steradian
+
+        /// <inheritdoc cref="SolidAngle.FromSteradians(UnitsNet.QuantityValue)" />
+        public static SolidAngle Steradians<T>(this T value) =>
+             SolidAngle.FromSteradians(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSpecificEnergyExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToSpecificEnergyExtensions.g.cs
new file mode 100644
index 0000000000..da8c461a92
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToSpecificEnergyExtensions.g.cs
@@ -0,0 +1,103 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToSpecificEnergy
+{
+    /// <summary>
+    /// A number to SpecificEnergy Extensions
+    /// </summary>
+    public static class NumberToSpecificEnergyExtensions
+    {
+
+        #region BtuPerPound
+
+        /// <inheritdoc cref="SpecificEnergy.FromBtuPerPound(UnitsNet.QuantityValue)" />
+        public static SpecificEnergy BtuPerPound<T>(this T value) =>
+             SpecificEnergy.FromBtuPerPound(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CaloriePerGram
+
+        /// <inheritdoc cref="SpecificEnergy.FromCaloriesPerGram(UnitsNet.QuantityValue)" />
+        public static SpecificEnergy CaloriesPerGram<T>(this T value) =>
+             SpecificEnergy.FromCaloriesPerGram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region JoulePerKilogram
+
+        /// <inheritdoc cref="SpecificEnergy.FromJoulesPerKilogram(UnitsNet.QuantityValue)" />
+        public static SpecificEnergy JoulesPerKilogram<T>(this T value) =>
+             SpecificEnergy.FromJoulesPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilocaloriePerGram
+
+        /// <inheritdoc cref="SpecificEnergy.FromKilocaloriesPerGram(UnitsNet.QuantityValue)" />
+        public static SpecificEnergy KilocaloriesPerGram<T>(this T value) =>
+             SpecificEnergy.FromKilocaloriesPerGram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilojoulePerKilogram
+
+        /// <inheritdoc cref="SpecificEnergy.FromKilojoulesPerKilogram(UnitsNet.QuantityValue)" />
+        public static SpecificEnergy KilojoulesPerKilogram<T>(this T value) =>
+             SpecificEnergy.FromKilojoulesPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilowattHourPerKilogram
+
+        /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerKilogram(UnitsNet.QuantityValue)" />
+        public static SpecificEnergy KilowattHoursPerKilogram<T>(this T value) =>
+             SpecificEnergy.FromKilowattHoursPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegajoulePerKilogram
+
+        /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerKilogram(UnitsNet.QuantityValue)" />
+        public static SpecificEnergy MegajoulesPerKilogram<T>(this T value) =>
+             SpecificEnergy.FromMegajoulesPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegawattHourPerKilogram
+
+        /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerKilogram(UnitsNet.QuantityValue)" />
+        public static SpecificEnergy MegawattHoursPerKilogram<T>(this T value) =>
+             SpecificEnergy.FromMegawattHoursPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattHourPerKilogram
+
+        /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerKilogram(UnitsNet.QuantityValue)" />
+        public static SpecificEnergy WattHoursPerKilogram<T>(this T value) =>
+             SpecificEnergy.FromWattHoursPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSpecificEntropyExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToSpecificEntropyExtensions.g.cs
new file mode 100644
index 0000000000..0a398e7556
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToSpecificEntropyExtensions.g.cs
@@ -0,0 +1,103 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToSpecificEntropy
+{
+    /// <summary>
+    /// A number to SpecificEntropy Extensions
+    /// </summary>
+    public static class NumberToSpecificEntropyExtensions
+    {
+
+        #region BtuPerPoundFahrenheit
+
+        /// <inheritdoc cref="SpecificEntropy.FromBtusPerPoundFahrenheit(UnitsNet.QuantityValue)" />
+        public static SpecificEntropy BtusPerPoundFahrenheit<T>(this T value) =>
+             SpecificEntropy.FromBtusPerPoundFahrenheit(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CaloriePerGramKelvin
+
+        /// <inheritdoc cref="SpecificEntropy.FromCaloriesPerGramKelvin(UnitsNet.QuantityValue)" />
+        public static SpecificEntropy CaloriesPerGramKelvin<T>(this T value) =>
+             SpecificEntropy.FromCaloriesPerGramKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+        #region JoulePerKilogramDegreeCelsius
+
+        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
+        public static SpecificEntropy JoulesPerKilogramDegreeCelsius<T>(this T value) =>
+             SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
+
+        #endregion
+
+        #region JoulePerKilogramKelvin
+
+        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
+        public static SpecificEntropy JoulesPerKilogramKelvin<T>(this T value) =>
+             SpecificEntropy.FromJoulesPerKilogramKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilocaloriePerGramKelvin
+
+        /// <inheritdoc cref="SpecificEntropy.FromKilocaloriesPerGramKelvin(UnitsNet.QuantityValue)" />
+        public static SpecificEntropy KilocaloriesPerGramKelvin<T>(this T value) =>
+             SpecificEntropy.FromKilocaloriesPerGramKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilojoulePerKilogramDegreeCelsius
+
+        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
+        public static SpecificEntropy KilojoulesPerKilogramDegreeCelsius<T>(this T value) =>
+             SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilojoulePerKilogramKelvin
+
+        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
+        public static SpecificEntropy KilojoulesPerKilogramKelvin<T>(this T value) =>
+             SpecificEntropy.FromKilojoulesPerKilogramKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegajoulePerKilogramDegreeCelsius
+
+        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
+        public static SpecificEntropy MegajoulesPerKilogramDegreeCelsius<T>(this T value) =>
+             SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegajoulePerKilogramKelvin
+
+        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
+        public static SpecificEntropy MegajoulesPerKilogramKelvin<T>(this T value) =>
+             SpecificEntropy.FromMegajoulesPerKilogramKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSpecificVolumeExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToSpecificVolumeExtensions.g.cs
new file mode 100644
index 0000000000..652342dd10
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToSpecificVolumeExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToSpecificVolume
+{
+    /// <summary>
+    /// A number to SpecificVolume Extensions
+    /// </summary>
+    public static class NumberToSpecificVolumeExtensions
+    {
+
+        #region CubicFootPerPound
+
+        /// <inheritdoc cref="SpecificVolume.FromCubicFeetPerPound(UnitsNet.QuantityValue)" />
+        public static SpecificVolume CubicFeetPerPound<T>(this T value) =>
+             SpecificVolume.FromCubicFeetPerPound(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicMeterPerKilogram
+
+        /// <inheritdoc cref="SpecificVolume.FromCubicMetersPerKilogram(UnitsNet.QuantityValue)" />
+        public static SpecificVolume CubicMetersPerKilogram<T>(this T value) =>
+             SpecificVolume.FromCubicMetersPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillicubicMeterPerKilogram
+
+        /// <inheritdoc cref="SpecificVolume.FromMillicubicMetersPerKilogram(UnitsNet.QuantityValue)" />
+        public static SpecificVolume MillicubicMetersPerKilogram<T>(this T value) =>
+             SpecificVolume.FromMillicubicMetersPerKilogram(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSpecificWeightExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToSpecificWeightExtensions.g.cs
new file mode 100644
index 0000000000..bc6e27473d
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToSpecificWeightExtensions.g.cs
@@ -0,0 +1,167 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToSpecificWeight
+{
+    /// <summary>
+    /// A number to SpecificWeight Extensions
+    /// </summary>
+    public static class NumberToSpecificWeightExtensions
+    {
+
+        #region KilogramForcePerCubicCentimeter
+
+        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicCentimeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight KilogramsForcePerCubicCentimeter<T>(this T value) =>
+             SpecificWeight.FromKilogramsForcePerCubicCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramForcePerCubicMeter
+
+        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight KilogramsForcePerCubicMeter<T>(this T value) =>
+             SpecificWeight.FromKilogramsForcePerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramForcePerCubicMillimeter
+
+        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMillimeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight KilogramsForcePerCubicMillimeter<T>(this T value) =>
+             SpecificWeight.FromKilogramsForcePerCubicMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonPerCubicCentimeter
+
+        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight KilonewtonsPerCubicCentimeter<T>(this T value) =>
+             SpecificWeight.FromKilonewtonsPerCubicCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonPerCubicMeter
+
+        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight KilonewtonsPerCubicMeter<T>(this T value) =>
+             SpecificWeight.FromKilonewtonsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonPerCubicMillimeter
+
+        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight KilonewtonsPerCubicMillimeter<T>(this T value) =>
+             SpecificWeight.FromKilonewtonsPerCubicMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundForcePerCubicFoot
+
+        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicFoot(UnitsNet.QuantityValue)" />
+        public static SpecificWeight KilopoundsForcePerCubicFoot<T>(this T value) =>
+             SpecificWeight.FromKilopoundsForcePerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundForcePerCubicInch
+
+        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicInch(UnitsNet.QuantityValue)" />
+        public static SpecificWeight KilopoundsForcePerCubicInch<T>(this T value) =>
+             SpecificWeight.FromKilopoundsForcePerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeganewtonPerCubicMeter
+
+        /// <inheritdoc cref="SpecificWeight.FromMeganewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight MeganewtonsPerCubicMeter<T>(this T value) =>
+             SpecificWeight.FromMeganewtonsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonPerCubicCentimeter
+
+        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight NewtonsPerCubicCentimeter<T>(this T value) =>
+             SpecificWeight.FromNewtonsPerCubicCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonPerCubicMeter
+
+        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight NewtonsPerCubicMeter<T>(this T value) =>
+             SpecificWeight.FromNewtonsPerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonPerCubicMillimeter
+
+        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight NewtonsPerCubicMillimeter<T>(this T value) =>
+             SpecificWeight.FromNewtonsPerCubicMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForcePerCubicFoot
+
+        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicFoot(UnitsNet.QuantityValue)" />
+        public static SpecificWeight PoundsForcePerCubicFoot<T>(this T value) =>
+             SpecificWeight.FromPoundsForcePerCubicFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForcePerCubicInch
+
+        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicInch(UnitsNet.QuantityValue)" />
+        public static SpecificWeight PoundsForcePerCubicInch<T>(this T value) =>
+             SpecificWeight.FromPoundsForcePerCubicInch(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForcePerCubicCentimeter
+
+        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicCentimeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight TonnesForcePerCubicCentimeter<T>(this T value) =>
+             SpecificWeight.FromTonnesForcePerCubicCentimeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForcePerCubicMeter
+
+        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight TonnesForcePerCubicMeter<T>(this T value) =>
+             SpecificWeight.FromTonnesForcePerCubicMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForcePerCubicMillimeter
+
+        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMillimeter(UnitsNet.QuantityValue)" />
+        public static SpecificWeight TonnesForcePerCubicMillimeter<T>(this T value) =>
+             SpecificWeight.FromTonnesForcePerCubicMillimeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSpeedExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToSpeedExtensions.g.cs
new file mode 100644
index 0000000000..bb116bfd0a
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToSpeedExtensions.g.cs
@@ -0,0 +1,287 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToSpeed
+{
+    /// <summary>
+    /// A number to Speed Extensions
+    /// </summary>
+    public static class NumberToSpeedExtensions
+    {
+
+        #region CentimeterPerHour
+
+        /// <inheritdoc cref="Speed.FromCentimetersPerHour(UnitsNet.QuantityValue)" />
+        public static Speed CentimetersPerHour<T>(this T value) =>
+             Speed.FromCentimetersPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentimeterPerMinute
+
+        /// <inheritdoc cref="Speed.FromCentimetersPerMinutes(UnitsNet.QuantityValue)" />
+        public static Speed CentimetersPerMinutes<T>(this T value) =>
+             Speed.FromCentimetersPerMinutes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentimeterPerSecond
+
+        /// <inheritdoc cref="Speed.FromCentimetersPerSecond(UnitsNet.QuantityValue)" />
+        public static Speed CentimetersPerSecond<T>(this T value) =>
+             Speed.FromCentimetersPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecimeterPerMinute
+
+        /// <inheritdoc cref="Speed.FromDecimetersPerMinutes(UnitsNet.QuantityValue)" />
+        public static Speed DecimetersPerMinutes<T>(this T value) =>
+             Speed.FromDecimetersPerMinutes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecimeterPerSecond
+
+        /// <inheritdoc cref="Speed.FromDecimetersPerSecond(UnitsNet.QuantityValue)" />
+        public static Speed DecimetersPerSecond<T>(this T value) =>
+             Speed.FromDecimetersPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region FootPerHour
+
+        /// <inheritdoc cref="Speed.FromFeetPerHour(UnitsNet.QuantityValue)" />
+        public static Speed FeetPerHour<T>(this T value) =>
+             Speed.FromFeetPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region FootPerMinute
+
+        /// <inheritdoc cref="Speed.FromFeetPerMinute(UnitsNet.QuantityValue)" />
+        public static Speed FeetPerMinute<T>(this T value) =>
+             Speed.FromFeetPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region FootPerSecond
+
+        /// <inheritdoc cref="Speed.FromFeetPerSecond(UnitsNet.QuantityValue)" />
+        public static Speed FeetPerSecond<T>(this T value) =>
+             Speed.FromFeetPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region InchPerHour
+
+        /// <inheritdoc cref="Speed.FromInchesPerHour(UnitsNet.QuantityValue)" />
+        public static Speed InchesPerHour<T>(this T value) =>
+             Speed.FromInchesPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region InchPerMinute
+
+        /// <inheritdoc cref="Speed.FromInchesPerMinute(UnitsNet.QuantityValue)" />
+        public static Speed InchesPerMinute<T>(this T value) =>
+             Speed.FromInchesPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region InchPerSecond
+
+        /// <inheritdoc cref="Speed.FromInchesPerSecond(UnitsNet.QuantityValue)" />
+        public static Speed InchesPerSecond<T>(this T value) =>
+             Speed.FromInchesPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilometerPerHour
+
+        /// <inheritdoc cref="Speed.FromKilometersPerHour(UnitsNet.QuantityValue)" />
+        public static Speed KilometersPerHour<T>(this T value) =>
+             Speed.FromKilometersPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilometerPerMinute
+
+        /// <inheritdoc cref="Speed.FromKilometersPerMinutes(UnitsNet.QuantityValue)" />
+        public static Speed KilometersPerMinutes<T>(this T value) =>
+             Speed.FromKilometersPerMinutes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilometerPerSecond
+
+        /// <inheritdoc cref="Speed.FromKilometersPerSecond(UnitsNet.QuantityValue)" />
+        public static Speed KilometersPerSecond<T>(this T value) =>
+             Speed.FromKilometersPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Knot
+
+        /// <inheritdoc cref="Speed.FromKnots(UnitsNet.QuantityValue)" />
+        public static Speed Knots<T>(this T value) =>
+             Speed.FromKnots(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeterPerHour
+
+        /// <inheritdoc cref="Speed.FromMetersPerHour(UnitsNet.QuantityValue)" />
+        public static Speed MetersPerHour<T>(this T value) =>
+             Speed.FromMetersPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeterPerMinute
+
+        /// <inheritdoc cref="Speed.FromMetersPerMinutes(UnitsNet.QuantityValue)" />
+        public static Speed MetersPerMinutes<T>(this T value) =>
+             Speed.FromMetersPerMinutes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeterPerSecond
+
+        /// <inheritdoc cref="Speed.FromMetersPerSecond(UnitsNet.QuantityValue)" />
+        public static Speed MetersPerSecond<T>(this T value) =>
+             Speed.FromMetersPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrometerPerMinute
+
+        /// <inheritdoc cref="Speed.FromMicrometersPerMinutes(UnitsNet.QuantityValue)" />
+        public static Speed MicrometersPerMinutes<T>(this T value) =>
+             Speed.FromMicrometersPerMinutes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrometerPerSecond
+
+        /// <inheritdoc cref="Speed.FromMicrometersPerSecond(UnitsNet.QuantityValue)" />
+        public static Speed MicrometersPerSecond<T>(this T value) =>
+             Speed.FromMicrometersPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilePerHour
+
+        /// <inheritdoc cref="Speed.FromMilesPerHour(UnitsNet.QuantityValue)" />
+        public static Speed MilesPerHour<T>(this T value) =>
+             Speed.FromMilesPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillimeterPerHour
+
+        /// <inheritdoc cref="Speed.FromMillimetersPerHour(UnitsNet.QuantityValue)" />
+        public static Speed MillimetersPerHour<T>(this T value) =>
+             Speed.FromMillimetersPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillimeterPerMinute
+
+        /// <inheritdoc cref="Speed.FromMillimetersPerMinutes(UnitsNet.QuantityValue)" />
+        public static Speed MillimetersPerMinutes<T>(this T value) =>
+             Speed.FromMillimetersPerMinutes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillimeterPerSecond
+
+        /// <inheritdoc cref="Speed.FromMillimetersPerSecond(UnitsNet.QuantityValue)" />
+        public static Speed MillimetersPerSecond<T>(this T value) =>
+             Speed.FromMillimetersPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanometerPerMinute
+
+        /// <inheritdoc cref="Speed.FromNanometersPerMinutes(UnitsNet.QuantityValue)" />
+        public static Speed NanometersPerMinutes<T>(this T value) =>
+             Speed.FromNanometersPerMinutes(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanometerPerSecond
+
+        /// <inheritdoc cref="Speed.FromNanometersPerSecond(UnitsNet.QuantityValue)" />
+        public static Speed NanometersPerSecond<T>(this T value) =>
+             Speed.FromNanometersPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsSurveyFootPerHour
+
+        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerHour(UnitsNet.QuantityValue)" />
+        public static Speed UsSurveyFeetPerHour<T>(this T value) =>
+             Speed.FromUsSurveyFeetPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsSurveyFootPerMinute
+
+        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerMinute(UnitsNet.QuantityValue)" />
+        public static Speed UsSurveyFeetPerMinute<T>(this T value) =>
+             Speed.FromUsSurveyFeetPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsSurveyFootPerSecond
+
+        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerSecond(UnitsNet.QuantityValue)" />
+        public static Speed UsSurveyFeetPerSecond<T>(this T value) =>
+             Speed.FromUsSurveyFeetPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region YardPerHour
+
+        /// <inheritdoc cref="Speed.FromYardsPerHour(UnitsNet.QuantityValue)" />
+        public static Speed YardsPerHour<T>(this T value) =>
+             Speed.FromYardsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region YardPerMinute
+
+        /// <inheritdoc cref="Speed.FromYardsPerMinute(UnitsNet.QuantityValue)" />
+        public static Speed YardsPerMinute<T>(this T value) =>
+             Speed.FromYardsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region YardPerSecond
+
+        /// <inheritdoc cref="Speed.FromYardsPerSecond(UnitsNet.QuantityValue)" />
+        public static Speed YardsPerSecond<T>(this T value) =>
+             Speed.FromYardsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureChangeRateExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureChangeRateExtensions.g.cs
new file mode 100644
index 0000000000..5fa142aa6a
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureChangeRateExtensions.g.cs
@@ -0,0 +1,111 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToTemperatureChangeRate
+{
+    /// <summary>
+    /// A number to TemperatureChangeRate Extensions
+    /// </summary>
+    public static class NumberToTemperatureChangeRateExtensions
+    {
+
+        #region CentidegreeCelsiusPerSecond
+
+        /// <inheritdoc cref="TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        public static TemperatureChangeRate CentidegreesCelsiusPerSecond<T>(this T value) =>
+             TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecadegreeCelsiusPerSecond
+
+        /// <inheritdoc cref="TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        public static TemperatureChangeRate DecadegreesCelsiusPerSecond<T>(this T value) =>
+             TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecidegreeCelsiusPerSecond
+
+        /// <inheritdoc cref="TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        public static TemperatureChangeRate DecidegreesCelsiusPerSecond<T>(this T value) =>
+             TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeCelsiusPerMinute
+
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerMinute(UnitsNet.QuantityValue)" />
+        public static TemperatureChangeRate DegreesCelsiusPerMinute<T>(this T value) =>
+             TemperatureChangeRate.FromDegreesCelsiusPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeCelsiusPerSecond
+
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        public static TemperatureChangeRate DegreesCelsiusPerSecond<T>(this T value) =>
+             TemperatureChangeRate.FromDegreesCelsiusPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region HectodegreeCelsiusPerSecond
+
+        /// <inheritdoc cref="TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        public static TemperatureChangeRate HectodegreesCelsiusPerSecond<T>(this T value) =>
+             TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilodegreeCelsiusPerSecond
+
+        /// <inheritdoc cref="TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        public static TemperatureChangeRate KilodegreesCelsiusPerSecond<T>(this T value) =>
+             TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrodegreeCelsiusPerSecond
+
+        /// <inheritdoc cref="TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        public static TemperatureChangeRate MicrodegreesCelsiusPerSecond<T>(this T value) =>
+             TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillidegreeCelsiusPerSecond
+
+        /// <inheritdoc cref="TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        public static TemperatureChangeRate MillidegreesCelsiusPerSecond<T>(this T value) =>
+             TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanodegreeCelsiusPerSecond
+
+        /// <inheritdoc cref="TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        public static TemperatureChangeRate NanodegreesCelsiusPerSecond<T>(this T value) =>
+             TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureDeltaExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureDeltaExtensions.g.cs
new file mode 100644
index 0000000000..091f54db63
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureDeltaExtensions.g.cs
@@ -0,0 +1,95 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToTemperatureDelta
+{
+    /// <summary>
+    /// A number to TemperatureDelta Extensions
+    /// </summary>
+    public static class NumberToTemperatureDeltaExtensions
+    {
+
+        #region DegreeCelsius
+
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesCelsius(UnitsNet.QuantityValue)" />
+        public static TemperatureDelta DegreesCelsius<T>(this T value) =>
+             TemperatureDelta.FromDegreesCelsius(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeDelisle
+
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesDelisle(UnitsNet.QuantityValue)" />
+        public static TemperatureDelta DegreesDelisle<T>(this T value) =>
+             TemperatureDelta.FromDegreesDelisle(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeFahrenheit
+
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesFahrenheit(UnitsNet.QuantityValue)" />
+        public static TemperatureDelta DegreesFahrenheit<T>(this T value) =>
+             TemperatureDelta.FromDegreesFahrenheit(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeNewton
+
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesNewton(UnitsNet.QuantityValue)" />
+        public static TemperatureDelta DegreesNewton<T>(this T value) =>
+             TemperatureDelta.FromDegreesNewton(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeRankine
+
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesRankine(UnitsNet.QuantityValue)" />
+        public static TemperatureDelta DegreesRankine<T>(this T value) =>
+             TemperatureDelta.FromDegreesRankine(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeReaumur
+
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesReaumur(UnitsNet.QuantityValue)" />
+        public static TemperatureDelta DegreesReaumur<T>(this T value) =>
+             TemperatureDelta.FromDegreesReaumur(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeRoemer
+
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesRoemer(UnitsNet.QuantityValue)" />
+        public static TemperatureDelta DegreesRoemer<T>(this T value) =>
+             TemperatureDelta.FromDegreesRoemer(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kelvin
+
+        /// <inheritdoc cref="TemperatureDelta.FromKelvins(UnitsNet.QuantityValue)" />
+        public static TemperatureDelta Kelvins<T>(this T value) =>
+             TemperatureDelta.FromKelvins(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureExtensions.g.cs
new file mode 100644
index 0000000000..da644bfe36
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureExtensions.g.cs
@@ -0,0 +1,103 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToTemperature
+{
+    /// <summary>
+    /// A number to Temperature Extensions
+    /// </summary>
+    public static class NumberToTemperatureExtensions
+    {
+
+        #region DegreeCelsius
+
+        /// <inheritdoc cref="Temperature.FromDegreesCelsius(UnitsNet.QuantityValue)" />
+        public static Temperature DegreesCelsius<T>(this T value) =>
+             Temperature.FromDegreesCelsius(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeDelisle
+
+        /// <inheritdoc cref="Temperature.FromDegreesDelisle(UnitsNet.QuantityValue)" />
+        public static Temperature DegreesDelisle<T>(this T value) =>
+             Temperature.FromDegreesDelisle(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeFahrenheit
+
+        /// <inheritdoc cref="Temperature.FromDegreesFahrenheit(UnitsNet.QuantityValue)" />
+        public static Temperature DegreesFahrenheit<T>(this T value) =>
+             Temperature.FromDegreesFahrenheit(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeNewton
+
+        /// <inheritdoc cref="Temperature.FromDegreesNewton(UnitsNet.QuantityValue)" />
+        public static Temperature DegreesNewton<T>(this T value) =>
+             Temperature.FromDegreesNewton(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeRankine
+
+        /// <inheritdoc cref="Temperature.FromDegreesRankine(UnitsNet.QuantityValue)" />
+        public static Temperature DegreesRankine<T>(this T value) =>
+             Temperature.FromDegreesRankine(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeReaumur
+
+        /// <inheritdoc cref="Temperature.FromDegreesReaumur(UnitsNet.QuantityValue)" />
+        public static Temperature DegreesReaumur<T>(this T value) =>
+             Temperature.FromDegreesReaumur(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DegreeRoemer
+
+        /// <inheritdoc cref="Temperature.FromDegreesRoemer(UnitsNet.QuantityValue)" />
+        public static Temperature DegreesRoemer<T>(this T value) =>
+             Temperature.FromDegreesRoemer(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kelvin
+
+        /// <inheritdoc cref="Temperature.FromKelvins(UnitsNet.QuantityValue)" />
+        public static Temperature Kelvins<T>(this T value) =>
+             Temperature.FromKelvins(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SolarTemperature
+
+        /// <inheritdoc cref="Temperature.FromSolarTemperatures(UnitsNet.QuantityValue)" />
+        public static Temperature SolarTemperatures<T>(this T value) =>
+             Temperature.FromSolarTemperatures(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToThermalConductivityExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToThermalConductivityExtensions.g.cs
new file mode 100644
index 0000000000..c353f6ddd4
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToThermalConductivityExtensions.g.cs
@@ -0,0 +1,47 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToThermalConductivity
+{
+    /// <summary>
+    /// A number to ThermalConductivity Extensions
+    /// </summary>
+    public static class NumberToThermalConductivityExtensions
+    {
+
+        #region BtuPerHourFootFahrenheit
+
+        /// <inheritdoc cref="ThermalConductivity.FromBtusPerHourFootFahrenheit(UnitsNet.QuantityValue)" />
+        public static ThermalConductivity BtusPerHourFootFahrenheit<T>(this T value) =>
+             ThermalConductivity.FromBtusPerHourFootFahrenheit(Convert.ToDouble(value));
+
+        #endregion
+
+        #region WattPerMeterKelvin
+
+        /// <inheritdoc cref="ThermalConductivity.FromWattsPerMeterKelvin(UnitsNet.QuantityValue)" />
+        public static ThermalConductivity WattsPerMeterKelvin<T>(this T value) =>
+             ThermalConductivity.FromWattsPerMeterKelvin(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToThermalResistanceExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToThermalResistanceExtensions.g.cs
new file mode 100644
index 0000000000..d1bf9ea6f7
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToThermalResistanceExtensions.g.cs
@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToThermalResistance
+{
+    /// <summary>
+    /// A number to ThermalResistance Extensions
+    /// </summary>
+    public static class NumberToThermalResistanceExtensions
+    {
+
+        #region HourSquareFeetDegreeFahrenheitPerBtu
+
+        /// <inheritdoc cref="ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(UnitsNet.QuantityValue)" />
+        public static ThermalResistance HourSquareFeetDegreesFahrenheitPerBtu<T>(this T value) =>
+             ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareCentimeterHourDegreeCelsiusPerKilocalorie
+
+        /// <inheritdoc cref="ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(UnitsNet.QuantityValue)" />
+        public static ThermalResistance SquareCentimeterHourDegreesCelsiusPerKilocalorie<T>(this T value) =>
+             ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareCentimeterKelvinPerWatt
+
+        /// <inheritdoc cref="ThermalResistance.FromSquareCentimeterKelvinsPerWatt(UnitsNet.QuantityValue)" />
+        public static ThermalResistance SquareCentimeterKelvinsPerWatt<T>(this T value) =>
+             ThermalResistance.FromSquareCentimeterKelvinsPerWatt(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareMeterDegreeCelsiusPerWatt
+
+        /// <inheritdoc cref="ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(UnitsNet.QuantityValue)" />
+        public static ThermalResistance SquareMeterDegreesCelsiusPerWatt<T>(this T value) =>
+             ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(Convert.ToDouble(value));
+
+        #endregion
+
+        #region SquareMeterKelvinPerKilowatt
+
+        /// <inheritdoc cref="ThermalResistance.FromSquareMeterKelvinsPerKilowatt(UnitsNet.QuantityValue)" />
+        public static ThermalResistance SquareMeterKelvinsPerKilowatt<T>(this T value) =>
+             ThermalResistance.FromSquareMeterKelvinsPerKilowatt(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToTorqueExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToTorqueExtensions.g.cs
new file mode 100644
index 0000000000..1b7684978b
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToTorqueExtensions.g.cs
@@ -0,0 +1,199 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToTorque
+{
+    /// <summary>
+    /// A number to Torque Extensions
+    /// </summary>
+    public static class NumberToTorqueExtensions
+    {
+
+        #region KilogramForceCentimeter
+
+        /// <inheritdoc cref="Torque.FromKilogramForceCentimeters(UnitsNet.QuantityValue)" />
+        public static Torque KilogramForceCentimeters<T>(this T value) =>
+             Torque.FromKilogramForceCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramForceMeter
+
+        /// <inheritdoc cref="Torque.FromKilogramForceMeters(UnitsNet.QuantityValue)" />
+        public static Torque KilogramForceMeters<T>(this T value) =>
+             Torque.FromKilogramForceMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramForceMillimeter
+
+        /// <inheritdoc cref="Torque.FromKilogramForceMillimeters(UnitsNet.QuantityValue)" />
+        public static Torque KilogramForceMillimeters<T>(this T value) =>
+             Torque.FromKilogramForceMillimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonCentimeter
+
+        /// <inheritdoc cref="Torque.FromKilonewtonCentimeters(UnitsNet.QuantityValue)" />
+        public static Torque KilonewtonCentimeters<T>(this T value) =>
+             Torque.FromKilonewtonCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonMeter
+
+        /// <inheritdoc cref="Torque.FromKilonewtonMeters(UnitsNet.QuantityValue)" />
+        public static Torque KilonewtonMeters<T>(this T value) =>
+             Torque.FromKilonewtonMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonMillimeter
+
+        /// <inheritdoc cref="Torque.FromKilonewtonMillimeters(UnitsNet.QuantityValue)" />
+        public static Torque KilonewtonMillimeters<T>(this T value) =>
+             Torque.FromKilonewtonMillimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundForceFoot
+
+        /// <inheritdoc cref="Torque.FromKilopoundForceFeet(UnitsNet.QuantityValue)" />
+        public static Torque KilopoundForceFeet<T>(this T value) =>
+             Torque.FromKilopoundForceFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundForceInch
+
+        /// <inheritdoc cref="Torque.FromKilopoundForceInches(UnitsNet.QuantityValue)" />
+        public static Torque KilopoundForceInches<T>(this T value) =>
+             Torque.FromKilopoundForceInches(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeganewtonCentimeter
+
+        /// <inheritdoc cref="Torque.FromMeganewtonCentimeters(UnitsNet.QuantityValue)" />
+        public static Torque MeganewtonCentimeters<T>(this T value) =>
+             Torque.FromMeganewtonCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeganewtonMeter
+
+        /// <inheritdoc cref="Torque.FromMeganewtonMeters(UnitsNet.QuantityValue)" />
+        public static Torque MeganewtonMeters<T>(this T value) =>
+             Torque.FromMeganewtonMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeganewtonMillimeter
+
+        /// <inheritdoc cref="Torque.FromMeganewtonMillimeters(UnitsNet.QuantityValue)" />
+        public static Torque MeganewtonMillimeters<T>(this T value) =>
+             Torque.FromMeganewtonMillimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegapoundForceFoot
+
+        /// <inheritdoc cref="Torque.FromMegapoundForceFeet(UnitsNet.QuantityValue)" />
+        public static Torque MegapoundForceFeet<T>(this T value) =>
+             Torque.FromMegapoundForceFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegapoundForceInch
+
+        /// <inheritdoc cref="Torque.FromMegapoundForceInches(UnitsNet.QuantityValue)" />
+        public static Torque MegapoundForceInches<T>(this T value) =>
+             Torque.FromMegapoundForceInches(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonCentimeter
+
+        /// <inheritdoc cref="Torque.FromNewtonCentimeters(UnitsNet.QuantityValue)" />
+        public static Torque NewtonCentimeters<T>(this T value) =>
+             Torque.FromNewtonCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonMeter
+
+        /// <inheritdoc cref="Torque.FromNewtonMeters(UnitsNet.QuantityValue)" />
+        public static Torque NewtonMeters<T>(this T value) =>
+             Torque.FromNewtonMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonMillimeter
+
+        /// <inheritdoc cref="Torque.FromNewtonMillimeters(UnitsNet.QuantityValue)" />
+        public static Torque NewtonMillimeters<T>(this T value) =>
+             Torque.FromNewtonMillimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForceFoot
+
+        /// <inheritdoc cref="Torque.FromPoundForceFeet(UnitsNet.QuantityValue)" />
+        public static Torque PoundForceFeet<T>(this T value) =>
+             Torque.FromPoundForceFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForceInch
+
+        /// <inheritdoc cref="Torque.FromPoundForceInches(UnitsNet.QuantityValue)" />
+        public static Torque PoundForceInches<T>(this T value) =>
+             Torque.FromPoundForceInches(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForceCentimeter
+
+        /// <inheritdoc cref="Torque.FromTonneForceCentimeters(UnitsNet.QuantityValue)" />
+        public static Torque TonneForceCentimeters<T>(this T value) =>
+             Torque.FromTonneForceCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForceMeter
+
+        /// <inheritdoc cref="Torque.FromTonneForceMeters(UnitsNet.QuantityValue)" />
+        public static Torque TonneForceMeters<T>(this T value) =>
+             Torque.FromTonneForceMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForceMillimeter
+
+        /// <inheritdoc cref="Torque.FromTonneForceMillimeters(UnitsNet.QuantityValue)" />
+        public static Torque TonneForceMillimeters<T>(this T value) =>
+             Torque.FromTonneForceMillimeters(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToTorquePerLengthExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToTorquePerLengthExtensions.g.cs
new file mode 100644
index 0000000000..a3d73dad93
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToTorquePerLengthExtensions.g.cs
@@ -0,0 +1,199 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToTorquePerLength
+{
+    /// <summary>
+    /// A number to TorquePerLength Extensions
+    /// </summary>
+    public static class NumberToTorquePerLengthExtensions
+    {
+
+        #region KilogramForceCentimeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromKilogramForceCentimetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength KilogramForceCentimetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromKilogramForceCentimetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramForceMeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromKilogramForceMetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength KilogramForceMetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromKilogramForceMetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilogramForceMillimeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromKilogramForceMillimetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength KilogramForceMillimetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromKilogramForceMillimetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonCentimeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromKilonewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength KilonewtonCentimetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromKilonewtonCentimetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonMeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromKilonewtonMetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength KilonewtonMetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromKilonewtonMetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilonewtonMillimeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromKilonewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength KilonewtonMillimetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromKilonewtonMillimetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundForceFootPerFoot
+
+        /// <inheritdoc cref="TorquePerLength.FromKilopoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
+        public static TorquePerLength KilopoundForceFeetPerFoot<T>(this T value) =>
+             TorquePerLength.FromKilopoundForceFeetPerFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilopoundForceInchPerFoot
+
+        /// <inheritdoc cref="TorquePerLength.FromKilopoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
+        public static TorquePerLength KilopoundForceInchesPerFoot<T>(this T value) =>
+             TorquePerLength.FromKilopoundForceInchesPerFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeganewtonCentimeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromMeganewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength MeganewtonCentimetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromMeganewtonCentimetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeganewtonMeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromMeganewtonMetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength MeganewtonMetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromMeganewtonMetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MeganewtonMillimeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromMeganewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength MeganewtonMillimetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromMeganewtonMillimetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegapoundForceFootPerFoot
+
+        /// <inheritdoc cref="TorquePerLength.FromMegapoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
+        public static TorquePerLength MegapoundForceFeetPerFoot<T>(this T value) =>
+             TorquePerLength.FromMegapoundForceFeetPerFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegapoundForceInchPerFoot
+
+        /// <inheritdoc cref="TorquePerLength.FromMegapoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
+        public static TorquePerLength MegapoundForceInchesPerFoot<T>(this T value) =>
+             TorquePerLength.FromMegapoundForceInchesPerFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonCentimeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromNewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength NewtonCentimetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromNewtonCentimetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonMeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromNewtonMetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength NewtonMetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromNewtonMetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NewtonMillimeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromNewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength NewtonMillimetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromNewtonMillimetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForceFootPerFoot
+
+        /// <inheritdoc cref="TorquePerLength.FromPoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
+        public static TorquePerLength PoundForceFeetPerFoot<T>(this T value) =>
+             TorquePerLength.FromPoundForceFeetPerFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PoundForceInchPerFoot
+
+        /// <inheritdoc cref="TorquePerLength.FromPoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
+        public static TorquePerLength PoundForceInchesPerFoot<T>(this T value) =>
+             TorquePerLength.FromPoundForceInchesPerFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForceCentimeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromTonneForceCentimetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength TonneForceCentimetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromTonneForceCentimetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForceMeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromTonneForceMetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength TonneForceMetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromTonneForceMetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region TonneForceMillimeterPerMeter
+
+        /// <inheritdoc cref="TorquePerLength.FromTonneForceMillimetersPerMeter(UnitsNet.QuantityValue)" />
+        public static TorquePerLength TonneForceMillimetersPerMeter<T>(this T value) =>
+             TorquePerLength.FromTonneForceMillimetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToVitaminAExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToVitaminAExtensions.g.cs
new file mode 100644
index 0000000000..ce905e2455
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToVitaminAExtensions.g.cs
@@ -0,0 +1,39 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToVitaminA
+{
+    /// <summary>
+    /// A number to VitaminA Extensions
+    /// </summary>
+    public static class NumberToVitaminAExtensions
+    {
+
+        #region InternationalUnit
+
+        /// <inheritdoc cref="VitaminA.FromInternationalUnits(UnitsNet.QuantityValue)" />
+        public static VitaminA InternationalUnits<T>(this T value) =>
+             VitaminA.FromInternationalUnits(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToVolumeConcentrationExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToVolumeConcentrationExtensions.g.cs
new file mode 100644
index 0000000000..b848c421c8
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToVolumeConcentrationExtensions.g.cs
@@ -0,0 +1,191 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToVolumeConcentration
+{
+    /// <summary>
+    /// A number to VolumeConcentration Extensions
+    /// </summary>
+    public static class NumberToVolumeConcentrationExtensions
+    {
+
+        #region CentilitersPerLiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerLiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration CentilitersPerLiter<T>(this T value) =>
+             VolumeConcentration.FromCentilitersPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentilitersPerMililiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerMililiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration CentilitersPerMililiter<T>(this T value) =>
+             VolumeConcentration.FromCentilitersPerMililiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecilitersPerLiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerLiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration DecilitersPerLiter<T>(this T value) =>
+             VolumeConcentration.FromDecilitersPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecilitersPerMililiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerMililiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration DecilitersPerMililiter<T>(this T value) =>
+             VolumeConcentration.FromDecilitersPerMililiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DecimalFraction
+
+        /// <inheritdoc cref="VolumeConcentration.FromDecimalFractions(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration DecimalFractions<T>(this T value) =>
+             VolumeConcentration.FromDecimalFractions(Convert.ToDouble(value));
+
+        #endregion
+
+        #region LitersPerLiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromLitersPerLiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration LitersPerLiter<T>(this T value) =>
+             VolumeConcentration.FromLitersPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region LitersPerMililiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromLitersPerMililiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration LitersPerMililiter<T>(this T value) =>
+             VolumeConcentration.FromLitersPerMililiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrolitersPerLiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerLiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration MicrolitersPerLiter<T>(this T value) =>
+             VolumeConcentration.FromMicrolitersPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicrolitersPerMililiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerMililiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration MicrolitersPerMililiter<T>(this T value) =>
+             VolumeConcentration.FromMicrolitersPerMililiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillilitersPerLiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerLiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration MillilitersPerLiter<T>(this T value) =>
+             VolumeConcentration.FromMillilitersPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillilitersPerMililiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerMililiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration MillilitersPerMililiter<T>(this T value) =>
+             VolumeConcentration.FromMillilitersPerMililiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanolitersPerLiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerLiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration NanolitersPerLiter<T>(this T value) =>
+             VolumeConcentration.FromNanolitersPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanolitersPerMililiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerMililiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration NanolitersPerMililiter<T>(this T value) =>
+             VolumeConcentration.FromNanolitersPerMililiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerBillion
+
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerBillion(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration PartsPerBillion<T>(this T value) =>
+             VolumeConcentration.FromPartsPerBillion(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerMillion
+
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerMillion(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration PartsPerMillion<T>(this T value) =>
+             VolumeConcentration.FromPartsPerMillion(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerThousand
+
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerThousand(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration PartsPerThousand<T>(this T value) =>
+             VolumeConcentration.FromPartsPerThousand(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PartPerTrillion
+
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration PartsPerTrillion<T>(this T value) =>
+             VolumeConcentration.FromPartsPerTrillion(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Percent
+
+        /// <inheritdoc cref="VolumeConcentration.FromPercent(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration Percent<T>(this T value) =>
+             VolumeConcentration.FromPercent(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicolitersPerLiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerLiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration PicolitersPerLiter<T>(this T value) =>
+             VolumeConcentration.FromPicolitersPerLiter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region PicolitersPerMililiter
+
+        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerMililiter(UnitsNet.QuantityValue)" />
+        public static VolumeConcentration PicolitersPerMililiter<T>(this T value) =>
+             VolumeConcentration.FromPicolitersPerMililiter(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToVolumeExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToVolumeExtensions.g.cs
new file mode 100644
index 0000000000..4aca579766
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToVolumeExtensions.g.cs
@@ -0,0 +1,407 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToVolume
+{
+    /// <summary>
+    /// A number to Volume Extensions
+    /// </summary>
+    public static class NumberToVolumeExtensions
+    {
+
+        #region AcreFoot
+
+        /// <inheritdoc cref="Volume.FromAcreFeet(UnitsNet.QuantityValue)" />
+        public static Volume AcreFeet<T>(this T value) =>
+             Volume.FromAcreFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region AuTablespoon
+
+        /// <inheritdoc cref="Volume.FromAuTablespoons(UnitsNet.QuantityValue)" />
+        public static Volume AuTablespoons<T>(this T value) =>
+             Volume.FromAuTablespoons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Centiliter
+
+        /// <inheritdoc cref="Volume.FromCentiliters(UnitsNet.QuantityValue)" />
+        public static Volume Centiliters<T>(this T value) =>
+             Volume.FromCentiliters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicCentimeter
+
+        /// <inheritdoc cref="Volume.FromCubicCentimeters(UnitsNet.QuantityValue)" />
+        public static Volume CubicCentimeters<T>(this T value) =>
+             Volume.FromCubicCentimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicDecimeter
+
+        /// <inheritdoc cref="Volume.FromCubicDecimeters(UnitsNet.QuantityValue)" />
+        public static Volume CubicDecimeters<T>(this T value) =>
+             Volume.FromCubicDecimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicFoot
+
+        /// <inheritdoc cref="Volume.FromCubicFeet(UnitsNet.QuantityValue)" />
+        public static Volume CubicFeet<T>(this T value) =>
+             Volume.FromCubicFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicHectometer
+
+        /// <inheritdoc cref="Volume.FromCubicHectometers(UnitsNet.QuantityValue)" />
+        public static Volume CubicHectometers<T>(this T value) =>
+             Volume.FromCubicHectometers(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicInch
+
+        /// <inheritdoc cref="Volume.FromCubicInches(UnitsNet.QuantityValue)" />
+        public static Volume CubicInches<T>(this T value) =>
+             Volume.FromCubicInches(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicKilometer
+
+        /// <inheritdoc cref="Volume.FromCubicKilometers(UnitsNet.QuantityValue)" />
+        public static Volume CubicKilometers<T>(this T value) =>
+             Volume.FromCubicKilometers(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicMeter
+
+        /// <inheritdoc cref="Volume.FromCubicMeters(UnitsNet.QuantityValue)" />
+        public static Volume CubicMeters<T>(this T value) =>
+             Volume.FromCubicMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicMicrometer
+
+        /// <inheritdoc cref="Volume.FromCubicMicrometers(UnitsNet.QuantityValue)" />
+        public static Volume CubicMicrometers<T>(this T value) =>
+             Volume.FromCubicMicrometers(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicMile
+
+        /// <inheritdoc cref="Volume.FromCubicMiles(UnitsNet.QuantityValue)" />
+        public static Volume CubicMiles<T>(this T value) =>
+             Volume.FromCubicMiles(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicMillimeter
+
+        /// <inheritdoc cref="Volume.FromCubicMillimeters(UnitsNet.QuantityValue)" />
+        public static Volume CubicMillimeters<T>(this T value) =>
+             Volume.FromCubicMillimeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicYard
+
+        /// <inheritdoc cref="Volume.FromCubicYards(UnitsNet.QuantityValue)" />
+        public static Volume CubicYards<T>(this T value) =>
+             Volume.FromCubicYards(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Deciliter
+
+        /// <inheritdoc cref="Volume.FromDeciliters(UnitsNet.QuantityValue)" />
+        public static Volume Deciliters<T>(this T value) =>
+             Volume.FromDeciliters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region HectocubicFoot
+
+        /// <inheritdoc cref="Volume.FromHectocubicFeet(UnitsNet.QuantityValue)" />
+        public static Volume HectocubicFeet<T>(this T value) =>
+             Volume.FromHectocubicFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region HectocubicMeter
+
+        /// <inheritdoc cref="Volume.FromHectocubicMeters(UnitsNet.QuantityValue)" />
+        public static Volume HectocubicMeters<T>(this T value) =>
+             Volume.FromHectocubicMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Hectoliter
+
+        /// <inheritdoc cref="Volume.FromHectoliters(UnitsNet.QuantityValue)" />
+        public static Volume Hectoliters<T>(this T value) =>
+             Volume.FromHectoliters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ImperialBeerBarrel
+
+        /// <inheritdoc cref="Volume.FromImperialBeerBarrels(UnitsNet.QuantityValue)" />
+        public static Volume ImperialBeerBarrels<T>(this T value) =>
+             Volume.FromImperialBeerBarrels(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ImperialGallon
+
+        /// <inheritdoc cref="Volume.FromImperialGallons(UnitsNet.QuantityValue)" />
+        public static Volume ImperialGallons<T>(this T value) =>
+             Volume.FromImperialGallons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ImperialOunce
+
+        /// <inheritdoc cref="Volume.FromImperialOunces(UnitsNet.QuantityValue)" />
+        public static Volume ImperialOunces<T>(this T value) =>
+             Volume.FromImperialOunces(Convert.ToDouble(value));
+
+        #endregion
+
+        #region ImperialPint
+
+        /// <inheritdoc cref="Volume.FromImperialPints(UnitsNet.QuantityValue)" />
+        public static Volume ImperialPints<T>(this T value) =>
+             Volume.FromImperialPints(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilocubicFoot
+
+        /// <inheritdoc cref="Volume.FromKilocubicFeet(UnitsNet.QuantityValue)" />
+        public static Volume KilocubicFeet<T>(this T value) =>
+             Volume.FromKilocubicFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilocubicMeter
+
+        /// <inheritdoc cref="Volume.FromKilocubicMeters(UnitsNet.QuantityValue)" />
+        public static Volume KilocubicMeters<T>(this T value) =>
+             Volume.FromKilocubicMeters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KiloimperialGallon
+
+        /// <inheritdoc cref="Volume.FromKiloimperialGallons(UnitsNet.QuantityValue)" />
+        public static Volume KiloimperialGallons<T>(this T value) =>
+             Volume.FromKiloimperialGallons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Kiloliter
+
+        /// <inheritdoc cref="Volume.FromKiloliters(UnitsNet.QuantityValue)" />
+        public static Volume Kiloliters<T>(this T value) =>
+             Volume.FromKiloliters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilousGallon
+
+        /// <inheritdoc cref="Volume.FromKilousGallons(UnitsNet.QuantityValue)" />
+        public static Volume KilousGallons<T>(this T value) =>
+             Volume.FromKilousGallons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Liter
+
+        /// <inheritdoc cref="Volume.FromLiters(UnitsNet.QuantityValue)" />
+        public static Volume Liters<T>(this T value) =>
+             Volume.FromLiters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegacubicFoot
+
+        /// <inheritdoc cref="Volume.FromMegacubicFeet(UnitsNet.QuantityValue)" />
+        public static Volume MegacubicFeet<T>(this T value) =>
+             Volume.FromMegacubicFeet(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegaimperialGallon
+
+        /// <inheritdoc cref="Volume.FromMegaimperialGallons(UnitsNet.QuantityValue)" />
+        public static Volume MegaimperialGallons<T>(this T value) =>
+             Volume.FromMegaimperialGallons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Megaliter
+
+        /// <inheritdoc cref="Volume.FromMegaliters(UnitsNet.QuantityValue)" />
+        public static Volume Megaliters<T>(this T value) =>
+             Volume.FromMegaliters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegausGallon
+
+        /// <inheritdoc cref="Volume.FromMegausGallons(UnitsNet.QuantityValue)" />
+        public static Volume MegausGallons<T>(this T value) =>
+             Volume.FromMegausGallons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MetricCup
+
+        /// <inheritdoc cref="Volume.FromMetricCups(UnitsNet.QuantityValue)" />
+        public static Volume MetricCups<T>(this T value) =>
+             Volume.FromMetricCups(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MetricTeaspoon
+
+        /// <inheritdoc cref="Volume.FromMetricTeaspoons(UnitsNet.QuantityValue)" />
+        public static Volume MetricTeaspoons<T>(this T value) =>
+             Volume.FromMetricTeaspoons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Microliter
+
+        /// <inheritdoc cref="Volume.FromMicroliters(UnitsNet.QuantityValue)" />
+        public static Volume Microliters<T>(this T value) =>
+             Volume.FromMicroliters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region Milliliter
+
+        /// <inheritdoc cref="Volume.FromMilliliters(UnitsNet.QuantityValue)" />
+        public static Volume Milliliters<T>(this T value) =>
+             Volume.FromMilliliters(Convert.ToDouble(value));
+
+        #endregion
+
+        #region OilBarrel
+
+        /// <inheritdoc cref="Volume.FromOilBarrels(UnitsNet.QuantityValue)" />
+        public static Volume OilBarrels<T>(this T value) =>
+             Volume.FromOilBarrels(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UkTablespoon
+
+        /// <inheritdoc cref="Volume.FromUkTablespoons(UnitsNet.QuantityValue)" />
+        public static Volume UkTablespoons<T>(this T value) =>
+             Volume.FromUkTablespoons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsBeerBarrel
+
+        /// <inheritdoc cref="Volume.FromUsBeerBarrels(UnitsNet.QuantityValue)" />
+        public static Volume UsBeerBarrels<T>(this T value) =>
+             Volume.FromUsBeerBarrels(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsCustomaryCup
+
+        /// <inheritdoc cref="Volume.FromUsCustomaryCups(UnitsNet.QuantityValue)" />
+        public static Volume UsCustomaryCups<T>(this T value) =>
+             Volume.FromUsCustomaryCups(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsGallon
+
+        /// <inheritdoc cref="Volume.FromUsGallons(UnitsNet.QuantityValue)" />
+        public static Volume UsGallons<T>(this T value) =>
+             Volume.FromUsGallons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsLegalCup
+
+        /// <inheritdoc cref="Volume.FromUsLegalCups(UnitsNet.QuantityValue)" />
+        public static Volume UsLegalCups<T>(this T value) =>
+             Volume.FromUsLegalCups(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsOunce
+
+        /// <inheritdoc cref="Volume.FromUsOunces(UnitsNet.QuantityValue)" />
+        public static Volume UsOunces<T>(this T value) =>
+             Volume.FromUsOunces(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsPint
+
+        /// <inheritdoc cref="Volume.FromUsPints(UnitsNet.QuantityValue)" />
+        public static Volume UsPints<T>(this T value) =>
+             Volume.FromUsPints(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsQuart
+
+        /// <inheritdoc cref="Volume.FromUsQuarts(UnitsNet.QuantityValue)" />
+        public static Volume UsQuarts<T>(this T value) =>
+             Volume.FromUsQuarts(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsTablespoon
+
+        /// <inheritdoc cref="Volume.FromUsTablespoons(UnitsNet.QuantityValue)" />
+        public static Volume UsTablespoons<T>(this T value) =>
+             Volume.FromUsTablespoons(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsTeaspoon
+
+        /// <inheritdoc cref="Volume.FromUsTeaspoons(UnitsNet.QuantityValue)" />
+        public static Volume UsTeaspoons<T>(this T value) =>
+             Volume.FromUsTeaspoons(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToVolumeFlowExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToVolumeFlowExtensions.g.cs
new file mode 100644
index 0000000000..8c243707ad
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToVolumeFlowExtensions.g.cs
@@ -0,0 +1,423 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToVolumeFlow
+{
+    /// <summary>
+    /// A number to VolumeFlow Extensions
+    /// </summary>
+    public static class NumberToVolumeFlowExtensions
+    {
+
+        #region AcreFootPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow AcreFeetPerDay<T>(this T value) =>
+             VolumeFlow.FromAcreFeetPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region AcreFootPerHour
+
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerHour(UnitsNet.QuantityValue)" />
+        public static VolumeFlow AcreFeetPerHour<T>(this T value) =>
+             VolumeFlow.FromAcreFeetPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region AcreFootPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow AcreFeetPerMinute<T>(this T value) =>
+             VolumeFlow.FromAcreFeetPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region AcreFootPerSecond
+
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerSecond(UnitsNet.QuantityValue)" />
+        public static VolumeFlow AcreFeetPerSecond<T>(this T value) =>
+             VolumeFlow.FromAcreFeetPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentiliterPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CentilitersPerDay<T>(this T value) =>
+             VolumeFlow.FromCentilitersPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CentiliterPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CentilitersPerMinute<T>(this T value) =>
+             VolumeFlow.FromCentilitersPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicDecimeterPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicDecimetersPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicDecimetersPerMinute<T>(this T value) =>
+             VolumeFlow.FromCubicDecimetersPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicFootPerHour
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerHour(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicFeetPerHour<T>(this T value) =>
+             VolumeFlow.FromCubicFeetPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicFootPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicFeetPerMinute<T>(this T value) =>
+             VolumeFlow.FromCubicFeetPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicFootPerSecond
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerSecond(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicFeetPerSecond<T>(this T value) =>
+             VolumeFlow.FromCubicFeetPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicMeterPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicMetersPerDay<T>(this T value) =>
+             VolumeFlow.FromCubicMetersPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicMeterPerHour
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerHour(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicMetersPerHour<T>(this T value) =>
+             VolumeFlow.FromCubicMetersPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicMeterPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicMetersPerMinute<T>(this T value) =>
+             VolumeFlow.FromCubicMetersPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicMeterPerSecond
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerSecond(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicMetersPerSecond<T>(this T value) =>
+             VolumeFlow.FromCubicMetersPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicMillimeterPerSecond
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicMillimetersPerSecond(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicMillimetersPerSecond<T>(this T value) =>
+             VolumeFlow.FromCubicMillimetersPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicYardPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicYardsPerDay<T>(this T value) =>
+             VolumeFlow.FromCubicYardsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicYardPerHour
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerHour(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicYardsPerHour<T>(this T value) =>
+             VolumeFlow.FromCubicYardsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicYardPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicYardsPerMinute<T>(this T value) =>
+             VolumeFlow.FromCubicYardsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicYardPerSecond
+
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerSecond(UnitsNet.QuantityValue)" />
+        public static VolumeFlow CubicYardsPerSecond<T>(this T value) =>
+             VolumeFlow.FromCubicYardsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DeciliterPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow DecilitersPerDay<T>(this T value) =>
+             VolumeFlow.FromDecilitersPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region DeciliterPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow DecilitersPerMinute<T>(this T value) =>
+             VolumeFlow.FromDecilitersPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KiloliterPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow KilolitersPerDay<T>(this T value) =>
+             VolumeFlow.FromKilolitersPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KiloliterPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow KilolitersPerMinute<T>(this T value) =>
+             VolumeFlow.FromKilolitersPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region KilousGallonPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromKilousGallonsPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow KilousGallonsPerMinute<T>(this T value) =>
+             VolumeFlow.FromKilousGallonsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region LiterPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow LitersPerDay<T>(this T value) =>
+             VolumeFlow.FromLitersPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region LiterPerHour
+
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerHour(UnitsNet.QuantityValue)" />
+        public static VolumeFlow LitersPerHour<T>(this T value) =>
+             VolumeFlow.FromLitersPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region LiterPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow LitersPerMinute<T>(this T value) =>
+             VolumeFlow.FromLitersPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region LiterPerSecond
+
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerSecond(UnitsNet.QuantityValue)" />
+        public static VolumeFlow LitersPerSecond<T>(this T value) =>
+             VolumeFlow.FromLitersPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegaliterPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow MegalitersPerDay<T>(this T value) =>
+             VolumeFlow.FromMegalitersPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MegaukGallonPerSecond
+
+        /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerSecond(UnitsNet.QuantityValue)" />
+        public static VolumeFlow MegaukGallonsPerSecond<T>(this T value) =>
+             VolumeFlow.FromMegaukGallonsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicroliterPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow MicrolitersPerDay<T>(this T value) =>
+             VolumeFlow.FromMicrolitersPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MicroliterPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow MicrolitersPerMinute<T>(this T value) =>
+             VolumeFlow.FromMicrolitersPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliliterPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow MillilitersPerDay<T>(this T value) =>
+             VolumeFlow.FromMillilitersPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MilliliterPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow MillilitersPerMinute<T>(this T value) =>
+             VolumeFlow.FromMillilitersPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region MillionUsGallonsPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromMillionUsGallonsPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow MillionUsGallonsPerDay<T>(this T value) =>
+             VolumeFlow.FromMillionUsGallonsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanoliterPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow NanolitersPerDay<T>(this T value) =>
+             VolumeFlow.FromNanolitersPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region NanoliterPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow NanolitersPerMinute<T>(this T value) =>
+             VolumeFlow.FromNanolitersPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region OilBarrelPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow OilBarrelsPerDay<T>(this T value) =>
+             VolumeFlow.FromOilBarrelsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region OilBarrelPerHour
+
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerHour(UnitsNet.QuantityValue)" />
+        public static VolumeFlow OilBarrelsPerHour<T>(this T value) =>
+             VolumeFlow.FromOilBarrelsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region OilBarrelPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow OilBarrelsPerMinute<T>(this T value) =>
+             VolumeFlow.FromOilBarrelsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region OilBarrelPerSecond
+
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerSecond(UnitsNet.QuantityValue)" />
+        public static VolumeFlow OilBarrelsPerSecond<T>(this T value) =>
+             VolumeFlow.FromOilBarrelsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UkGallonPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow UkGallonsPerDay<T>(this T value) =>
+             VolumeFlow.FromUkGallonsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UkGallonPerHour
+
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerHour(UnitsNet.QuantityValue)" />
+        public static VolumeFlow UkGallonsPerHour<T>(this T value) =>
+             VolumeFlow.FromUkGallonsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UkGallonPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow UkGallonsPerMinute<T>(this T value) =>
+             VolumeFlow.FromUkGallonsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UkGallonPerSecond
+
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerSecond(UnitsNet.QuantityValue)" />
+        public static VolumeFlow UkGallonsPerSecond<T>(this T value) =>
+             VolumeFlow.FromUkGallonsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsGallonPerDay
+
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerDay(UnitsNet.QuantityValue)" />
+        public static VolumeFlow UsGallonsPerDay<T>(this T value) =>
+             VolumeFlow.FromUsGallonsPerDay(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsGallonPerHour
+
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerHour(UnitsNet.QuantityValue)" />
+        public static VolumeFlow UsGallonsPerHour<T>(this T value) =>
+             VolumeFlow.FromUsGallonsPerHour(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsGallonPerMinute
+
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerMinute(UnitsNet.QuantityValue)" />
+        public static VolumeFlow UsGallonsPerMinute<T>(this T value) =>
+             VolumeFlow.FromUsGallonsPerMinute(Convert.ToDouble(value));
+
+        #endregion
+
+        #region UsGallonPerSecond
+
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerSecond(UnitsNet.QuantityValue)" />
+        public static VolumeFlow UsGallonsPerSecond<T>(this T value) =>
+             VolumeFlow.FromUsGallonsPerSecond(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToVolumePerLengthExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/NumberToVolumePerLengthExtensions.g.cs
new file mode 100644
index 0000000000..8e2b9093d1
--- /dev/null
+++ b/UnitsNet/GeneratedCode/Extensions/NumberToVolumePerLengthExtensions.g.cs
@@ -0,0 +1,55 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+                        
+namespace UnitsNet.Extensions.NumberToVolumePerLength
+{
+    /// <summary>
+    /// A number to VolumePerLength Extensions
+    /// </summary>
+    public static class NumberToVolumePerLengthExtensions
+    {
+
+        #region CubicMeterPerMeter
+
+        /// <inheritdoc cref="VolumePerLength.FromCubicMetersPerMeter(UnitsNet.QuantityValue)" />
+        public static VolumePerLength CubicMetersPerMeter<T>(this T value) =>
+             VolumePerLength.FromCubicMetersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region LiterPerMeter
+
+        /// <inheritdoc cref="VolumePerLength.FromLitersPerMeter(UnitsNet.QuantityValue)" />
+        public static VolumePerLength LitersPerMeter<T>(this T value) =>
+             VolumePerLength.FromLitersPerMeter(Convert.ToDouble(value));
+
+        #endregion
+
+        #region OilBarrelPerFoot
+
+        /// <inheritdoc cref="VolumePerLength.FromOilBarrelsPerFoot(UnitsNet.QuantityValue)" />
+        public static VolumePerLength OilBarrelsPerFoot<T>(this T value) =>
+             VolumePerLength.FromOilBarrelsPerFoot(Convert.ToDouble(value));
+
+        #endregion
+
+    }
+}

From a601a8a5dc034d672978e54b366c516a4a67ba86 Mon Sep 17 00:00:00 2001
From: Lu Li <Lu.Li@WOODGROUP.COM>
Date: Wed, 15 Jan 2020 13:37:31 -0700
Subject: [PATCH 07/15] Add the UnitsNet.Extensions project

---
 CodeGen/Generators/UnitsNetGenerator.cs       |  5 ++-
 .../NumberToAccelerationExtensions.g.cs       |  0
 .../NumberToAmountOfSubstanceExtensions.g.cs  |  0
 .../NumberToAmplitudeRatioExtensions.g.cs     |  0
 .../NumberToAngleExtensions.g.cs              |  0
 .../NumberToApparentEnergyExtensions.g.cs     |  0
 .../NumberToApparentPowerExtensions.g.cs      |  0
 .../NumberToAreaDensityExtensions.g.cs        |  0
 .../NumberToAreaExtensions.g.cs               |  0
 ...NumberToAreaMomentOfInertiaExtensions.g.cs |  0
 .../NumberToBitRateExtensions.g.cs            |  0
 ...rakeSpecificFuelConsumptionExtensions.g.cs |  0
 .../NumberToCapacitanceExtensions.g.cs        |  0
 ...efficientOfThermalExpansionExtensions.g.cs |  0
 .../NumberToDensityExtensions.g.cs            |  0
 .../NumberToDurationExtensions.g.cs           |  0
 .../NumberToDynamicViscosityExtensions.g.cs   |  0
 .../NumberToElectricAdmittanceExtensions.g.cs |  0
 ...mberToElectricChargeDensityExtensions.g.cs |  0
 .../NumberToElectricChargeExtensions.g.cs     |  0
 ...NumberToElectricConductanceExtensions.g.cs |  0
 ...umberToElectricConductivityExtensions.g.cs |  0
 ...berToElectricCurrentDensityExtensions.g.cs |  0
 .../NumberToElectricCurrentExtensions.g.cs    |  0
 ...erToElectricCurrentGradientExtensions.g.cs |  0
 .../NumberToElectricFieldExtensions.g.cs      |  0
 .../NumberToElectricInductanceExtensions.g.cs |  0
 ...NumberToElectricPotentialAcExtensions.g.cs |  0
 ...NumberToElectricPotentialDcExtensions.g.cs |  0
 .../NumberToElectricPotentialExtensions.g.cs  |  0
 .../NumberToElectricResistanceExtensions.g.cs |  0
 ...NumberToElectricResistivityExtensions.g.cs |  0
 ...lectricSurfaceChargeDensityExtensions.g.cs |  0
 .../NumberToEnergyExtensions.g.cs             |  0
 .../NumberToEntropyExtensions.g.cs            |  0
 .../NumberToForceChangeRateExtensions.g.cs    |  0
 .../NumberToForceExtensions.g.cs              |  0
 .../NumberToForcePerLengthExtensions.g.cs     |  0
 .../NumberToFrequencyExtensions.g.cs          |  0
 .../NumberToFuelEfficiencyExtensions.g.cs     |  0
 .../NumberToHeatFluxExtensions.g.cs           |  0
 ...erToHeatTransferCoefficientExtensions.g.cs |  0
 .../NumberToIlluminanceExtensions.g.cs        |  0
 .../NumberToInformationExtensions.g.cs        |  0
 .../NumberToIrradianceExtensions.g.cs         |  0
 .../NumberToIrradiationExtensions.g.cs        |  0
 .../NumberToKinematicViscosityExtensions.g.cs |  0
 .../NumberToLapseRateExtensions.g.cs          |  0
 .../NumberToLengthExtensions.g.cs             |  0
 .../NumberToLevelExtensions.g.cs              |  0
 .../NumberToLinearDensityExtensions.g.cs      |  0
 .../NumberToLuminosityExtensions.g.cs         |  0
 .../NumberToLuminousFluxExtensions.g.cs       |  0
 .../NumberToLuminousIntensityExtensions.g.cs  |  0
 .../NumberToMagneticFieldExtensions.g.cs      |  0
 .../NumberToMagneticFluxExtensions.g.cs       |  0
 .../NumberToMagnetizationExtensions.g.cs      |  0
 .../NumberToMassConcentrationExtensions.g.cs  |  0
 .../NumberToMassExtensions.g.cs               |  0
 .../NumberToMassFlowExtensions.g.cs           |  0
 .../NumberToMassFluxExtensions.g.cs           |  0
 .../NumberToMassFractionExtensions.g.cs       |  0
 ...NumberToMassMomentOfInertiaExtensions.g.cs |  0
 .../NumberToMolarEnergyExtensions.g.cs        |  0
 .../NumberToMolarEntropyExtensions.g.cs       |  0
 .../NumberToMolarMassExtensions.g.cs          |  0
 .../NumberToMolarityExtensions.g.cs           |  0
 .../NumberToPermeabilityExtensions.g.cs       |  0
 .../NumberToPermittivityExtensions.g.cs       |  0
 .../NumberToPowerDensityExtensions.g.cs       |  0
 .../NumberToPowerExtensions.g.cs              |  0
 .../NumberToPowerRatioExtensions.g.cs         |  0
 .../NumberToPressureChangeRateExtensions.g.cs |  0
 .../NumberToPressureExtensions.g.cs           |  0
 .../NumberToRatioChangeRateExtensions.g.cs    |  0
 .../NumberToRatioExtensions.g.cs              |  0
 .../NumberToReactiveEnergyExtensions.g.cs     |  0
 .../NumberToReactivePowerExtensions.g.cs      |  0
 ...berToRotationalAccelerationExtensions.g.cs |  0
 .../NumberToRotationalSpeedExtensions.g.cs    |  0
 ...NumberToRotationalStiffnessExtensions.g.cs |  0
 ...otationalStiffnessPerLengthExtensions.g.cs |  0
 .../NumberToSolidAngleExtensions.g.cs         |  0
 .../NumberToSpecificEnergyExtensions.g.cs     |  0
 .../NumberToSpecificEntropyExtensions.g.cs    |  0
 .../NumberToSpecificVolumeExtensions.g.cs     |  0
 .../NumberToSpecificWeightExtensions.g.cs     |  0
 .../NumberToSpeedExtensions.g.cs              |  0
 ...mberToTemperatureChangeRateExtensions.g.cs |  0
 .../NumberToTemperatureDeltaExtensions.g.cs   |  0
 .../NumberToTemperatureExtensions.g.cs        |  0
 ...NumberToThermalConductivityExtensions.g.cs |  0
 .../NumberToThermalResistanceExtensions.g.cs  |  0
 .../NumberToTorqueExtensions.g.cs             |  0
 .../NumberToTorquePerLengthExtensions.g.cs    |  0
 .../NumberToVitaminAExtensions.g.cs           |  0
 ...NumberToVolumeConcentrationExtensions.g.cs |  0
 .../NumberToVolumeExtensions.g.cs             |  0
 .../NumberToVolumeFlowExtensions.g.cs         |  0
 .../NumberToVolumePerLengthExtensions.g.cs    |  0
 .../UnitsNet.Extensions.csproj                | 43 +++++++++++++++++++
 UnitsNet.Tests/UnitsNet.Tests.csproj          |  1 +
 UnitsNet.sln                                  | 14 ++++--
 103 files changed, 57 insertions(+), 6 deletions(-)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToAccelerationExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToAmountOfSubstanceExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToAmplitudeRatioExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToAngleExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToApparentEnergyExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToApparentPowerExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToAreaDensityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToAreaExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToAreaMomentOfInertiaExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToBitRateExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToCapacitanceExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToCoefficientOfThermalExpansionExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToDensityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToDurationExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToDynamicViscosityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricAdmittanceExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricChargeDensityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricChargeExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricConductanceExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricConductivityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricCurrentDensityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricCurrentExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricCurrentGradientExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricFieldExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricInductanceExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricPotentialAcExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricPotentialDcExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricPotentialExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricResistanceExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricResistivityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToElectricSurfaceChargeDensityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToEnergyExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToEntropyExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToForceChangeRateExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToForceExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToForcePerLengthExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToFrequencyExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToFuelEfficiencyExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToHeatFluxExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToHeatTransferCoefficientExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToIlluminanceExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToInformationExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToIrradianceExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToIrradiationExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToKinematicViscosityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToLapseRateExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToLengthExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToLevelExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToLinearDensityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToLuminosityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToLuminousFluxExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToLuminousIntensityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMagneticFieldExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMagneticFluxExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMagnetizationExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMassConcentrationExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMassExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMassFlowExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMassFluxExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMassFractionExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMassMomentOfInertiaExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMolarEnergyExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMolarEntropyExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMolarMassExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToMolarityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToPermeabilityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToPermittivityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToPowerDensityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToPowerExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToPowerRatioExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToPressureChangeRateExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToPressureExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToRatioChangeRateExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToRatioExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToReactiveEnergyExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToReactivePowerExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToRotationalAccelerationExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToRotationalSpeedExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToRotationalStiffnessExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToRotationalStiffnessPerLengthExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToSolidAngleExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToSpecificEnergyExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToSpecificEntropyExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToSpecificVolumeExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToSpecificWeightExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToSpeedExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToTemperatureChangeRateExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToTemperatureDeltaExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToTemperatureExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToThermalConductivityExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToThermalResistanceExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToTorqueExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToTorquePerLengthExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToVitaminAExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToVolumeConcentrationExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToVolumeExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToVolumeFlowExtensions.g.cs (100%)
 rename {UnitsNet/GeneratedCode/Extensions => UnitsNet.Extensions/GeneratedCode/NumberToExtensions}/NumberToVolumePerLengthExtensions.g.cs (100%)
 create mode 100644 UnitsNet.Extensions/UnitsNet.Extensions.csproj

diff --git a/CodeGen/Generators/UnitsNetGenerator.cs b/CodeGen/Generators/UnitsNetGenerator.cs
index c52b7ecc6e..a9af09aa8d 100644
--- a/CodeGen/Generators/UnitsNetGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGenerator.cs
@@ -37,12 +37,13 @@ internal static class UnitsNetGenerator
         public static void Generate(string rootDir, Quantity[] quantities)
         {
             var outputDir = $"{rootDir}/UnitsNet/GeneratedCode";
+            var extensionsOutputDir = $"{rootDir}/UnitsNet.Extensions/GeneratedCode";
             var testProjectDir = $"{rootDir}/UnitsNet.Tests";
 
             // Ensure output directories exist
             Directory.CreateDirectory($"{outputDir}/Quantities");
             Directory.CreateDirectory($"{outputDir}/Units");
-            Directory.CreateDirectory($"{outputDir}/Extensions");
+            Directory.CreateDirectory($"{extensionsOutputDir}/NumberToExtensions");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode/TestsBase");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode/QuantityTests");
@@ -98,7 +99,7 @@ private static void GenerateQuantity(StringBuilder sb, Quantity quantity, string
             sb.Append("quantity(OK) ");
         }
 
-        private static void GenerateNumberExtensions(StringBuilder sb, Quantity quantity, string filePath)
+        private static void GenerateNumberToExtensions(StringBuilder sb, Quantity quantity, string filePath)
         {
             var content = new NumberExtensionsGenerator(quantity).Generate();
             File.WriteAllText(filePath, content, Encoding.UTF8);
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAccelerationExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAccelerationExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToAccelerationExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAccelerationExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAmountOfSubstanceExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAmountOfSubstanceExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToAmountOfSubstanceExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAmountOfSubstanceExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAmplitudeRatioExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAmplitudeRatioExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToAmplitudeRatioExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAmplitudeRatioExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAngleExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAngleExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToAngleExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAngleExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToApparentEnergyExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToApparentEnergyExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToApparentEnergyExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToApparentEnergyExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToApparentPowerExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToApparentPowerExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToApparentPowerExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToApparentPowerExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAreaDensityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaDensityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToAreaDensityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaDensityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAreaExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToAreaExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToAreaMomentOfInertiaExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaMomentOfInertiaExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToAreaMomentOfInertiaExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaMomentOfInertiaExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToBitRateExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToBitRateExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToBitRateExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToBitRateExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToCapacitanceExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToCapacitanceExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToCapacitanceExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToCapacitanceExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToCoefficientOfThermalExpansionExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToCoefficientOfThermalExpansionExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToCoefficientOfThermalExpansionExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToCoefficientOfThermalExpansionExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToDensityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDensityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToDensityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDensityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToDurationExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDurationExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToDurationExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDurationExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToDynamicViscosityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDynamicViscosityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToDynamicViscosityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDynamicViscosityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricAdmittanceExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricAdmittanceExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricAdmittanceExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricAdmittanceExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeDensityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricChargeDensityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeDensityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricChargeDensityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricChargeExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricChargeExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricChargeExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricConductanceExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricConductanceExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricConductanceExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricConductanceExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricConductivityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricConductivityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricConductivityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricConductivityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentDensityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentDensityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentDensityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentDensityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentGradientExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentGradientExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricCurrentGradientExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentGradientExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricFieldExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricFieldExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricFieldExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricFieldExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricInductanceExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricInductanceExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricInductanceExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricInductanceExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialAcExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialAcExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialAcExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialAcExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialDcExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialDcExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialDcExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialDcExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricPotentialExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricResistanceExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricResistanceExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricResistanceExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricResistanceExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricResistivityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricResistivityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricResistivityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricResistivityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToElectricSurfaceChargeDensityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricSurfaceChargeDensityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToElectricSurfaceChargeDensityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricSurfaceChargeDensityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToEnergyExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToEnergyExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToEnergyExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToEnergyExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToEntropyExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToEntropyExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToEntropyExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToEntropyExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToForceChangeRateExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForceChangeRateExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToForceChangeRateExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForceChangeRateExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToForceExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForceExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToForceExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForceExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToForcePerLengthExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForcePerLengthExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToForcePerLengthExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForcePerLengthExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToFrequencyExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToFrequencyExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToFrequencyExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToFrequencyExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToFuelEfficiencyExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToFuelEfficiencyExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToFuelEfficiencyExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToFuelEfficiencyExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToHeatFluxExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToHeatFluxExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToHeatFluxExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToHeatFluxExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToHeatTransferCoefficientExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToHeatTransferCoefficientExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToHeatTransferCoefficientExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToHeatTransferCoefficientExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToIlluminanceExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIlluminanceExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToIlluminanceExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIlluminanceExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToInformationExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToInformationExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToInformationExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToInformationExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToIrradianceExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIrradianceExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToIrradianceExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIrradianceExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToIrradiationExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIrradiationExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToIrradiationExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIrradiationExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToKinematicViscosityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToKinematicViscosityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToKinematicViscosityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToKinematicViscosityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLapseRateExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLapseRateExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToLapseRateExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLapseRateExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLengthExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLengthExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToLengthExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLengthExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLevelExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLevelExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToLevelExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLevelExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLinearDensityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLinearDensityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToLinearDensityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLinearDensityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLuminosityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminosityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToLuminosityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminosityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLuminousFluxExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminousFluxExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToLuminousFluxExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminousFluxExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToLuminousIntensityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminousIntensityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToLuminousIntensityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminousIntensityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMagneticFieldExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagneticFieldExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMagneticFieldExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagneticFieldExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMagneticFluxExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagneticFluxExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMagneticFluxExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagneticFluxExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMagnetizationExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagnetizationExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMagnetizationExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagnetizationExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassConcentrationExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassConcentrationExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMassConcentrationExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassConcentrationExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMassExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassFlowExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFlowExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMassFlowExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFlowExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassFluxExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFluxExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMassFluxExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFluxExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassFractionExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFractionExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMassFractionExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFractionExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMassMomentOfInertiaExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassMomentOfInertiaExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMassMomentOfInertiaExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassMomentOfInertiaExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMolarEnergyExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarEnergyExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMolarEnergyExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarEnergyExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMolarEntropyExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarEntropyExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMolarEntropyExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarEntropyExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMolarMassExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarMassExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMolarMassExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarMassExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToMolarityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToMolarityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPermeabilityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPermeabilityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToPermeabilityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPermeabilityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPermittivityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPermittivityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToPermittivityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPermittivityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPowerDensityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerDensityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToPowerDensityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerDensityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPowerExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToPowerExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPowerRatioExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerRatioExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToPowerRatioExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerRatioExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPressureChangeRateExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPressureChangeRateExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToPressureChangeRateExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPressureChangeRateExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToPressureExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPressureExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToPressureExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPressureExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRatioChangeRateExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRatioChangeRateExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToRatioChangeRateExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRatioChangeRateExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRatioExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRatioExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToRatioExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRatioExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToReactiveEnergyExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToReactiveEnergyExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToReactiveEnergyExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToReactiveEnergyExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToReactivePowerExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToReactivePowerExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToReactivePowerExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToReactivePowerExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRotationalAccelerationExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalAccelerationExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToRotationalAccelerationExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalAccelerationExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRotationalSpeedExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalSpeedExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToRotationalSpeedExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalSpeedExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalStiffnessExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalStiffnessExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessPerLengthExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalStiffnessPerLengthExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToRotationalStiffnessPerLengthExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalStiffnessPerLengthExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSolidAngleExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSolidAngleExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToSolidAngleExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSolidAngleExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSpecificEnergyExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificEnergyExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToSpecificEnergyExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificEnergyExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSpecificEntropyExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificEntropyExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToSpecificEntropyExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificEntropyExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSpecificVolumeExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificVolumeExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToSpecificVolumeExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificVolumeExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSpecificWeightExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificWeightExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToSpecificWeightExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificWeightExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToSpeedExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpeedExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToSpeedExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpeedExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureChangeRateExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureChangeRateExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToTemperatureChangeRateExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureChangeRateExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureDeltaExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureDeltaExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToTemperatureDeltaExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureDeltaExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToTemperatureExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToTemperatureExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToThermalConductivityExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToThermalConductivityExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToThermalConductivityExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToThermalConductivityExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToThermalResistanceExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToThermalResistanceExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToThermalResistanceExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToThermalResistanceExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToTorqueExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTorqueExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToTorqueExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTorqueExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToTorquePerLengthExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTorquePerLengthExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToTorquePerLengthExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTorquePerLengthExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToVitaminAExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVitaminAExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToVitaminAExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVitaminAExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToVolumeConcentrationExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeConcentrationExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToVolumeConcentrationExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeConcentrationExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToVolumeExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToVolumeExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToVolumeFlowExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeFlowExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToVolumeFlowExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeFlowExtensions.g.cs
diff --git a/UnitsNet/GeneratedCode/Extensions/NumberToVolumePerLengthExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumePerLengthExtensions.g.cs
similarity index 100%
rename from UnitsNet/GeneratedCode/Extensions/NumberToVolumePerLengthExtensions.g.cs
rename to UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumePerLengthExtensions.g.cs
diff --git a/UnitsNet.Extensions/UnitsNet.Extensions.csproj b/UnitsNet.Extensions/UnitsNet.Extensions.csproj
new file mode 100644
index 0000000000..8e6790ccdf
--- /dev/null
+++ b/UnitsNet.Extensions/UnitsNet.Extensions.csproj
@@ -0,0 +1,43 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- NuGet properties -->
+  <PropertyGroup>
+    <PackageId>UnitsNet.Extensions</PackageId>
+    <Version>1.0.0</Version>
+    <Authors>Andreas Gullberg Larsen</Authors>
+    <Title>Units.NET Extensions</Title>
+    <Description>A extension library for Units.NET.</Description>
+    <Copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</Copyright>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <RepositoryUrl>https://github.com/angularsen/UnitsNet</RepositoryUrl>
+    <PackageIconUrl>https://raw.githubusercontent.com/angularsen/UnitsNet/ce85185429be345d77eb2ce09c99d59cc9ab8aed/Docs/Images/logo-32.png</PackageIconUrl>
+    <PackageProjectUrl>https://github.com/angularsen/UnitsNet</PackageProjectUrl>
+    <PackageLicenseExpression>MIT-0</PackageLicenseExpression>
+    <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
+    <PackageTags>UnitsNet Extensions NumberToExtensions NumberToUnitsExtensions NumberToUnits convert conversion parse</PackageTags>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <AssemblyVersion>1.0.0.0</AssemblyVersion>
+    <LangVersion>latest</LangVersion>
+    <RootNamespace>UnitsNet</RootNamespace>
+    <TargetFrameworks>netstandard2.0;net40</TargetFrameworks>
+    <MSBuildTreatWarningsAsErrors>true</MSBuildTreatWarningsAsErrors>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Folder Include="GeneratedCode\" />
+  </ItemGroup>
+
+  <!-- Strong name signing -->
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>../UnitsNet.snk</AssemblyOriginatorKeyFile>
+    <DelaySign>false</DelaySign>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+
+  <!-- Project references, will also generate the corresponding nuget dependencies -->
+  <ItemGroup>
+    <ProjectReference Include="..\UnitsNet\UnitsNet.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/UnitsNet.Tests/UnitsNet.Tests.csproj b/UnitsNet.Tests/UnitsNet.Tests.csproj
index 5e319ab79f..8795003776 100644
--- a/UnitsNet.Tests/UnitsNet.Tests.csproj
+++ b/UnitsNet.Tests/UnitsNet.Tests.csproj
@@ -33,6 +33,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\UnitsNet.Extensions\UnitsNet.Extensions.csproj" />
     <ProjectReference Include="..\UnitsNet\UnitsNet.csproj" />
   </ItemGroup>
 
diff --git a/UnitsNet.sln b/UnitsNet.sln
index 0f9fa94fa2..9bed845739 100644
--- a/UnitsNet.sln
+++ b/UnitsNet.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27130.2027
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.29609.76
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitsNet", "UnitsNet\UnitsNet.csproj", "{CBEAD842-07BC-4B08-9D9D-D6659813776F}"
 EndProject
@@ -13,9 +13,11 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitsNet.Tests", "UnitsNet.
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitsNet.Serialization.JsonNet.CompatibilityTests", "UnitsNet.Serialization.JsonNet.CompatibilityTests\UnitsNet.Serialization.JsonNet.CompatibilityTests.csproj", "{21F2FFAC-BF39-487F-9ADE-37100162F955}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitsNet.Benchmark", "UnitsNet.Benchmark\UnitsNet.Benchmark.csproj", "{76B9C7C8-E3D3-4FA7-B782-78E4BA1D0AD8}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitsNet.Benchmark", "UnitsNet.Benchmark\UnitsNet.Benchmark.csproj", "{76B9C7C8-E3D3-4FA7-B782-78E4BA1D0AD8}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeGen", "CodeGen\CodeGen.csproj", "{078E3D44-4F60-46B3-9099-91A7CBF0B213}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeGen", "CodeGen\CodeGen.csproj", "{078E3D44-4F60-46B3-9099-91A7CBF0B213}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitsNet.Extensions", "UnitsNet.Extensions\UnitsNet.Extensions.csproj", "{41763DBA-0F2D-40D2-853C-2CBF719C7208}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -51,6 +53,10 @@ Global
 		{078E3D44-4F60-46B3-9099-91A7CBF0B213}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{078E3D44-4F60-46B3-9099-91A7CBF0B213}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{078E3D44-4F60-46B3-9099-91A7CBF0B213}.Release|Any CPU.Build.0 = Release|Any CPU
+		{41763DBA-0F2D-40D2-853C-2CBF719C7208}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{41763DBA-0F2D-40D2-853C-2CBF719C7208}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{41763DBA-0F2D-40D2-853C-2CBF719C7208}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{41763DBA-0F2D-40D2-853C-2CBF719C7208}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

From cc947f8b4331f5412a45be0ce26b0e351f514ce9 Mon Sep 17 00:00:00 2001
From: Lu Li <Lu.Li@WOODGROUP.COM>
Date: Wed, 15 Jan 2020 14:35:16 -0700
Subject: [PATCH 08/15] Change the build process, include the
 UnitsNet.Extensions project and add the version bump scripts.

---
 Build/build-functions.psm1                    |  3 +-
 ...bump-version-UnitsNet.Extensions-major.bat |  4 ++
 ...bump-version-UnitsNet.Extensions-minor.bat |  4 ++
 ...bump-version-UnitsNet.Extensions-patch.bat |  4 ++
 ...ump-version-UnitsNet.Extensions-suffix.bat |  4 ++
 Build/set-version-UnitsNet.Extensions.ps1     | 59 +++++++++++++++++++
 6 files changed, 77 insertions(+), 1 deletion(-)
 create mode 100644 Build/bump-version-UnitsNet.Extensions-major.bat
 create mode 100644 Build/bump-version-UnitsNet.Extensions-minor.bat
 create mode 100644 Build/bump-version-UnitsNet.Extensions-patch.bat
 create mode 100644 Build/bump-version-UnitsNet.Extensions-suffix.bat
 create mode 100644 Build/set-version-UnitsNet.Extensions.ps1

diff --git a/Build/build-functions.psm1 b/Build/build-functions.psm1
index 967637db2c..cfd11bdd31 100644
--- a/Build/build-functions.psm1
+++ b/Build/build-functions.psm1
@@ -97,7 +97,8 @@ function Start-Tests {
 function Start-PackNugets {
   $projectPaths = @(
     "UnitsNet\UnitsNet.csproj",
-    "UnitsNet.Serialization.JsonNet\UnitsNet.Serialization.JsonNet.csproj"
+    "UnitsNet.Serialization.JsonNet\UnitsNet.Serialization.JsonNet.csproj",
+    "UnitsNet.Extensions\UnitsNet.Extensions.csproj"
     )
 
   write-host -foreground blue "Pack nugets...`n---"
diff --git a/Build/bump-version-UnitsNet.Extensions-major.bat b/Build/bump-version-UnitsNet.Extensions-major.bat
new file mode 100644
index 0000000000..1a779d3135
--- /dev/null
+++ b/Build/bump-version-UnitsNet.Extensions-major.bat
@@ -0,0 +1,4 @@
+@echo off
+SET scriptdir=%~dp0
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.Extensions.ps1 -bump major
+if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet.Extensions-minor.bat b/Build/bump-version-UnitsNet.Extensions-minor.bat
new file mode 100644
index 0000000000..2c3a5b1b49
--- /dev/null
+++ b/Build/bump-version-UnitsNet.Extensions-minor.bat
@@ -0,0 +1,4 @@
+@echo off
+SET scriptdir=%~dp0
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.Extensions.ps1 -bump minor
+if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet.Extensions-patch.bat b/Build/bump-version-UnitsNet.Extensions-patch.bat
new file mode 100644
index 0000000000..b2296035e0
--- /dev/null
+++ b/Build/bump-version-UnitsNet.Extensions-patch.bat
@@ -0,0 +1,4 @@
+@echo off
+SET scriptdir=%~dp0
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.Extensions.ps1 -bump patch
+if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet.Extensions-suffix.bat b/Build/bump-version-UnitsNet.Extensions-suffix.bat
new file mode 100644
index 0000000000..af6cb175df
--- /dev/null
+++ b/Build/bump-version-UnitsNet.Extensions-suffix.bat
@@ -0,0 +1,4 @@
+@echo off
+SET scriptdir=%~dp0
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.Extensions.ps1 -bump suffix
+if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/set-version-UnitsNet.Extensions.ps1 b/Build/set-version-UnitsNet.Extensions.ps1
new file mode 100644
index 0000000000..e171a72b2b
--- /dev/null
+++ b/Build/set-version-UnitsNet.Extensions.ps1
@@ -0,0 +1,59 @@
+<# .SYNOPSIS
+  Updates the version of all UnitsNet.Extensions projects.
+.DESCRIPTION
+  Updates the <Version> property of the .csproj project files.
+.PARAMETER set
+  Set new version
+.PARAMETER bump
+  Bump major, minor, patch or semver suffix number. Only one can be specified at a time, and bumping one part will reset all the lesser parts.
+.EXAMPLE
+  Set new version.
+  -v 2.3.4-beta3: 1.0.0 => 2.3.4-beta3
+.EXAMPLE
+  Bump the major, minor, patch or suffix part of the version.
+  -b major: 1.2.3-alpha1 => 2.0.0
+  -b minor: 1.2.3-alpha1 => 1.3.0
+  -b patch: 1.2.3-alpha1 => 1.2.4
+  -b suffix: 1.2.3-alpha => 1.2.3-alpha2
+  -b suffix: 1.2.3-alpha2 => 1.2.3-alpha3
+  -b suffix: 1.2.3-beta2 => 1.2.3-beta3
+  -b suffix: 1.2.3-rc2 => 1.2.3-rc3
+
+.NOTES
+  Author: Lu Li
+  Date:   Jan 15, 2020
+  Based on original work by Luis Rocha from: http://www.luisrocha.net/2009/11/setting-assembly-version-with-windows.html
+  #>
+  [CmdletBinding()]
+  Param(
+    [Parameter(Mandatory=$true, Position=0, ParameterSetName="set", HelpMessage="Set version string")]
+    [Alias("version")]
+    [string]$setVersion,
+
+    [Parameter(Mandatory=$true, Position=0, ParameterSetName="bump", HelpMessage="Bump one or more version parts")]
+    [Alias("bump")]
+    [ValidateSet('major','minor','patch','suffix')]
+    [string]$bumpVersion
+    )
+
+  function Help {
+    "Sets the AssemblyVersion and AssemblyFileVersion of AssemblyInfo.cs files`n"
+    ".\SetVersion.ps1 [VersionNumber]`n"
+    "   [VersionNumber]     The version number to set, for example: 1.1.9301.0"
+    "                       If not provided, a version number will be generated.`n"
+  }
+
+# Import functions: Get-NewProjectVersion, Set-ProjectVersion, Invoke-CommitAndTagVersion
+Import-Module "$PSScriptRoot\set-version.psm1"
+
+$root = Resolve-Path "$PSScriptRoot\.."
+$paramSet = $PsCmdlet.ParameterSetName
+$projFile = "$root\UnitsNet.Extensions\UnitsNet.Extensions.csproj"
+$versionFiles = @($projFile)
+$projectName = "UnitsNet.Extensions"
+
+# Use UnitsNet.Common.props version as base if bumping major/minor/patch
+$newVersion = Get-NewProjectVersion $projFile $paramSet $setVersion $bumpVersion
+
+Set-ProjectVersion $projFile $newVersion
+Invoke-CommitAndTagVersion $projectName $versionFiles $newVersion

From 970a9a6d24eb148878f48751f4ce42d943a1b101 Mon Sep 17 00:00:00 2001
From: Lu Li <luli0401@gmail.com>
Date: Wed, 22 Jan 2020 14:09:26 -0700
Subject: [PATCH 09/15] Create UnitsNet.Extensions.Tests project.

---
 .../NumberExtensionsTest.cs                   |  0
 .../UnitsNet.Extensions.Tests.csproj          | 39 +++++++++++++++++++
 .../NumberToVolumePerLengthExtensions.g.cs    | 16 ++++++++
 UnitsNet.Tests/UnitsNet.Tests.csproj          |  1 -
 UnitsNet.sln                                  |  8 +++-
 5 files changed, 62 insertions(+), 2 deletions(-)
 rename {UnitsNet.Tests => UnitsNet.Extensions.Tests/NumberToExtensions}/NumberExtensionsTest.cs (100%)
 create mode 100644 UnitsNet.Extensions.Tests/UnitsNet.Extensions.Tests.csproj

diff --git a/UnitsNet.Tests/NumberExtensionsTest.cs b/UnitsNet.Extensions.Tests/NumberToExtensions/NumberExtensionsTest.cs
similarity index 100%
rename from UnitsNet.Tests/NumberExtensionsTest.cs
rename to UnitsNet.Extensions.Tests/NumberToExtensions/NumberExtensionsTest.cs
diff --git a/UnitsNet.Extensions.Tests/UnitsNet.Extensions.Tests.csproj b/UnitsNet.Extensions.Tests/UnitsNet.Extensions.Tests.csproj
new file mode 100644
index 0000000000..751f4469f7
--- /dev/null
+++ b/UnitsNet.Extensions.Tests/UnitsNet.Extensions.Tests.csproj
@@ -0,0 +1,39 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netcoreapp2.1</TargetFrameworks>
+    <RootNamespace>UnitsNet.Extensions.Tests</RootNamespace>
+    <LangVersion>latest</LangVersion>
+    <MSBuildTreatWarningsAsErrors>true</MSBuildTreatWarningsAsErrors>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <!-- Strong name signing -->
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>../UnitsNet.snk</AssemblyOriginatorKeyFile>
+    <DelaySign>false</DelaySign>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyName>UnitsNet.Extensions.Tests</AssemblyName>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="obj\**" />
+    <EmbeddedResource Remove="obj\**" />
+    <None Remove="obj\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="JetBrains.Annotations" Version="2019.1.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.1" />
+    <DotNetCliToolReference Include="JetBrains.dotCover.CommandLineTools" Version="2019.1.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\UnitsNet.Extensions\UnitsNet.Extensions.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumePerLengthExtensions.g.cs b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumePerLengthExtensions.g.cs
index 8e2b9093d1..4d673864c9 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumePerLengthExtensions.g.cs
+++ b/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumePerLengthExtensions.g.cs
@@ -35,6 +35,22 @@ public static VolumePerLength CubicMetersPerMeter<T>(this T value) =>
 
         #endregion
 
+        #region CubicYardPerFoot
+
+        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerFoot(UnitsNet.QuantityValue)" />
+        public static VolumePerLength CubicYardsPerFoot<T>(this T value) =>
+             VolumePerLength.FromCubicYardsPerFoot(Convert.ToDouble(value));
+
+        #endregion
+
+        #region CubicYardPerUsSurveyFoot
+
+        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerUsSurveyFoot(UnitsNet.QuantityValue)" />
+        public static VolumePerLength CubicYardsPerUsSurveyFoot<T>(this T value) =>
+             VolumePerLength.FromCubicYardsPerUsSurveyFoot(Convert.ToDouble(value));
+
+        #endregion
+
         #region LiterPerMeter
 
         /// <inheritdoc cref="VolumePerLength.FromLitersPerMeter(UnitsNet.QuantityValue)" />
diff --git a/UnitsNet.Tests/UnitsNet.Tests.csproj b/UnitsNet.Tests/UnitsNet.Tests.csproj
index 8795003776..5e319ab79f 100644
--- a/UnitsNet.Tests/UnitsNet.Tests.csproj
+++ b/UnitsNet.Tests/UnitsNet.Tests.csproj
@@ -33,7 +33,6 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\UnitsNet.Extensions\UnitsNet.Extensions.csproj" />
     <ProjectReference Include="..\UnitsNet\UnitsNet.csproj" />
   </ItemGroup>
 
diff --git a/UnitsNet.sln b/UnitsNet.sln
index 9bed845739..5a031f6198 100644
--- a/UnitsNet.sln
+++ b/UnitsNet.sln
@@ -17,7 +17,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitsNet.Benchmark", "Units
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeGen", "CodeGen\CodeGen.csproj", "{078E3D44-4F60-46B3-9099-91A7CBF0B213}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitsNet.Extensions", "UnitsNet.Extensions\UnitsNet.Extensions.csproj", "{41763DBA-0F2D-40D2-853C-2CBF719C7208}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitsNet.Extensions", "UnitsNet.Extensions\UnitsNet.Extensions.csproj", "{41763DBA-0F2D-40D2-853C-2CBF719C7208}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitsNet.Extensions.Tests", "UnitsNet.Extensions.Tests\UnitsNet.Extensions.Tests.csproj", "{32DC928D-5E5E-4BD4-AEF4-D46705E46126}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -57,6 +59,10 @@ Global
 		{41763DBA-0F2D-40D2-853C-2CBF719C7208}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{41763DBA-0F2D-40D2-853C-2CBF719C7208}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{41763DBA-0F2D-40D2-853C-2CBF719C7208}.Release|Any CPU.Build.0 = Release|Any CPU
+		{32DC928D-5E5E-4BD4-AEF4-D46705E46126}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{32DC928D-5E5E-4BD4-AEF4-D46705E46126}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{32DC928D-5E5E-4BD4-AEF4-D46705E46126}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{32DC928D-5E5E-4BD4-AEF4-D46705E46126}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

From ebecf7fdaf5df2d077d0e5a6e34696f06cf25955 Mon Sep 17 00:00:00 2001
From: Lu Li <luli0401@gmail.com>
Date: Wed, 22 Jan 2020 15:15:01 -0700
Subject: [PATCH 10/15] Resolve the build error from rebase.

---
 CodeGen/Generators/UnitsNetGenerator.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CodeGen/Generators/UnitsNetGenerator.cs b/CodeGen/Generators/UnitsNetGenerator.cs
index a9af09aa8d..31f6af770a 100644
--- a/CodeGen/Generators/UnitsNetGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGenerator.cs
@@ -53,7 +53,7 @@ public static void Generate(string rootDir, Quantity[] quantities)
                 var sb = new StringBuilder($"{quantity.Name}:".PadRight(AlignPad));
                 GenerateQuantity(sb, quantity, $"{outputDir}/Quantities/{quantity.Name}.g.cs");
                 GenerateUnitType(sb, quantity, $"{outputDir}/Units/{quantity.Name}Unit.g.cs");
-                GenerateNumberExtensions(sb, quantity, $"{outputDir}/Extensions/NumberTo{quantity.Name}Extensions.g.cs");
+                GenerateNumberToExtensions(sb, quantity, $"{outputDir}/Extensions/NumberTo{quantity.Name}Extensions.g.cs");
 
                 // Example: CustomCode/Quantities/LengthTests inherits GeneratedCode/TestsBase/LengthTestsBase
                 // This way when new units are added to the quantity JSON definition, we auto-generate the new

From 0b8b9758a4080841b76bec0fd41a6792b77c27a2 Mon Sep 17 00:00:00 2001
From: Lu Li <luli0401@gmail.com>
Date: Wed, 22 Jan 2020 15:23:08 -0700
Subject: [PATCH 11/15] Fix the wrong directory.

---
 CodeGen/Generators/UnitsNetGenerator.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CodeGen/Generators/UnitsNetGenerator.cs b/CodeGen/Generators/UnitsNetGenerator.cs
index 31f6af770a..a991b0aa2e 100644
--- a/CodeGen/Generators/UnitsNetGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGenerator.cs
@@ -53,7 +53,7 @@ public static void Generate(string rootDir, Quantity[] quantities)
                 var sb = new StringBuilder($"{quantity.Name}:".PadRight(AlignPad));
                 GenerateQuantity(sb, quantity, $"{outputDir}/Quantities/{quantity.Name}.g.cs");
                 GenerateUnitType(sb, quantity, $"{outputDir}/Units/{quantity.Name}Unit.g.cs");
-                GenerateNumberToExtensions(sb, quantity, $"{outputDir}/Extensions/NumberTo{quantity.Name}Extensions.g.cs");
+                GenerateNumberToExtensions(sb, quantity, $"{extensionsOutputDir}/NumberToExtensions/NumberTo{quantity.Name}Extensions.g.cs");
 
                 // Example: CustomCode/Quantities/LengthTests inherits GeneratedCode/TestsBase/LengthTestsBase
                 // This way when new units are added to the quantity JSON definition, we auto-generate the new

From 23972ff8ee4fd505573051985c4e4236a1a3d4bc Mon Sep 17 00:00:00 2001
From: Lu Li <luli0401@gmail.com>
Date: Mon, 3 Feb 2020 10:16:24 -0700
Subject: [PATCH 12/15] Sync the Extension project version number with the main
 library, add a test project for extension methods, and improve the Extension
 project decription.

---
 Build/bump-version-UnitsNet-major.bat         |   1 +
 Build/bump-version-UnitsNet-minor.bat         |   1 +
 Build/bump-version-UnitsNet-patch.bat         |   1 +
 Build/bump-version-UnitsNet-suffix.bat        |   1 +
 ...bump-version-UnitsNet.Extensions-major.bat |   4 -
 ...bump-version-UnitsNet.Extensions-minor.bat |   4 -
 ...bump-version-UnitsNet.Extensions-patch.bat |   4 -
 ...ump-version-UnitsNet.Extensions-suffix.bat |   4 -
 ...ersion-UnitsNet.NumberExtensions-major.bat |   4 +
 ...ersion-UnitsNet.NumberExtensions-minor.bat |   4 +
 ...ersion-UnitsNet.NumberExtensions-patch.bat |   4 +
 ...rsion-UnitsNet.NumberExtensions-suffix.bat |   4 +
 ...set-version-UnitsNet.NumberExtensions.ps1} |   4 +-
 .../UnitsNetGen/NumberExtensionsGenerator.cs  |  21 +-
 .../NumberExtensionsTestClassGenerator.cs     |  57 ++++
 CodeGen/Generators/UnitsNetGenerator.cs       |  16 +-
 .../NumberExtensionsTest.cs                   |  20 --
 .../NumberToAccelerationExtensionsTest.g.cs   |  80 +++++
 ...mberToAmountOfSubstanceExtensionsTest.g.cs |  88 ++++++
 .../NumberToAmplitudeRatioExtensionsTest.g.cs |  44 +++
 .../NumberToAngleExtensionsTest.g.cs          |  84 +++++
 .../NumberToApparentEnergyExtensionsTest.g.cs |  40 +++
 .../NumberToApparentPowerExtensionsTest.g.cs  |  44 +++
 .../NumberToAreaDensityExtensionsTest.g.cs    |  32 ++
 .../NumberToAreaExtensionsTest.g.cs           |  84 +++++
 ...erToAreaMomentOfInertiaExtensionsTest.g.cs |  52 +++
 .../NumberToBitRateExtensionsTest.g.cs        | 132 ++++++++
 ...SpecificFuelConsumptionExtensionsTest.g.cs |  40 +++
 .../NumberToCapacitanceExtensionsTest.g.cs    |  56 ++++
 ...cientOfThermalExpansionExtensionsTest.g.cs |  40 +++
 .../NumberToDensityExtensionsTest.g.cs        | 188 +++++++++++
 .../NumberToDurationExtensionsTest.g.cs       |  68 ++++
 ...umberToDynamicViscosityExtensionsTest.g.cs |  64 ++++
 ...berToElectricAdmittanceExtensionsTest.g.cs |  44 +++
 ...ToElectricChargeDensityExtensionsTest.g.cs |  32 ++
 .../NumberToElectricChargeExtensionsTest.g.cs |  48 +++
 ...erToElectricConductanceExtensionsTest.g.cs |  40 +++
 ...rToElectricConductivityExtensionsTest.g.cs |  40 +++
 ...oElectricCurrentDensityExtensionsTest.g.cs |  40 +++
 ...NumberToElectricCurrentExtensionsTest.g.cs |  60 ++++
 ...ElectricCurrentGradientExtensionsTest.g.cs |  32 ++
 .../NumberToElectricFieldExtensionsTest.g.cs  |  32 ++
 ...berToElectricInductanceExtensionsTest.g.cs |  44 +++
 ...erToElectricPotentialAcExtensionsTest.g.cs |  48 +++
 ...erToElectricPotentialDcExtensionsTest.g.cs |  48 +++
 ...mberToElectricPotentialExtensionsTest.g.cs |  48 +++
 ...berToElectricResistanceExtensionsTest.g.cs |  48 +++
 ...erToElectricResistivityExtensionsTest.g.cs |  84 +++++
 ...ricSurfaceChargeDensityExtensionsTest.g.cs |  40 +++
 .../NumberToEnergyExtensionsTest.g.cs         | 132 ++++++++
 .../NumberToEntropyExtensionsTest.g.cs        |  56 ++++
 ...NumberToForceChangeRateExtensionsTest.g.cs |  72 +++++
 .../NumberToForceExtensionsTest.g.cs          |  80 +++++
 .../NumberToForcePerLengthExtensionsTest.g.cs |  76 +++++
 .../NumberToFrequencyExtensionsTest.g.cs      |  64 ++++
 .../NumberToFuelEfficiencyExtensionsTest.g.cs |  44 +++
 .../NumberToHeatFluxExtensionsTest.g.cs       | 100 ++++++
 ...HeatTransferCoefficientExtensionsTest.g.cs |  40 +++
 .../NumberToIlluminanceExtensionsTest.g.cs    |  44 +++
 .../NumberToInformationExtensionsTest.g.cs    | 132 ++++++++
 .../NumberToIrradianceExtensionsTest.g.cs     |  84 +++++
 .../NumberToIrradiationExtensionsTest.g.cs    |  56 ++++
 ...berToKinematicViscosityExtensionsTest.g.cs |  60 ++++
 .../NumberToLapseRateExtensionsTest.g.cs      |  32 ++
 .../NumberToLengthExtensionsTest.g.cs         | 156 +++++++++
 .../NumberToLevelExtensionsTest.g.cs          |  36 +++
 .../NumberToLinearDensityExtensionsTest.g.cs  |  40 +++
 .../NumberToLuminosityExtensionsTest.g.cs     |  84 +++++
 .../NumberToLuminousFluxExtensionsTest.g.cs   |  32 ++
 ...mberToLuminousIntensityExtensionsTest.g.cs |  32 ++
 .../NumberToMagneticFieldExtensionsTest.g.cs  |  44 +++
 .../NumberToMagneticFluxExtensionsTest.g.cs   |  32 ++
 .../NumberToMagnetizationExtensionsTest.g.cs  |  32 ++
 ...mberToMassConcentrationExtensionsTest.g.cs | 188 +++++++++++
 .../NumberToMassExtensionsTest.g.cs           | 128 ++++++++
 .../NumberToMassFlowExtensionsTest.g.cs       | 160 ++++++++++
 .../NumberToMassFluxExtensionsTest.g.cs       |  36 +++
 .../NumberToMassFractionExtensionsTest.g.cs   | 124 ++++++++
 ...erToMassMomentOfInertiaExtensionsTest.g.cs | 140 +++++++++
 .../NumberToMolarEnergyExtensionsTest.g.cs    |  40 +++
 .../NumberToMolarEntropyExtensionsTest.g.cs   |  40 +++
 .../NumberToMolarMassExtensionsTest.g.cs      |  76 +++++
 .../NumberToMolarityExtensionsTest.g.cs       |  60 ++++
 .../NumberToPermeabilityExtensionsTest.g.cs   |  32 ++
 .../NumberToPermittivityExtensionsTest.g.cs   |  32 ++
 .../NumberToPowerDensityExtensionsTest.g.cs   | 204 ++++++++++++
 .../NumberToPowerExtensionsTest.g.cs          | 128 ++++++++
 .../NumberToPowerRatioExtensionsTest.g.cs     |  36 +++
 ...berToPressureChangeRateExtensionsTest.g.cs |  56 ++++
 .../NumberToPressureExtensionsTest.g.cs       | 196 ++++++++++++
 ...NumberToRatioChangeRateExtensionsTest.g.cs |  36 +++
 .../NumberToRatioExtensionsTest.g.cs          |  52 +++
 .../NumberToReactiveEnergyExtensionsTest.g.cs |  40 +++
 .../NumberToReactivePowerExtensionsTest.g.cs  |  44 +++
 ...oRotationalAccelerationExtensionsTest.g.cs |  44 +++
 ...NumberToRotationalSpeedExtensionsTest.g.cs |  80 +++++
 ...erToRotationalStiffnessExtensionsTest.g.cs |  40 +++
 ...ionalStiffnessPerLengthExtensionsTest.g.cs |  40 +++
 .../NumberToSolidAngleExtensionsTest.g.cs     |  32 ++
 .../NumberToSpecificEnergyExtensionsTest.g.cs |  64 ++++
 ...NumberToSpecificEntropyExtensionsTest.g.cs |  64 ++++
 .../NumberToSpecificVolumeExtensionsTest.g.cs |  40 +++
 .../NumberToSpecificWeightExtensionsTest.g.cs |  96 ++++++
 .../NumberToSpeedExtensionsTest.g.cs          | 156 +++++++++
 ...ToTemperatureChangeRateExtensionsTest.g.cs |  68 ++++
 ...umberToTemperatureDeltaExtensionsTest.g.cs |  60 ++++
 .../NumberToTemperatureExtensionsTest.g.cs    |  64 ++++
 ...erToThermalConductivityExtensionsTest.g.cs |  36 +++
 ...mberToThermalResistanceExtensionsTest.g.cs |  48 +++
 .../NumberToTorqueExtensionsTest.g.cs         | 112 +++++++
 ...NumberToTorquePerLengthExtensionsTest.g.cs | 112 +++++++
 .../NumberToVitaminAExtensionsTest.g.cs       |  32 ++
 ...erToVolumeConcentrationExtensionsTest.g.cs | 108 +++++++
 .../NumberToVolumeExtensionsTest.g.cs         | 216 +++++++++++++
 .../NumberToVolumeFlowExtensionsTest.g.cs     | 224 +++++++++++++
 ...NumberToVolumePerLengthExtensionsTest.g.cs |  48 +++
 .../UnitsNet.NumberExtensions.Tests.csproj    |  10 +-
 .../NumberToAccelerationExtensions.g.cs       |  81 +----
 .../NumberToAmountOfSubstanceExtensions.g.cs  |  93 +-----
 .../NumberToAmplitudeRatioExtensions.g.cs     |  27 +-
 .../NumberToAngleExtensions.g.cs              |  87 +----
 .../NumberToApparentEnergyExtensions.g.cs     |  21 +-
 .../NumberToApparentPowerExtensions.g.cs      |  27 +-
 .../NumberToAreaDensityExtensions.g.cs        |   9 +-
 .../NumberToAreaExtensions.g.cs               |  87 +----
 ...NumberToAreaMomentOfInertiaExtensions.g.cs |  39 +--
 .../NumberToBitRateExtensions.g.cs            | 159 ++--------
 ...rakeSpecificFuelConsumptionExtensions.g.cs |  21 +-
 .../NumberToCapacitanceExtensions.g.cs        |  45 +--
 ...efficientOfThermalExpansionExtensions.g.cs |  21 +-
 .../NumberToDensityExtensions.g.cs            | 243 +++-----------
 .../NumberToDurationExtensions.g.cs           |  63 +---
 .../NumberToDynamicViscosityExtensions.g.cs   |  57 +---
 .../NumberToElectricAdmittanceExtensions.g.cs |  27 +-
 ...mberToElectricChargeDensityExtensions.g.cs |   9 +-
 .../NumberToElectricChargeExtensions.g.cs     |  33 +-
 ...NumberToElectricConductanceExtensions.g.cs |  21 +-
 ...umberToElectricConductivityExtensions.g.cs |  21 +-
 ...berToElectricCurrentDensityExtensions.g.cs |  21 +-
 .../NumberToElectricCurrentExtensions.g.cs    |  51 +--
 ...erToElectricCurrentGradientExtensions.g.cs |   9 +-
 .../NumberToElectricFieldExtensions.g.cs      |   9 +-
 .../NumberToElectricInductanceExtensions.g.cs |  27 +-
 ...NumberToElectricPotentialAcExtensions.g.cs |  33 +-
 ...NumberToElectricPotentialDcExtensions.g.cs |  33 +-
 .../NumberToElectricPotentialExtensions.g.cs  |  33 +-
 .../NumberToElectricResistanceExtensions.g.cs |  33 +-
 ...NumberToElectricResistivityExtensions.g.cs |  87 +----
 ...lectricSurfaceChargeDensityExtensions.g.cs |  21 +-
 .../NumberToEnergyExtensions.g.cs             | 159 ++--------
 .../NumberToEntropyExtensions.g.cs            |  45 +--
 .../NumberToForceChangeRateExtensions.g.cs    |  69 +---
 .../NumberToForceExtensions.g.cs              |  81 +----
 .../NumberToForcePerLengthExtensions.g.cs     |  75 +----
 .../NumberToFrequencyExtensions.g.cs          |  57 +---
 .../NumberToFuelEfficiencyExtensions.g.cs     |  27 +-
 .../NumberToHeatFluxExtensions.g.cs           | 111 ++-----
 ...erToHeatTransferCoefficientExtensions.g.cs |  21 +-
 .../NumberToIlluminanceExtensions.g.cs        |  27 +-
 .../NumberToInformationExtensions.g.cs        | 159 ++--------
 .../NumberToIrradianceExtensions.g.cs         |  87 +----
 .../NumberToIrradiationExtensions.g.cs        |  45 +--
 .../NumberToKinematicViscosityExtensions.g.cs |  51 +--
 .../NumberToLapseRateExtensions.g.cs          |   9 +-
 .../NumberToLengthExtensions.g.cs             | 195 ++----------
 .../NumberToLevelExtensions.g.cs              |  15 +-
 .../NumberToLinearDensityExtensions.g.cs      |  21 +-
 .../NumberToLuminosityExtensions.g.cs         |  87 +----
 .../NumberToLuminousFluxExtensions.g.cs       |   9 +-
 .../NumberToLuminousIntensityExtensions.g.cs  |   9 +-
 .../NumberToMagneticFieldExtensions.g.cs      |  27 +-
 .../NumberToMagneticFluxExtensions.g.cs       |   9 +-
 .../NumberToMagnetizationExtensions.g.cs      |   9 +-
 .../NumberToMassConcentrationExtensions.g.cs  | 243 +++-----------
 .../NumberToMassExtensions.g.cs               | 153 ++-------
 .../NumberToMassFlowExtensions.g.cs           | 201 ++----------
 .../NumberToMassFluxExtensions.g.cs           |  15 +-
 .../NumberToMassFractionExtensions.g.cs       | 147 ++-------
 ...NumberToMassMomentOfInertiaExtensions.g.cs | 171 ++--------
 .../NumberToMolarEnergyExtensions.g.cs        |  21 +-
 .../NumberToMolarEntropyExtensions.g.cs       |  21 +-
 .../NumberToMolarMassExtensions.g.cs          |  75 +----
 .../NumberToMolarityExtensions.g.cs           |  51 +--
 .../NumberToPermeabilityExtensions.g.cs       |   9 +-
 .../NumberToPermittivityExtensions.g.cs       |   9 +-
 .../NumberToPowerDensityExtensions.g.cs       | 267 +++-------------
 .../NumberToPowerExtensions.g.cs              | 153 ++-------
 .../NumberToPowerRatioExtensions.g.cs         |  15 +-
 .../NumberToPressureChangeRateExtensions.g.cs |  45 +--
 .../NumberToPressureExtensions.g.cs           | 255 +++------------
 .../NumberToRatioChangeRateExtensions.g.cs    |  15 +-
 .../NumberToRatioExtensions.g.cs              |  39 +--
 .../NumberToReactiveEnergyExtensions.g.cs     |  21 +-
 .../NumberToReactivePowerExtensions.g.cs      |  27 +-
 ...berToRotationalAccelerationExtensions.g.cs |  27 +-
 .../NumberToRotationalSpeedExtensions.g.cs    |  81 +----
 ...NumberToRotationalStiffnessExtensions.g.cs |  21 +-
 ...otationalStiffnessPerLengthExtensions.g.cs |  21 +-
 .../NumberToSolidAngleExtensions.g.cs         |   9 +-
 .../NumberToSpecificEnergyExtensions.g.cs     |  57 +---
 .../NumberToSpecificEntropyExtensions.g.cs    |  57 +---
 .../NumberToSpecificVolumeExtensions.g.cs     |  21 +-
 .../NumberToSpecificWeightExtensions.g.cs     | 105 ++-----
 .../NumberToSpeedExtensions.g.cs              | 195 ++----------
 ...mberToTemperatureChangeRateExtensions.g.cs |  63 +---
 .../NumberToTemperatureDeltaExtensions.g.cs   |  51 +--
 .../NumberToTemperatureExtensions.g.cs        |  57 +---
 ...NumberToThermalConductivityExtensions.g.cs |  15 +-
 .../NumberToThermalResistanceExtensions.g.cs  |  33 +-
 .../NumberToTorqueExtensions.g.cs             | 129 ++------
 .../NumberToTorquePerLengthExtensions.g.cs    | 129 ++------
 .../NumberToVitaminAExtensions.g.cs           |   9 +-
 ...NumberToVolumeConcentrationExtensions.g.cs | 123 ++------
 .../NumberToVolumeExtensions.g.cs             | 285 +++--------------
 .../NumberToVolumeFlowExtensions.g.cs         | 297 +++---------------
 .../NumberToVolumePerLengthExtensions.g.cs    |  33 +-
 .../UnitsNet.NumberExtensions.csproj          |  12 +-
 UnitsNet.sln                                  |  12 +-
 218 files changed, 8344 insertions(+), 5623 deletions(-)
 delete mode 100644 Build/bump-version-UnitsNet.Extensions-major.bat
 delete mode 100644 Build/bump-version-UnitsNet.Extensions-minor.bat
 delete mode 100644 Build/bump-version-UnitsNet.Extensions-patch.bat
 delete mode 100644 Build/bump-version-UnitsNet.Extensions-suffix.bat
 create mode 100644 Build/bump-version-UnitsNet.NumberExtensions-major.bat
 create mode 100644 Build/bump-version-UnitsNet.NumberExtensions-minor.bat
 create mode 100644 Build/bump-version-UnitsNet.NumberExtensions-patch.bat
 create mode 100644 Build/bump-version-UnitsNet.NumberExtensions-suffix.bat
 rename Build/{set-version-UnitsNet.Extensions.ps1 => set-version-UnitsNet.NumberExtensions.ps1} (94%)
 create mode 100644 CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs
 delete mode 100644 UnitsNet.Extensions.Tests/NumberToExtensions/NumberExtensionsTest.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAccelerationExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmountOfSubstanceExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmplitudeRatioExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAngleExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentEnergyExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentPowerExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaMomentOfInertiaExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCapacitanceExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDurationExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDynamicViscosityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricAdmittanceExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeDensityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductanceExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductivityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentDensityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricFieldExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricInductanceExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialAcExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialDcExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistanceExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistivityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEntropyExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForcePerLengthExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIlluminanceExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradianceExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradiationExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToKinematicViscosityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLapseRateExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLengthExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLevelExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearDensityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminosityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousFluxExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousIntensityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFieldExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFluxExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagnetizationExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFlowExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFluxExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFractionExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassMomentOfInertiaExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEnergyExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEntropyExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermeabilityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermittivityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerRatioExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioChangeRateExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactiveEnergyExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactivePowerExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalAccelerationExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalSpeedExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSolidAngleExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEnergyExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEntropyExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificWeightExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureChangeRateExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureDeltaExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalResistanceExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorquePerLengthExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVitaminAExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
 create mode 100644 UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumePerLengthExtensionsTest.g.cs
 rename UnitsNet.Extensions.Tests/UnitsNet.Extensions.Tests.csproj => UnitsNet.NumberExtensions.Tests/UnitsNet.NumberExtensions.Tests.csproj (80%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToAccelerationExtensions.g.cs (67%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToAmountOfSubstanceExtensions.g.cs (67%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToAmplitudeRatioExtensions.g.cs (77%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToAngleExtensions.g.cs (66%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToApparentEnergyExtensions.g.cs (79%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToApparentPowerExtensions.g.cs (77%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToAreaDensityExtensions.g.cs (87%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToAreaExtensions.g.cs (66%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToAreaMomentOfInertiaExtensions.g.cs (72%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToBitRateExtensions.g.cs (62%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs (77%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToCapacitanceExtensions.g.cs (72%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToCoefficientOfThermalExpansionExtensions.g.cs (77%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToDensityExtensions.g.cs (60%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToDurationExtensions.g.cs (69%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToDynamicViscosityExtensions.g.cs (68%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricAdmittanceExtensions.g.cs (77%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricChargeDensityExtensions.g.cs (87%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricChargeExtensions.g.cs (75%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricConductanceExtensions.g.cs (79%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricConductivityExtensions.g.cs (79%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricCurrentDensityExtensions.g.cs (79%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricCurrentExtensions.g.cs (71%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricCurrentGradientExtensions.g.cs (87%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricFieldExtensions.g.cs (88%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricInductanceExtensions.g.cs (77%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricPotentialAcExtensions.g.cs (75%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricPotentialDcExtensions.g.cs (75%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricPotentialExtensions.g.cs (76%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricResistanceExtensions.g.cs (76%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricResistivityExtensions.g.cs (67%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToElectricSurfaceChargeDensityExtensions.g.cs (77%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToEnergyExtensions.g.cs (62%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToEntropyExtensions.g.cs (71%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToForceChangeRateExtensions.g.cs (67%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToForceExtensions.g.cs (67%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToForcePerLengthExtensions.g.cs (67%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToFrequencyExtensions.g.cs (70%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToFuelEfficiencyExtensions.g.cs (76%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToHeatFluxExtensions.g.cs (63%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToHeatTransferCoefficientExtensions.g.cs (76%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToIlluminanceExtensions.g.cs (78%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToInformationExtensions.g.cs (63%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToIrradianceExtensions.g.cs (65%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToIrradiationExtensions.g.cs (70%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToKinematicViscosityExtensions.g.cs (71%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToLapseRateExtensions.g.cs (87%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToLengthExtensions.g.cs (61%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToLevelExtensions.g.cs (85%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToLinearDensityExtensions.g.cs (79%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToLuminosityExtensions.g.cs (66%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToLuminousFluxExtensions.g.cs (89%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToLuminousIntensityExtensions.g.cs (88%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMagneticFieldExtensions.g.cs (78%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMagneticFluxExtensions.g.cs (89%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMagnetizationExtensions.g.cs (88%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMassConcentrationExtensions.g.cs (62%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMassExtensions.g.cs (63%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMassFlowExtensions.g.cs (61%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMassFluxExtensions.g.cs (81%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMassFractionExtensions.g.cs (63%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMassMomentOfInertiaExtensions.g.cs (63%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMolarEnergyExtensions.g.cs (79%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMolarEntropyExtensions.g.cs (78%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMolarMassExtensions.g.cs (67%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToMolarityExtensions.g.cs (70%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToPermeabilityExtensions.g.cs (88%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToPermittivityExtensions.g.cs (88%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToPowerDensityExtensions.g.cs (61%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToPowerExtensions.g.cs (62%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToPowerRatioExtensions.g.cs (83%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToPressureChangeRateExtensions.g.cs (70%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToPressureExtensions.g.cs (60%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToRatioChangeRateExtensions.g.cs (82%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToRatioExtensions.g.cs (73%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToReactiveEnergyExtensions.g.cs (77%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToReactivePowerExtensions.g.cs (75%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToRotationalAccelerationExtensions.g.cs (74%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToRotationalSpeedExtensions.g.cs (67%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToRotationalStiffnessExtensions.g.cs (77%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToRotationalStiffnessPerLengthExtensions.g.cs (76%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToSolidAngleExtensions.g.cs (89%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToSpecificEnergyExtensions.g.cs (69%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToSpecificEntropyExtensions.g.cs (68%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToSpecificVolumeExtensions.g.cs (78%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToSpecificWeightExtensions.g.cs (64%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToSpeedExtensions.g.cs (61%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToTemperatureChangeRateExtensions.g.cs (68%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToTemperatureDeltaExtensions.g.cs (71%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToTemperatureExtensions.g.cs (69%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToThermalConductivityExtensions.g.cs (81%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToThermalResistanceExtensions.g.cs (72%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToTorqueExtensions.g.cs (63%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToTorquePerLengthExtensions.g.cs (63%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToVitaminAExtensions.g.cs (88%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToVolumeConcentrationExtensions.g.cs (65%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToVolumeExtensions.g.cs (60%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToVolumeFlowExtensions.g.cs (61%)
 rename {UnitsNet.Extensions/GeneratedCode/NumberToExtensions => UnitsNet.NumberExtensions/GeneratedCode}/NumberToVolumePerLengthExtensions.g.cs (73%)
 rename UnitsNet.Extensions/UnitsNet.Extensions.csproj => UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj (78%)

diff --git a/Build/bump-version-UnitsNet-major.bat b/Build/bump-version-UnitsNet-major.bat
index f608d81ab7..dce2e00bce 100644
--- a/Build/bump-version-UnitsNet-major.bat
+++ b/Build/bump-version-UnitsNet-major.bat
@@ -1,4 +1,5 @@
 @echo off
 SET scriptdir=%~dp0
 call powershell -NoProfile %scriptdir%\set-version-UnitsNet.ps1 -bump major
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.NumberExtensions.ps1 -bump major
 if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet-minor.bat b/Build/bump-version-UnitsNet-minor.bat
index 43c7224906..0cc41218b5 100644
--- a/Build/bump-version-UnitsNet-minor.bat
+++ b/Build/bump-version-UnitsNet-minor.bat
@@ -1,4 +1,5 @@
 @echo off
 SET scriptdir=%~dp0
 call powershell -NoProfile %scriptdir%\set-version-UnitsNet.ps1 -bump minor
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.NumberExtensions.ps1 -bump minor
 if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet-patch.bat b/Build/bump-version-UnitsNet-patch.bat
index c911a32962..9af0752f50 100644
--- a/Build/bump-version-UnitsNet-patch.bat
+++ b/Build/bump-version-UnitsNet-patch.bat
@@ -1,4 +1,5 @@
 @echo off
 SET scriptdir=%~dp0
 call powershell -NoProfile %scriptdir%\set-version-UnitsNet.ps1 -bump patch
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.NumberExtensions.ps1 -bump patch
 if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet-suffix.bat b/Build/bump-version-UnitsNet-suffix.bat
index 291e06dfd2..4781f5607c 100644
--- a/Build/bump-version-UnitsNet-suffix.bat
+++ b/Build/bump-version-UnitsNet-suffix.bat
@@ -1,4 +1,5 @@
 @echo off
 SET scriptdir=%~dp0
 call powershell -NoProfile %scriptdir%\set-version-UnitsNet.ps1 -bump suffix
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.NumberExtensions.ps1 -bump suffix
 if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet.Extensions-major.bat b/Build/bump-version-UnitsNet.Extensions-major.bat
deleted file mode 100644
index 1a779d3135..0000000000
--- a/Build/bump-version-UnitsNet.Extensions-major.bat
+++ /dev/null
@@ -1,4 +0,0 @@
-@echo off
-SET scriptdir=%~dp0
-call powershell -NoProfile %scriptdir%\set-version-UnitsNet.Extensions.ps1 -bump major
-if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet.Extensions-minor.bat b/Build/bump-version-UnitsNet.Extensions-minor.bat
deleted file mode 100644
index 2c3a5b1b49..0000000000
--- a/Build/bump-version-UnitsNet.Extensions-minor.bat
+++ /dev/null
@@ -1,4 +0,0 @@
-@echo off
-SET scriptdir=%~dp0
-call powershell -NoProfile %scriptdir%\set-version-UnitsNet.Extensions.ps1 -bump minor
-if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet.Extensions-patch.bat b/Build/bump-version-UnitsNet.Extensions-patch.bat
deleted file mode 100644
index b2296035e0..0000000000
--- a/Build/bump-version-UnitsNet.Extensions-patch.bat
+++ /dev/null
@@ -1,4 +0,0 @@
-@echo off
-SET scriptdir=%~dp0
-call powershell -NoProfile %scriptdir%\set-version-UnitsNet.Extensions.ps1 -bump patch
-if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet.Extensions-suffix.bat b/Build/bump-version-UnitsNet.Extensions-suffix.bat
deleted file mode 100644
index af6cb175df..0000000000
--- a/Build/bump-version-UnitsNet.Extensions-suffix.bat
+++ /dev/null
@@ -1,4 +0,0 @@
-@echo off
-SET scriptdir=%~dp0
-call powershell -NoProfile %scriptdir%\set-version-UnitsNet.Extensions.ps1 -bump suffix
-if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet.NumberExtensions-major.bat b/Build/bump-version-UnitsNet.NumberExtensions-major.bat
new file mode 100644
index 0000000000..b57de0f59f
--- /dev/null
+++ b/Build/bump-version-UnitsNet.NumberExtensions-major.bat
@@ -0,0 +1,4 @@
+@echo off
+SET scriptdir=%~dp0
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.NumberExtensions.ps1 -bump major
+if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet.NumberExtensions-minor.bat b/Build/bump-version-UnitsNet.NumberExtensions-minor.bat
new file mode 100644
index 0000000000..0cc4c5ad31
--- /dev/null
+++ b/Build/bump-version-UnitsNet.NumberExtensions-minor.bat
@@ -0,0 +1,4 @@
+@echo off
+SET scriptdir=%~dp0
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.NumberExtensions.ps1 -bump minor
+if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet.NumberExtensions-patch.bat b/Build/bump-version-UnitsNet.NumberExtensions-patch.bat
new file mode 100644
index 0000000000..577ab6c7ad
--- /dev/null
+++ b/Build/bump-version-UnitsNet.NumberExtensions-patch.bat
@@ -0,0 +1,4 @@
+@echo off
+SET scriptdir=%~dp0
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.NumberExtensions.ps1 -bump patch
+if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/bump-version-UnitsNet.NumberExtensions-suffix.bat b/Build/bump-version-UnitsNet.NumberExtensions-suffix.bat
new file mode 100644
index 0000000000..7bc980b07e
--- /dev/null
+++ b/Build/bump-version-UnitsNet.NumberExtensions-suffix.bat
@@ -0,0 +1,4 @@
+@echo off
+SET scriptdir=%~dp0
+call powershell -NoProfile %scriptdir%\set-version-UnitsNet.NumberExtensions.ps1 -bump suffix
+if %errorlevel% neq 0 exit /b %errorlevel%
\ No newline at end of file
diff --git a/Build/set-version-UnitsNet.Extensions.ps1 b/Build/set-version-UnitsNet.NumberExtensions.ps1
similarity index 94%
rename from Build/set-version-UnitsNet.Extensions.ps1
rename to Build/set-version-UnitsNet.NumberExtensions.ps1
index e171a72b2b..be2ac86642 100644
--- a/Build/set-version-UnitsNet.Extensions.ps1
+++ b/Build/set-version-UnitsNet.NumberExtensions.ps1
@@ -48,9 +48,9 @@ Import-Module "$PSScriptRoot\set-version.psm1"
 
 $root = Resolve-Path "$PSScriptRoot\.."
 $paramSet = $PsCmdlet.ParameterSetName
-$projFile = "$root\UnitsNet.Extensions\UnitsNet.Extensions.csproj"
+$projFile = "$root\UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj"
 $versionFiles = @($projFile)
-$projectName = "UnitsNet.Extensions"
+$projectName = "UnitsNet.NumberExtensions"
 
 # Use UnitsNet.Common.props version as base if bumping major/minor/patch
 $newVersion = Get-NewProjectVersion $projFile $paramSet $setVersion $bumpVersion
diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
index 9fda87baf3..3942b8e556 100644
--- a/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
@@ -25,34 +25,27 @@ public override string Generate()
 $@"
 using System;
                         
-namespace UnitsNet.Extensions.NumberTo{_quantityName}
+namespace UnitsNet.NumberExtensions.NumberTo{_quantityName}
 {{
     /// <summary>
     /// A number to {_quantityName} Extensions
     /// </summary>
     public static class NumberTo{_quantityName}Extensions
-    {{
-"
-            );
+    {{");
 
             foreach (var unit in _units)
             {
-                Writer.WL($@"
-        #region {unit.SingularName}
-
-        /// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(UnitsNet.QuantityValue)"" />");
+                Writer.WL(2, $@"
+/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(UnitsNet.QuantityValue)"" />");
 
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit.ObsoleteText));
 
-                Writer.WL($@"        public static {_quantityName} {unit.PluralName}<T>(this T value) =>
-             {_quantityName}.From{unit.PluralName}(Convert.ToDouble(value));
-
-        #endregion
+                Writer.WL(2, $@"public static {_quantityName} {unit.PluralName}<T>(this T value) =>
+            {_quantityName}.From{unit.PluralName}(Convert.ToDouble(value));
 ");
             }
 
-            Writer.WL(@"
-    }
+            Writer.WL(1, @"}
 }");
             return Writer.ToString();
         }
diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs
new file mode 100644
index 0000000000..6c75a8c1e4
--- /dev/null
+++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsTestClassGenerator.cs
@@ -0,0 +1,57 @@
+using System;
+using CodeGen.JsonTypes;
+
+namespace CodeGen.Generators.UnitsNetGen
+{
+    internal class NumberExtensionsTestClassGenerator : GeneratorBase
+    {
+        private readonly Unit[] _units;
+        private readonly string _quantityName;
+
+        public NumberExtensionsTestClassGenerator(Quantity quantity)
+        {
+            if (quantity is null)
+                throw new ArgumentNullException(nameof(quantity));
+
+            _units = quantity.Units;
+            _quantityName = quantity.Name;
+        }
+
+
+        public override string Generate()
+        {
+            Writer.WL(GeneratedFileHeader);
+
+            Writer.WL(
+$@"
+using UnitsNet.NumberExtensions.NumberTo{_quantityName};
+using Xunit;
+
+namespace UnitsNet.Tests
+{{    
+    public class NumberTo{_quantityName}ExtensionsTests
+    {{");
+
+            foreach (var unit in _units)
+            {
+                Writer.WL(2, $@"
+[Fact]");
+
+                Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit.ObsoleteText));
+
+                Writer.WL(2, $@"public void NumberTo{unit.PluralName}Test() =>
+            Assert.Equal({_quantityName}.From{unit.PluralName}(2), 2.{unit.PluralName}());
+");
+            }
+
+            Writer.WL(1, @"}
+}");
+            return Writer.ToString();
+        }
+
+        private string GetObsoleteAttributeOrNull(string obsoleteText) =>
+          string.IsNullOrWhiteSpace(obsoleteText) ?
+          null :
+          $"[System.Obsolete({obsoleteText})]";
+    }
+}
diff --git a/CodeGen/Generators/UnitsNetGenerator.cs b/CodeGen/Generators/UnitsNetGenerator.cs
index a991b0aa2e..0e3ca992e3 100644
--- a/CodeGen/Generators/UnitsNetGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGenerator.cs
@@ -37,13 +37,15 @@ internal static class UnitsNetGenerator
         public static void Generate(string rootDir, Quantity[] quantities)
         {
             var outputDir = $"{rootDir}/UnitsNet/GeneratedCode";
-            var extensionsOutputDir = $"{rootDir}/UnitsNet.Extensions/GeneratedCode";
+            var extensionsOutputDir = $"{rootDir}/UnitsNet.NumberExtensions/GeneratedCode";
+            var extensionsTestOutputDir = $"{rootDir}/UnitsNet.NumberExtensions.Tests/GeneratedCode";
             var testProjectDir = $"{rootDir}/UnitsNet.Tests";
 
             // Ensure output directories exist
             Directory.CreateDirectory($"{outputDir}/Quantities");
             Directory.CreateDirectory($"{outputDir}/Units");
-            Directory.CreateDirectory($"{extensionsOutputDir}/NumberToExtensions");
+            Directory.CreateDirectory($"{extensionsOutputDir}");
+            Directory.CreateDirectory($"{extensionsTestOutputDir}");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode/TestsBase");
             Directory.CreateDirectory($"{testProjectDir}/GeneratedCode/QuantityTests");
@@ -53,7 +55,8 @@ public static void Generate(string rootDir, Quantity[] quantities)
                 var sb = new StringBuilder($"{quantity.Name}:".PadRight(AlignPad));
                 GenerateQuantity(sb, quantity, $"{outputDir}/Quantities/{quantity.Name}.g.cs");
                 GenerateUnitType(sb, quantity, $"{outputDir}/Units/{quantity.Name}Unit.g.cs");
-                GenerateNumberToExtensions(sb, quantity, $"{extensionsOutputDir}/NumberToExtensions/NumberTo{quantity.Name}Extensions.g.cs");
+                GenerateNumberToExtensions(sb, quantity, $"{extensionsOutputDir}/NumberTo{quantity.Name}Extensions.g.cs");
+                GenerateNumberToExtensionsTestClass(sb, quantity, $"{extensionsTestOutputDir}/NumberTo{quantity.Name}ExtensionsTest.g.cs");
 
                 // Example: CustomCode/Quantities/LengthTests inherits GeneratedCode/TestsBase/LengthTestsBase
                 // This way when new units are added to the quantity JSON definition, we auto-generate the new
@@ -106,6 +109,13 @@ private static void GenerateNumberToExtensions(StringBuilder sb, Quantity quanti
             sb.Append("number extensions(OK) ");
         }
 
+        private static void GenerateNumberToExtensionsTestClass(StringBuilder sb, Quantity quantity, string filePath)
+        {
+            var content = new NumberExtensionsTestClassGenerator(quantity).Generate();
+            File.WriteAllText(filePath, content, Encoding.UTF8);
+            sb.Append("number extensions tests(OK) ");
+        }
+
         private static void GenerateUnitType(StringBuilder sb, Quantity quantity, string filePath)
         {
             var content = new UnitTypeGenerator(quantity).Generate();
diff --git a/UnitsNet.Extensions.Tests/NumberToExtensions/NumberExtensionsTest.cs b/UnitsNet.Extensions.Tests/NumberToExtensions/NumberExtensionsTest.cs
deleted file mode 100644
index 1b1db5851d..0000000000
--- a/UnitsNet.Extensions.Tests/NumberToExtensions/NumberExtensionsTest.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using UnitsNet.Extensions.NumberToAngle;
-using UnitsNet.Extensions.NumberToForce;
-using UnitsNet.Extensions.NumberToLength;
-using UnitsNet.Extensions.NumberToMass;
-using Xunit;
-
-namespace UnitsNet.Tests
-{
-    public class NumberExtensionsTest
-    {
-        [Fact]
-        public void SomeArbitraryExtensionMethods_CreatesCorrectValue()
-        {
-            Assert.Equal(Length.FromMeters(1), 1.Meters());
-            Assert.Equal(Mass.FromTonnes(2), 2.Tonnes());
-            Assert.Equal(Force.FromKiloPonds(3), 3.KiloPonds());
-            Assert.Equal(Angle.FromRadians(3), 3.Radians());
-        }
-    }
-}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAccelerationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAccelerationExtensionsTest.g.cs
new file mode 100644
index 0000000000..cf949149ea
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAccelerationExtensionsTest.g.cs
@@ -0,0 +1,80 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToAcceleration;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToAccelerationExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentimetersPerSecondSquaredTest() =>
+            Assert.Equal(Acceleration.FromCentimetersPerSecondSquared(2), 2.CentimetersPerSecondSquared());
+
+        [Fact]
+        public void NumberToDecimetersPerSecondSquaredTest() =>
+            Assert.Equal(Acceleration.FromDecimetersPerSecondSquared(2), 2.DecimetersPerSecondSquared());
+
+        [Fact]
+        public void NumberToFeetPerSecondSquaredTest() =>
+            Assert.Equal(Acceleration.FromFeetPerSecondSquared(2), 2.FeetPerSecondSquared());
+
+        [Fact]
+        public void NumberToInchesPerSecondSquaredTest() =>
+            Assert.Equal(Acceleration.FromInchesPerSecondSquared(2), 2.InchesPerSecondSquared());
+
+        [Fact]
+        public void NumberToKilometersPerSecondSquaredTest() =>
+            Assert.Equal(Acceleration.FromKilometersPerSecondSquared(2), 2.KilometersPerSecondSquared());
+
+        [Fact]
+        public void NumberToKnotsPerHourTest() =>
+            Assert.Equal(Acceleration.FromKnotsPerHour(2), 2.KnotsPerHour());
+
+        [Fact]
+        public void NumberToKnotsPerMinuteTest() =>
+            Assert.Equal(Acceleration.FromKnotsPerMinute(2), 2.KnotsPerMinute());
+
+        [Fact]
+        public void NumberToKnotsPerSecondTest() =>
+            Assert.Equal(Acceleration.FromKnotsPerSecond(2), 2.KnotsPerSecond());
+
+        [Fact]
+        public void NumberToMetersPerSecondSquaredTest() =>
+            Assert.Equal(Acceleration.FromMetersPerSecondSquared(2), 2.MetersPerSecondSquared());
+
+        [Fact]
+        public void NumberToMicrometersPerSecondSquaredTest() =>
+            Assert.Equal(Acceleration.FromMicrometersPerSecondSquared(2), 2.MicrometersPerSecondSquared());
+
+        [Fact]
+        public void NumberToMillimetersPerSecondSquaredTest() =>
+            Assert.Equal(Acceleration.FromMillimetersPerSecondSquared(2), 2.MillimetersPerSecondSquared());
+
+        [Fact]
+        public void NumberToNanometersPerSecondSquaredTest() =>
+            Assert.Equal(Acceleration.FromNanometersPerSecondSquared(2), 2.NanometersPerSecondSquared());
+
+        [Fact]
+        public void NumberToStandardGravityTest() =>
+            Assert.Equal(Acceleration.FromStandardGravity(2), 2.StandardGravity());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmountOfSubstanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmountOfSubstanceExtensionsTest.g.cs
new file mode 100644
index 0000000000..7197c0edac
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmountOfSubstanceExtensionsTest.g.cs
@@ -0,0 +1,88 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToAmountOfSubstance;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToAmountOfSubstanceExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentimolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromCentimoles(2), 2.Centimoles());
+
+        [Fact]
+        public void NumberToCentipoundMolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromCentipoundMoles(2), 2.CentipoundMoles());
+
+        [Fact]
+        public void NumberToDecimolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromDecimoles(2), 2.Decimoles());
+
+        [Fact]
+        public void NumberToDecipoundMolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromDecipoundMoles(2), 2.DecipoundMoles());
+
+        [Fact]
+        public void NumberToKilomolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromKilomoles(2), 2.Kilomoles());
+
+        [Fact]
+        public void NumberToKilopoundMolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromKilopoundMoles(2), 2.KilopoundMoles());
+
+        [Fact]
+        public void NumberToMegamolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromMegamoles(2), 2.Megamoles());
+
+        [Fact]
+        public void NumberToMicromolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromMicromoles(2), 2.Micromoles());
+
+        [Fact]
+        public void NumberToMicropoundMolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromMicropoundMoles(2), 2.MicropoundMoles());
+
+        [Fact]
+        public void NumberToMillimolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromMillimoles(2), 2.Millimoles());
+
+        [Fact]
+        public void NumberToMillipoundMolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromMillipoundMoles(2), 2.MillipoundMoles());
+
+        [Fact]
+        public void NumberToMolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromMoles(2), 2.Moles());
+
+        [Fact]
+        public void NumberToNanomolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromNanomoles(2), 2.Nanomoles());
+
+        [Fact]
+        public void NumberToNanopoundMolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromNanopoundMoles(2), 2.NanopoundMoles());
+
+        [Fact]
+        public void NumberToPoundMolesTest() =>
+            Assert.Equal(AmountOfSubstance.FromPoundMoles(2), 2.PoundMoles());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmplitudeRatioExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmplitudeRatioExtensionsTest.g.cs
new file mode 100644
index 0000000000..33b41517be
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAmplitudeRatioExtensionsTest.g.cs
@@ -0,0 +1,44 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToAmplitudeRatio;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToAmplitudeRatioExtensionsTests
+    {
+        [Fact]
+        public void NumberToDecibelMicrovoltsTest() =>
+            Assert.Equal(AmplitudeRatio.FromDecibelMicrovolts(2), 2.DecibelMicrovolts());
+
+        [Fact]
+        public void NumberToDecibelMillivoltsTest() =>
+            Assert.Equal(AmplitudeRatio.FromDecibelMillivolts(2), 2.DecibelMillivolts());
+
+        [Fact]
+        public void NumberToDecibelsUnloadedTest() =>
+            Assert.Equal(AmplitudeRatio.FromDecibelsUnloaded(2), 2.DecibelsUnloaded());
+
+        [Fact]
+        public void NumberToDecibelVoltsTest() =>
+            Assert.Equal(AmplitudeRatio.FromDecibelVolts(2), 2.DecibelVolts());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAngleExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAngleExtensionsTest.g.cs
new file mode 100644
index 0000000000..9d34cc85c0
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAngleExtensionsTest.g.cs
@@ -0,0 +1,84 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToAngle;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToAngleExtensionsTests
+    {
+        [Fact]
+        public void NumberToArcminutesTest() =>
+            Assert.Equal(Angle.FromArcminutes(2), 2.Arcminutes());
+
+        [Fact]
+        public void NumberToArcsecondsTest() =>
+            Assert.Equal(Angle.FromArcseconds(2), 2.Arcseconds());
+
+        [Fact]
+        public void NumberToCentiradiansTest() =>
+            Assert.Equal(Angle.FromCentiradians(2), 2.Centiradians());
+
+        [Fact]
+        public void NumberToDeciradiansTest() =>
+            Assert.Equal(Angle.FromDeciradians(2), 2.Deciradians());
+
+        [Fact]
+        public void NumberToDegreesTest() =>
+            Assert.Equal(Angle.FromDegrees(2), 2.Degrees());
+
+        [Fact]
+        public void NumberToGradiansTest() =>
+            Assert.Equal(Angle.FromGradians(2), 2.Gradians());
+
+        [Fact]
+        public void NumberToMicrodegreesTest() =>
+            Assert.Equal(Angle.FromMicrodegrees(2), 2.Microdegrees());
+
+        [Fact]
+        public void NumberToMicroradiansTest() =>
+            Assert.Equal(Angle.FromMicroradians(2), 2.Microradians());
+
+        [Fact]
+        public void NumberToMillidegreesTest() =>
+            Assert.Equal(Angle.FromMillidegrees(2), 2.Millidegrees());
+
+        [Fact]
+        public void NumberToMilliradiansTest() =>
+            Assert.Equal(Angle.FromMilliradians(2), 2.Milliradians());
+
+        [Fact]
+        public void NumberToNanodegreesTest() =>
+            Assert.Equal(Angle.FromNanodegrees(2), 2.Nanodegrees());
+
+        [Fact]
+        public void NumberToNanoradiansTest() =>
+            Assert.Equal(Angle.FromNanoradians(2), 2.Nanoradians());
+
+        [Fact]
+        public void NumberToRadiansTest() =>
+            Assert.Equal(Angle.FromRadians(2), 2.Radians());
+
+        [Fact]
+        public void NumberToRevolutionsTest() =>
+            Assert.Equal(Angle.FromRevolutions(2), 2.Revolutions());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentEnergyExtensionsTest.g.cs
new file mode 100644
index 0000000000..218daac837
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentEnergyExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToApparentEnergy;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToApparentEnergyExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilovoltampereHoursTest() =>
+            Assert.Equal(ApparentEnergy.FromKilovoltampereHours(2), 2.KilovoltampereHours());
+
+        [Fact]
+        public void NumberToMegavoltampereHoursTest() =>
+            Assert.Equal(ApparentEnergy.FromMegavoltampereHours(2), 2.MegavoltampereHours());
+
+        [Fact]
+        public void NumberToVoltampereHoursTest() =>
+            Assert.Equal(ApparentEnergy.FromVoltampereHours(2), 2.VoltampereHours());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentPowerExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentPowerExtensionsTest.g.cs
new file mode 100644
index 0000000000..c7855d37da
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToApparentPowerExtensionsTest.g.cs
@@ -0,0 +1,44 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToApparentPower;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToApparentPowerExtensionsTests
+    {
+        [Fact]
+        public void NumberToGigavoltamperesTest() =>
+            Assert.Equal(ApparentPower.FromGigavoltamperes(2), 2.Gigavoltamperes());
+
+        [Fact]
+        public void NumberToKilovoltamperesTest() =>
+            Assert.Equal(ApparentPower.FromKilovoltamperes(2), 2.Kilovoltamperes());
+
+        [Fact]
+        public void NumberToMegavoltamperesTest() =>
+            Assert.Equal(ApparentPower.FromMegavoltamperes(2), 2.Megavoltamperes());
+
+        [Fact]
+        public void NumberToVoltamperesTest() =>
+            Assert.Equal(ApparentPower.FromVoltamperes(2), 2.Voltamperes());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
new file mode 100644
index 0000000000..e5f721ddc0
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaDensityExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToAreaDensity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToAreaDensityExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilogramsPerSquareMeterTest() =>
+            Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(2), 2.KilogramsPerSquareMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaExtensionsTest.g.cs
new file mode 100644
index 0000000000..4f35ec9d41
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaExtensionsTest.g.cs
@@ -0,0 +1,84 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToArea;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToAreaExtensionsTests
+    {
+        [Fact]
+        public void NumberToAcresTest() =>
+            Assert.Equal(Area.FromAcres(2), 2.Acres());
+
+        [Fact]
+        public void NumberToHectaresTest() =>
+            Assert.Equal(Area.FromHectares(2), 2.Hectares());
+
+        [Fact]
+        public void NumberToSquareCentimetersTest() =>
+            Assert.Equal(Area.FromSquareCentimeters(2), 2.SquareCentimeters());
+
+        [Fact]
+        public void NumberToSquareDecimetersTest() =>
+            Assert.Equal(Area.FromSquareDecimeters(2), 2.SquareDecimeters());
+
+        [Fact]
+        public void NumberToSquareFeetTest() =>
+            Assert.Equal(Area.FromSquareFeet(2), 2.SquareFeet());
+
+        [Fact]
+        public void NumberToSquareInchesTest() =>
+            Assert.Equal(Area.FromSquareInches(2), 2.SquareInches());
+
+        [Fact]
+        public void NumberToSquareKilometersTest() =>
+            Assert.Equal(Area.FromSquareKilometers(2), 2.SquareKilometers());
+
+        [Fact]
+        public void NumberToSquareMetersTest() =>
+            Assert.Equal(Area.FromSquareMeters(2), 2.SquareMeters());
+
+        [Fact]
+        public void NumberToSquareMicrometersTest() =>
+            Assert.Equal(Area.FromSquareMicrometers(2), 2.SquareMicrometers());
+
+        [Fact]
+        public void NumberToSquareMilesTest() =>
+            Assert.Equal(Area.FromSquareMiles(2), 2.SquareMiles());
+
+        [Fact]
+        public void NumberToSquareMillimetersTest() =>
+            Assert.Equal(Area.FromSquareMillimeters(2), 2.SquareMillimeters());
+
+        [Fact]
+        public void NumberToSquareNauticalMilesTest() =>
+            Assert.Equal(Area.FromSquareNauticalMiles(2), 2.SquareNauticalMiles());
+
+        [Fact]
+        public void NumberToSquareYardsTest() =>
+            Assert.Equal(Area.FromSquareYards(2), 2.SquareYards());
+
+        [Fact]
+        public void NumberToUsSurveySquareFeetTest() =>
+            Assert.Equal(Area.FromUsSurveySquareFeet(2), 2.UsSurveySquareFeet());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaMomentOfInertiaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaMomentOfInertiaExtensionsTest.g.cs
new file mode 100644
index 0000000000..217dc33c30
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToAreaMomentOfInertiaExtensionsTest.g.cs
@@ -0,0 +1,52 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToAreaMomentOfInertia;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToAreaMomentOfInertiaExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentimetersToTheFourthTest() =>
+            Assert.Equal(AreaMomentOfInertia.FromCentimetersToTheFourth(2), 2.CentimetersToTheFourth());
+
+        [Fact]
+        public void NumberToDecimetersToTheFourthTest() =>
+            Assert.Equal(AreaMomentOfInertia.FromDecimetersToTheFourth(2), 2.DecimetersToTheFourth());
+
+        [Fact]
+        public void NumberToFeetToTheFourthTest() =>
+            Assert.Equal(AreaMomentOfInertia.FromFeetToTheFourth(2), 2.FeetToTheFourth());
+
+        [Fact]
+        public void NumberToInchesToTheFourthTest() =>
+            Assert.Equal(AreaMomentOfInertia.FromInchesToTheFourth(2), 2.InchesToTheFourth());
+
+        [Fact]
+        public void NumberToMetersToTheFourthTest() =>
+            Assert.Equal(AreaMomentOfInertia.FromMetersToTheFourth(2), 2.MetersToTheFourth());
+
+        [Fact]
+        public void NumberToMillimetersToTheFourthTest() =>
+            Assert.Equal(AreaMomentOfInertia.FromMillimetersToTheFourth(2), 2.MillimetersToTheFourth());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs
new file mode 100644
index 0000000000..46afbcae68
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBitRateExtensionsTest.g.cs
@@ -0,0 +1,132 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToBitRate;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToBitRateExtensionsTests
+    {
+        [Fact]
+        public void NumberToBitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromBitsPerSecond(2), 2.BitsPerSecond());
+
+        [Fact]
+        public void NumberToBytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromBytesPerSecond(2), 2.BytesPerSecond());
+
+        [Fact]
+        public void NumberToExabitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromExabitsPerSecond(2), 2.ExabitsPerSecond());
+
+        [Fact]
+        public void NumberToExabytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromExabytesPerSecond(2), 2.ExabytesPerSecond());
+
+        [Fact]
+        public void NumberToExbibitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromExbibitsPerSecond(2), 2.ExbibitsPerSecond());
+
+        [Fact]
+        public void NumberToExbibytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromExbibytesPerSecond(2), 2.ExbibytesPerSecond());
+
+        [Fact]
+        public void NumberToGibibitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromGibibitsPerSecond(2), 2.GibibitsPerSecond());
+
+        [Fact]
+        public void NumberToGibibytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromGibibytesPerSecond(2), 2.GibibytesPerSecond());
+
+        [Fact]
+        public void NumberToGigabitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromGigabitsPerSecond(2), 2.GigabitsPerSecond());
+
+        [Fact]
+        public void NumberToGigabytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromGigabytesPerSecond(2), 2.GigabytesPerSecond());
+
+        [Fact]
+        public void NumberToKibibitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromKibibitsPerSecond(2), 2.KibibitsPerSecond());
+
+        [Fact]
+        public void NumberToKibibytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromKibibytesPerSecond(2), 2.KibibytesPerSecond());
+
+        [Fact]
+        public void NumberToKilobitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromKilobitsPerSecond(2), 2.KilobitsPerSecond());
+
+        [Fact]
+        public void NumberToKilobytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromKilobytesPerSecond(2), 2.KilobytesPerSecond());
+
+        [Fact]
+        public void NumberToMebibitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromMebibitsPerSecond(2), 2.MebibitsPerSecond());
+
+        [Fact]
+        public void NumberToMebibytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromMebibytesPerSecond(2), 2.MebibytesPerSecond());
+
+        [Fact]
+        public void NumberToMegabitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromMegabitsPerSecond(2), 2.MegabitsPerSecond());
+
+        [Fact]
+        public void NumberToMegabytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromMegabytesPerSecond(2), 2.MegabytesPerSecond());
+
+        [Fact]
+        public void NumberToPebibitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromPebibitsPerSecond(2), 2.PebibitsPerSecond());
+
+        [Fact]
+        public void NumberToPebibytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromPebibytesPerSecond(2), 2.PebibytesPerSecond());
+
+        [Fact]
+        public void NumberToPetabitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromPetabitsPerSecond(2), 2.PetabitsPerSecond());
+
+        [Fact]
+        public void NumberToPetabytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromPetabytesPerSecond(2), 2.PetabytesPerSecond());
+
+        [Fact]
+        public void NumberToTebibitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromTebibitsPerSecond(2), 2.TebibitsPerSecond());
+
+        [Fact]
+        public void NumberToTebibytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromTebibytesPerSecond(2), 2.TebibytesPerSecond());
+
+        [Fact]
+        public void NumberToTerabitsPerSecondTest() =>
+            Assert.Equal(BitRate.FromTerabitsPerSecond(2), 2.TerabitsPerSecond());
+
+        [Fact]
+        public void NumberToTerabytesPerSecondTest() =>
+            Assert.Equal(BitRate.FromTerabytesPerSecond(2), 2.TerabytesPerSecond());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensionsTest.g.cs
new file mode 100644
index 0000000000..3d229d9f32
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToBrakeSpecificFuelConsumption;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToBrakeSpecificFuelConsumptionExtensionsTests
+    {
+        [Fact]
+        public void NumberToGramsPerKiloWattHourTest() =>
+            Assert.Equal(BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(2), 2.GramsPerKiloWattHour());
+
+        [Fact]
+        public void NumberToKilogramsPerJouleTest() =>
+            Assert.Equal(BrakeSpecificFuelConsumption.FromKilogramsPerJoule(2), 2.KilogramsPerJoule());
+
+        [Fact]
+        public void NumberToPoundsPerMechanicalHorsepowerHourTest() =>
+            Assert.Equal(BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(2), 2.PoundsPerMechanicalHorsepowerHour());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCapacitanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCapacitanceExtensionsTest.g.cs
new file mode 100644
index 0000000000..5fb028ebfd
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCapacitanceExtensionsTest.g.cs
@@ -0,0 +1,56 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToCapacitance;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToCapacitanceExtensionsTests
+    {
+        [Fact]
+        public void NumberToFaradsTest() =>
+            Assert.Equal(Capacitance.FromFarads(2), 2.Farads());
+
+        [Fact]
+        public void NumberToKilofaradsTest() =>
+            Assert.Equal(Capacitance.FromKilofarads(2), 2.Kilofarads());
+
+        [Fact]
+        public void NumberToMegafaradsTest() =>
+            Assert.Equal(Capacitance.FromMegafarads(2), 2.Megafarads());
+
+        [Fact]
+        public void NumberToMicrofaradsTest() =>
+            Assert.Equal(Capacitance.FromMicrofarads(2), 2.Microfarads());
+
+        [Fact]
+        public void NumberToMillifaradsTest() =>
+            Assert.Equal(Capacitance.FromMillifarads(2), 2.Millifarads());
+
+        [Fact]
+        public void NumberToNanofaradsTest() =>
+            Assert.Equal(Capacitance.FromNanofarads(2), 2.Nanofarads());
+
+        [Fact]
+        public void NumberToPicofaradsTest() =>
+            Assert.Equal(Capacitance.FromPicofarads(2), 2.Picofarads());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensionsTest.g.cs
new file mode 100644
index 0000000000..fa1a8d2a47
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToCoefficientOfThermalExpansion;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToCoefficientOfThermalExpansionExtensionsTests
+    {
+        [Fact]
+        public void NumberToInverseDegreeCelsiusTest() =>
+            Assert.Equal(CoefficientOfThermalExpansion.FromInverseDegreeCelsius(2), 2.InverseDegreeCelsius());
+
+        [Fact]
+        public void NumberToInverseDegreeFahrenheitTest() =>
+            Assert.Equal(CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(2), 2.InverseDegreeFahrenheit());
+
+        [Fact]
+        public void NumberToInverseKelvinTest() =>
+            Assert.Equal(CoefficientOfThermalExpansion.FromInverseKelvin(2), 2.InverseKelvin());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs
new file mode 100644
index 0000000000..59f917e45e
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDensityExtensionsTest.g.cs
@@ -0,0 +1,188 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToDensity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToDensityExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentigramsPerDeciLiterTest() =>
+            Assert.Equal(Density.FromCentigramsPerDeciLiter(2), 2.CentigramsPerDeciLiter());
+
+        [Fact]
+        public void NumberToCentigramsPerLiterTest() =>
+            Assert.Equal(Density.FromCentigramsPerLiter(2), 2.CentigramsPerLiter());
+
+        [Fact]
+        public void NumberToCentigramsPerMilliliterTest() =>
+            Assert.Equal(Density.FromCentigramsPerMilliliter(2), 2.CentigramsPerMilliliter());
+
+        [Fact]
+        public void NumberToDecigramsPerDeciLiterTest() =>
+            Assert.Equal(Density.FromDecigramsPerDeciLiter(2), 2.DecigramsPerDeciLiter());
+
+        [Fact]
+        public void NumberToDecigramsPerLiterTest() =>
+            Assert.Equal(Density.FromDecigramsPerLiter(2), 2.DecigramsPerLiter());
+
+        [Fact]
+        public void NumberToDecigramsPerMilliliterTest() =>
+            Assert.Equal(Density.FromDecigramsPerMilliliter(2), 2.DecigramsPerMilliliter());
+
+        [Fact]
+        public void NumberToGramsPerCubicCentimeterTest() =>
+            Assert.Equal(Density.FromGramsPerCubicCentimeter(2), 2.GramsPerCubicCentimeter());
+
+        [Fact]
+        public void NumberToGramsPerCubicMeterTest() =>
+            Assert.Equal(Density.FromGramsPerCubicMeter(2), 2.GramsPerCubicMeter());
+
+        [Fact]
+        public void NumberToGramsPerCubicMillimeterTest() =>
+            Assert.Equal(Density.FromGramsPerCubicMillimeter(2), 2.GramsPerCubicMillimeter());
+
+        [Fact]
+        public void NumberToGramsPerDeciLiterTest() =>
+            Assert.Equal(Density.FromGramsPerDeciLiter(2), 2.GramsPerDeciLiter());
+
+        [Fact]
+        public void NumberToGramsPerLiterTest() =>
+            Assert.Equal(Density.FromGramsPerLiter(2), 2.GramsPerLiter());
+
+        [Fact]
+        public void NumberToGramsPerMilliliterTest() =>
+            Assert.Equal(Density.FromGramsPerMilliliter(2), 2.GramsPerMilliliter());
+
+        [Fact]
+        public void NumberToKilogramsPerCubicCentimeterTest() =>
+            Assert.Equal(Density.FromKilogramsPerCubicCentimeter(2), 2.KilogramsPerCubicCentimeter());
+
+        [Fact]
+        public void NumberToKilogramsPerCubicMeterTest() =>
+            Assert.Equal(Density.FromKilogramsPerCubicMeter(2), 2.KilogramsPerCubicMeter());
+
+        [Fact]
+        public void NumberToKilogramsPerCubicMillimeterTest() =>
+            Assert.Equal(Density.FromKilogramsPerCubicMillimeter(2), 2.KilogramsPerCubicMillimeter());
+
+        [Fact]
+        public void NumberToKilogramsPerLiterTest() =>
+            Assert.Equal(Density.FromKilogramsPerLiter(2), 2.KilogramsPerLiter());
+
+        [Fact]
+        public void NumberToKilopoundsPerCubicFootTest() =>
+            Assert.Equal(Density.FromKilopoundsPerCubicFoot(2), 2.KilopoundsPerCubicFoot());
+
+        [Fact]
+        public void NumberToKilopoundsPerCubicInchTest() =>
+            Assert.Equal(Density.FromKilopoundsPerCubicInch(2), 2.KilopoundsPerCubicInch());
+
+        [Fact]
+        public void NumberToMicrogramsPerCubicMeterTest() =>
+            Assert.Equal(Density.FromMicrogramsPerCubicMeter(2), 2.MicrogramsPerCubicMeter());
+
+        [Fact]
+        public void NumberToMicrogramsPerDeciLiterTest() =>
+            Assert.Equal(Density.FromMicrogramsPerDeciLiter(2), 2.MicrogramsPerDeciLiter());
+
+        [Fact]
+        public void NumberToMicrogramsPerLiterTest() =>
+            Assert.Equal(Density.FromMicrogramsPerLiter(2), 2.MicrogramsPerLiter());
+
+        [Fact]
+        public void NumberToMicrogramsPerMilliliterTest() =>
+            Assert.Equal(Density.FromMicrogramsPerMilliliter(2), 2.MicrogramsPerMilliliter());
+
+        [Fact]
+        public void NumberToMilligramsPerCubicMeterTest() =>
+            Assert.Equal(Density.FromMilligramsPerCubicMeter(2), 2.MilligramsPerCubicMeter());
+
+        [Fact]
+        public void NumberToMilligramsPerDeciLiterTest() =>
+            Assert.Equal(Density.FromMilligramsPerDeciLiter(2), 2.MilligramsPerDeciLiter());
+
+        [Fact]
+        public void NumberToMilligramsPerLiterTest() =>
+            Assert.Equal(Density.FromMilligramsPerLiter(2), 2.MilligramsPerLiter());
+
+        [Fact]
+        public void NumberToMilligramsPerMilliliterTest() =>
+            Assert.Equal(Density.FromMilligramsPerMilliliter(2), 2.MilligramsPerMilliliter());
+
+        [Fact]
+        public void NumberToNanogramsPerDeciLiterTest() =>
+            Assert.Equal(Density.FromNanogramsPerDeciLiter(2), 2.NanogramsPerDeciLiter());
+
+        [Fact]
+        public void NumberToNanogramsPerLiterTest() =>
+            Assert.Equal(Density.FromNanogramsPerLiter(2), 2.NanogramsPerLiter());
+
+        [Fact]
+        public void NumberToNanogramsPerMilliliterTest() =>
+            Assert.Equal(Density.FromNanogramsPerMilliliter(2), 2.NanogramsPerMilliliter());
+
+        [Fact]
+        public void NumberToPicogramsPerDeciLiterTest() =>
+            Assert.Equal(Density.FromPicogramsPerDeciLiter(2), 2.PicogramsPerDeciLiter());
+
+        [Fact]
+        public void NumberToPicogramsPerLiterTest() =>
+            Assert.Equal(Density.FromPicogramsPerLiter(2), 2.PicogramsPerLiter());
+
+        [Fact]
+        public void NumberToPicogramsPerMilliliterTest() =>
+            Assert.Equal(Density.FromPicogramsPerMilliliter(2), 2.PicogramsPerMilliliter());
+
+        [Fact]
+        public void NumberToPoundsPerCubicFootTest() =>
+            Assert.Equal(Density.FromPoundsPerCubicFoot(2), 2.PoundsPerCubicFoot());
+
+        [Fact]
+        public void NumberToPoundsPerCubicInchTest() =>
+            Assert.Equal(Density.FromPoundsPerCubicInch(2), 2.PoundsPerCubicInch());
+
+        [Fact]
+        public void NumberToPoundsPerImperialGallonTest() =>
+            Assert.Equal(Density.FromPoundsPerImperialGallon(2), 2.PoundsPerImperialGallon());
+
+        [Fact]
+        public void NumberToPoundsPerUSGallonTest() =>
+            Assert.Equal(Density.FromPoundsPerUSGallon(2), 2.PoundsPerUSGallon());
+
+        [Fact]
+        public void NumberToSlugsPerCubicFootTest() =>
+            Assert.Equal(Density.FromSlugsPerCubicFoot(2), 2.SlugsPerCubicFoot());
+
+        [Fact]
+        public void NumberToTonnesPerCubicCentimeterTest() =>
+            Assert.Equal(Density.FromTonnesPerCubicCentimeter(2), 2.TonnesPerCubicCentimeter());
+
+        [Fact]
+        public void NumberToTonnesPerCubicMeterTest() =>
+            Assert.Equal(Density.FromTonnesPerCubicMeter(2), 2.TonnesPerCubicMeter());
+
+        [Fact]
+        public void NumberToTonnesPerCubicMillimeterTest() =>
+            Assert.Equal(Density.FromTonnesPerCubicMillimeter(2), 2.TonnesPerCubicMillimeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDurationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDurationExtensionsTest.g.cs
new file mode 100644
index 0000000000..93fc192f86
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDurationExtensionsTest.g.cs
@@ -0,0 +1,68 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToDuration;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToDurationExtensionsTests
+    {
+        [Fact]
+        public void NumberToDaysTest() =>
+            Assert.Equal(Duration.FromDays(2), 2.Days());
+
+        [Fact]
+        public void NumberToHoursTest() =>
+            Assert.Equal(Duration.FromHours(2), 2.Hours());
+
+        [Fact]
+        public void NumberToMicrosecondsTest() =>
+            Assert.Equal(Duration.FromMicroseconds(2), 2.Microseconds());
+
+        [Fact]
+        public void NumberToMillisecondsTest() =>
+            Assert.Equal(Duration.FromMilliseconds(2), 2.Milliseconds());
+
+        [Fact]
+        public void NumberToMinutesTest() =>
+            Assert.Equal(Duration.FromMinutes(2), 2.Minutes());
+
+        [Fact]
+        public void NumberToMonths30Test() =>
+            Assert.Equal(Duration.FromMonths30(2), 2.Months30());
+
+        [Fact]
+        public void NumberToNanosecondsTest() =>
+            Assert.Equal(Duration.FromNanoseconds(2), 2.Nanoseconds());
+
+        [Fact]
+        public void NumberToSecondsTest() =>
+            Assert.Equal(Duration.FromSeconds(2), 2.Seconds());
+
+        [Fact]
+        public void NumberToWeeksTest() =>
+            Assert.Equal(Duration.FromWeeks(2), 2.Weeks());
+
+        [Fact]
+        public void NumberToYears365Test() =>
+            Assert.Equal(Duration.FromYears365(2), 2.Years365());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDynamicViscosityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDynamicViscosityExtensionsTest.g.cs
new file mode 100644
index 0000000000..765adaa8db
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToDynamicViscosityExtensionsTest.g.cs
@@ -0,0 +1,64 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToDynamicViscosity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToDynamicViscosityExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentipoiseTest() =>
+            Assert.Equal(DynamicViscosity.FromCentipoise(2), 2.Centipoise());
+
+        [Fact]
+        public void NumberToMicropascalSecondsTest() =>
+            Assert.Equal(DynamicViscosity.FromMicropascalSeconds(2), 2.MicropascalSeconds());
+
+        [Fact]
+        public void NumberToMillipascalSecondsTest() =>
+            Assert.Equal(DynamicViscosity.FromMillipascalSeconds(2), 2.MillipascalSeconds());
+
+        [Fact]
+        public void NumberToNewtonSecondsPerMeterSquaredTest() =>
+            Assert.Equal(DynamicViscosity.FromNewtonSecondsPerMeterSquared(2), 2.NewtonSecondsPerMeterSquared());
+
+        [Fact]
+        public void NumberToPascalSecondsTest() =>
+            Assert.Equal(DynamicViscosity.FromPascalSeconds(2), 2.PascalSeconds());
+
+        [Fact]
+        public void NumberToPoiseTest() =>
+            Assert.Equal(DynamicViscosity.FromPoise(2), 2.Poise());
+
+        [Fact]
+        public void NumberToPoundsForceSecondPerSquareFootTest() =>
+            Assert.Equal(DynamicViscosity.FromPoundsForceSecondPerSquareFoot(2), 2.PoundsForceSecondPerSquareFoot());
+
+        [Fact]
+        public void NumberToPoundsForceSecondPerSquareInchTest() =>
+            Assert.Equal(DynamicViscosity.FromPoundsForceSecondPerSquareInch(2), 2.PoundsForceSecondPerSquareInch());
+
+        [Fact]
+        public void NumberToReynsTest() =>
+            Assert.Equal(DynamicViscosity.FromReyns(2), 2.Reyns());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricAdmittanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricAdmittanceExtensionsTest.g.cs
new file mode 100644
index 0000000000..92e38cf4a3
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricAdmittanceExtensionsTest.g.cs
@@ -0,0 +1,44 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricAdmittance;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricAdmittanceExtensionsTests
+    {
+        [Fact]
+        public void NumberToMicrosiemensTest() =>
+            Assert.Equal(ElectricAdmittance.FromMicrosiemens(2), 2.Microsiemens());
+
+        [Fact]
+        public void NumberToMillisiemensTest() =>
+            Assert.Equal(ElectricAdmittance.FromMillisiemens(2), 2.Millisiemens());
+
+        [Fact]
+        public void NumberToNanosiemensTest() =>
+            Assert.Equal(ElectricAdmittance.FromNanosiemens(2), 2.Nanosiemens());
+
+        [Fact]
+        public void NumberToSiemensTest() =>
+            Assert.Equal(ElectricAdmittance.FromSiemens(2), 2.Siemens());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeDensityExtensionsTest.g.cs
new file mode 100644
index 0000000000..e947ba90e4
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeDensityExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricChargeDensity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricChargeDensityExtensionsTests
+    {
+        [Fact]
+        public void NumberToCoulombsPerCubicMeterTest() =>
+            Assert.Equal(ElectricChargeDensity.FromCoulombsPerCubicMeter(2), 2.CoulombsPerCubicMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeExtensionsTest.g.cs
new file mode 100644
index 0000000000..2e2de22eb3
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricChargeExtensionsTest.g.cs
@@ -0,0 +1,48 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricCharge;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricChargeExtensionsTests
+    {
+        [Fact]
+        public void NumberToAmpereHoursTest() =>
+            Assert.Equal(ElectricCharge.FromAmpereHours(2), 2.AmpereHours());
+
+        [Fact]
+        public void NumberToCoulombsTest() =>
+            Assert.Equal(ElectricCharge.FromCoulombs(2), 2.Coulombs());
+
+        [Fact]
+        public void NumberToKiloampereHoursTest() =>
+            Assert.Equal(ElectricCharge.FromKiloampereHours(2), 2.KiloampereHours());
+
+        [Fact]
+        public void NumberToMegaampereHoursTest() =>
+            Assert.Equal(ElectricCharge.FromMegaampereHours(2), 2.MegaampereHours());
+
+        [Fact]
+        public void NumberToMilliampereHoursTest() =>
+            Assert.Equal(ElectricCharge.FromMilliampereHours(2), 2.MilliampereHours());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductanceExtensionsTest.g.cs
new file mode 100644
index 0000000000..e6640aa1d5
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductanceExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricConductance;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricConductanceExtensionsTests
+    {
+        [Fact]
+        public void NumberToMicrosiemensTest() =>
+            Assert.Equal(ElectricConductance.FromMicrosiemens(2), 2.Microsiemens());
+
+        [Fact]
+        public void NumberToMillisiemensTest() =>
+            Assert.Equal(ElectricConductance.FromMillisiemens(2), 2.Millisiemens());
+
+        [Fact]
+        public void NumberToSiemensTest() =>
+            Assert.Equal(ElectricConductance.FromSiemens(2), 2.Siemens());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductivityExtensionsTest.g.cs
new file mode 100644
index 0000000000..7abe9c5bbe
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricConductivityExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricConductivity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricConductivityExtensionsTests
+    {
+        [Fact]
+        public void NumberToSiemensPerFootTest() =>
+            Assert.Equal(ElectricConductivity.FromSiemensPerFoot(2), 2.SiemensPerFoot());
+
+        [Fact]
+        public void NumberToSiemensPerInchTest() =>
+            Assert.Equal(ElectricConductivity.FromSiemensPerInch(2), 2.SiemensPerInch());
+
+        [Fact]
+        public void NumberToSiemensPerMeterTest() =>
+            Assert.Equal(ElectricConductivity.FromSiemensPerMeter(2), 2.SiemensPerMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentDensityExtensionsTest.g.cs
new file mode 100644
index 0000000000..d07398f18c
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentDensityExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricCurrentDensity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricCurrentDensityExtensionsTests
+    {
+        [Fact]
+        public void NumberToAmperesPerSquareFootTest() =>
+            Assert.Equal(ElectricCurrentDensity.FromAmperesPerSquareFoot(2), 2.AmperesPerSquareFoot());
+
+        [Fact]
+        public void NumberToAmperesPerSquareInchTest() =>
+            Assert.Equal(ElectricCurrentDensity.FromAmperesPerSquareInch(2), 2.AmperesPerSquareInch());
+
+        [Fact]
+        public void NumberToAmperesPerSquareMeterTest() =>
+            Assert.Equal(ElectricCurrentDensity.FromAmperesPerSquareMeter(2), 2.AmperesPerSquareMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentExtensionsTest.g.cs
new file mode 100644
index 0000000000..a8e9233ca1
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentExtensionsTest.g.cs
@@ -0,0 +1,60 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricCurrent;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricCurrentExtensionsTests
+    {
+        [Fact]
+        public void NumberToAmperesTest() =>
+            Assert.Equal(ElectricCurrent.FromAmperes(2), 2.Amperes());
+
+        [Fact]
+        public void NumberToCentiamperesTest() =>
+            Assert.Equal(ElectricCurrent.FromCentiamperes(2), 2.Centiamperes());
+
+        [Fact]
+        public void NumberToKiloamperesTest() =>
+            Assert.Equal(ElectricCurrent.FromKiloamperes(2), 2.Kiloamperes());
+
+        [Fact]
+        public void NumberToMegaamperesTest() =>
+            Assert.Equal(ElectricCurrent.FromMegaamperes(2), 2.Megaamperes());
+
+        [Fact]
+        public void NumberToMicroamperesTest() =>
+            Assert.Equal(ElectricCurrent.FromMicroamperes(2), 2.Microamperes());
+
+        [Fact]
+        public void NumberToMilliamperesTest() =>
+            Assert.Equal(ElectricCurrent.FromMilliamperes(2), 2.Milliamperes());
+
+        [Fact]
+        public void NumberToNanoamperesTest() =>
+            Assert.Equal(ElectricCurrent.FromNanoamperes(2), 2.Nanoamperes());
+
+        [Fact]
+        public void NumberToPicoamperesTest() =>
+            Assert.Equal(ElectricCurrent.FromPicoamperes(2), 2.Picoamperes());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs
new file mode 100644
index 0000000000..aa940b7e5b
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricCurrentGradientExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricCurrentGradient;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricCurrentGradientExtensionsTests
+    {
+        [Fact]
+        public void NumberToAmperesPerSecondTest() =>
+            Assert.Equal(ElectricCurrentGradient.FromAmperesPerSecond(2), 2.AmperesPerSecond());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricFieldExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricFieldExtensionsTest.g.cs
new file mode 100644
index 0000000000..633c0ad865
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricFieldExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricField;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricFieldExtensionsTests
+    {
+        [Fact]
+        public void NumberToVoltsPerMeterTest() =>
+            Assert.Equal(ElectricField.FromVoltsPerMeter(2), 2.VoltsPerMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricInductanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricInductanceExtensionsTest.g.cs
new file mode 100644
index 0000000000..59869a90f2
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricInductanceExtensionsTest.g.cs
@@ -0,0 +1,44 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricInductance;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricInductanceExtensionsTests
+    {
+        [Fact]
+        public void NumberToHenriesTest() =>
+            Assert.Equal(ElectricInductance.FromHenries(2), 2.Henries());
+
+        [Fact]
+        public void NumberToMicrohenriesTest() =>
+            Assert.Equal(ElectricInductance.FromMicrohenries(2), 2.Microhenries());
+
+        [Fact]
+        public void NumberToMillihenriesTest() =>
+            Assert.Equal(ElectricInductance.FromMillihenries(2), 2.Millihenries());
+
+        [Fact]
+        public void NumberToNanohenriesTest() =>
+            Assert.Equal(ElectricInductance.FromNanohenries(2), 2.Nanohenries());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialAcExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialAcExtensionsTest.g.cs
new file mode 100644
index 0000000000..54337c2287
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialAcExtensionsTest.g.cs
@@ -0,0 +1,48 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricPotentialAc;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricPotentialAcExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilovoltsAcTest() =>
+            Assert.Equal(ElectricPotentialAc.FromKilovoltsAc(2), 2.KilovoltsAc());
+
+        [Fact]
+        public void NumberToMegavoltsAcTest() =>
+            Assert.Equal(ElectricPotentialAc.FromMegavoltsAc(2), 2.MegavoltsAc());
+
+        [Fact]
+        public void NumberToMicrovoltsAcTest() =>
+            Assert.Equal(ElectricPotentialAc.FromMicrovoltsAc(2), 2.MicrovoltsAc());
+
+        [Fact]
+        public void NumberToMillivoltsAcTest() =>
+            Assert.Equal(ElectricPotentialAc.FromMillivoltsAc(2), 2.MillivoltsAc());
+
+        [Fact]
+        public void NumberToVoltsAcTest() =>
+            Assert.Equal(ElectricPotentialAc.FromVoltsAc(2), 2.VoltsAc());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialDcExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialDcExtensionsTest.g.cs
new file mode 100644
index 0000000000..2c058240c3
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialDcExtensionsTest.g.cs
@@ -0,0 +1,48 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricPotentialDc;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricPotentialDcExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilovoltsDcTest() =>
+            Assert.Equal(ElectricPotentialDc.FromKilovoltsDc(2), 2.KilovoltsDc());
+
+        [Fact]
+        public void NumberToMegavoltsDcTest() =>
+            Assert.Equal(ElectricPotentialDc.FromMegavoltsDc(2), 2.MegavoltsDc());
+
+        [Fact]
+        public void NumberToMicrovoltsDcTest() =>
+            Assert.Equal(ElectricPotentialDc.FromMicrovoltsDc(2), 2.MicrovoltsDc());
+
+        [Fact]
+        public void NumberToMillivoltsDcTest() =>
+            Assert.Equal(ElectricPotentialDc.FromMillivoltsDc(2), 2.MillivoltsDc());
+
+        [Fact]
+        public void NumberToVoltsDcTest() =>
+            Assert.Equal(ElectricPotentialDc.FromVoltsDc(2), 2.VoltsDc());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialExtensionsTest.g.cs
new file mode 100644
index 0000000000..799c7ae5bc
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricPotentialExtensionsTest.g.cs
@@ -0,0 +1,48 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricPotential;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricPotentialExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilovoltsTest() =>
+            Assert.Equal(ElectricPotential.FromKilovolts(2), 2.Kilovolts());
+
+        [Fact]
+        public void NumberToMegavoltsTest() =>
+            Assert.Equal(ElectricPotential.FromMegavolts(2), 2.Megavolts());
+
+        [Fact]
+        public void NumberToMicrovoltsTest() =>
+            Assert.Equal(ElectricPotential.FromMicrovolts(2), 2.Microvolts());
+
+        [Fact]
+        public void NumberToMillivoltsTest() =>
+            Assert.Equal(ElectricPotential.FromMillivolts(2), 2.Millivolts());
+
+        [Fact]
+        public void NumberToVoltsTest() =>
+            Assert.Equal(ElectricPotential.FromVolts(2), 2.Volts());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistanceExtensionsTest.g.cs
new file mode 100644
index 0000000000..f0f1f50091
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistanceExtensionsTest.g.cs
@@ -0,0 +1,48 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricResistance;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricResistanceExtensionsTests
+    {
+        [Fact]
+        public void NumberToGigaohmsTest() =>
+            Assert.Equal(ElectricResistance.FromGigaohms(2), 2.Gigaohms());
+
+        [Fact]
+        public void NumberToKiloohmsTest() =>
+            Assert.Equal(ElectricResistance.FromKiloohms(2), 2.Kiloohms());
+
+        [Fact]
+        public void NumberToMegaohmsTest() =>
+            Assert.Equal(ElectricResistance.FromMegaohms(2), 2.Megaohms());
+
+        [Fact]
+        public void NumberToMilliohmsTest() =>
+            Assert.Equal(ElectricResistance.FromMilliohms(2), 2.Milliohms());
+
+        [Fact]
+        public void NumberToOhmsTest() =>
+            Assert.Equal(ElectricResistance.FromOhms(2), 2.Ohms());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistivityExtensionsTest.g.cs
new file mode 100644
index 0000000000..6a50c427e4
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricResistivityExtensionsTest.g.cs
@@ -0,0 +1,84 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricResistivity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricResistivityExtensionsTests
+    {
+        [Fact]
+        public void NumberToKiloohmsCentimeterTest() =>
+            Assert.Equal(ElectricResistivity.FromKiloohmsCentimeter(2), 2.KiloohmsCentimeter());
+
+        [Fact]
+        public void NumberToKiloohmMetersTest() =>
+            Assert.Equal(ElectricResistivity.FromKiloohmMeters(2), 2.KiloohmMeters());
+
+        [Fact]
+        public void NumberToMegaohmsCentimeterTest() =>
+            Assert.Equal(ElectricResistivity.FromMegaohmsCentimeter(2), 2.MegaohmsCentimeter());
+
+        [Fact]
+        public void NumberToMegaohmMetersTest() =>
+            Assert.Equal(ElectricResistivity.FromMegaohmMeters(2), 2.MegaohmMeters());
+
+        [Fact]
+        public void NumberToMicroohmsCentimeterTest() =>
+            Assert.Equal(ElectricResistivity.FromMicroohmsCentimeter(2), 2.MicroohmsCentimeter());
+
+        [Fact]
+        public void NumberToMicroohmMetersTest() =>
+            Assert.Equal(ElectricResistivity.FromMicroohmMeters(2), 2.MicroohmMeters());
+
+        [Fact]
+        public void NumberToMilliohmsCentimeterTest() =>
+            Assert.Equal(ElectricResistivity.FromMilliohmsCentimeter(2), 2.MilliohmsCentimeter());
+
+        [Fact]
+        public void NumberToMilliohmMetersTest() =>
+            Assert.Equal(ElectricResistivity.FromMilliohmMeters(2), 2.MilliohmMeters());
+
+        [Fact]
+        public void NumberToNanoohmsCentimeterTest() =>
+            Assert.Equal(ElectricResistivity.FromNanoohmsCentimeter(2), 2.NanoohmsCentimeter());
+
+        [Fact]
+        public void NumberToNanoohmMetersTest() =>
+            Assert.Equal(ElectricResistivity.FromNanoohmMeters(2), 2.NanoohmMeters());
+
+        [Fact]
+        public void NumberToOhmsCentimeterTest() =>
+            Assert.Equal(ElectricResistivity.FromOhmsCentimeter(2), 2.OhmsCentimeter());
+
+        [Fact]
+        public void NumberToOhmMetersTest() =>
+            Assert.Equal(ElectricResistivity.FromOhmMeters(2), 2.OhmMeters());
+
+        [Fact]
+        public void NumberToPicoohmsCentimeterTest() =>
+            Assert.Equal(ElectricResistivity.FromPicoohmsCentimeter(2), 2.PicoohmsCentimeter());
+
+        [Fact]
+        public void NumberToPicoohmMetersTest() =>
+            Assert.Equal(ElectricResistivity.FromPicoohmMeters(2), 2.PicoohmMeters());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensionsTest.g.cs
new file mode 100644
index 0000000000..bc6ed172f7
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToElectricSurfaceChargeDensity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToElectricSurfaceChargeDensityExtensionsTests
+    {
+        [Fact]
+        public void NumberToCoulombsPerSquareCentimeterTest() =>
+            Assert.Equal(ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(2), 2.CoulombsPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToCoulombsPerSquareInchTest() =>
+            Assert.Equal(ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(2), 2.CoulombsPerSquareInch());
+
+        [Fact]
+        public void NumberToCoulombsPerSquareMeterTest() =>
+            Assert.Equal(ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(2), 2.CoulombsPerSquareMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs
new file mode 100644
index 0000000000..3c5b460aba
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEnergyExtensionsTest.g.cs
@@ -0,0 +1,132 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToEnergy;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToEnergyExtensionsTests
+    {
+        [Fact]
+        public void NumberToBritishThermalUnitsTest() =>
+            Assert.Equal(Energy.FromBritishThermalUnits(2), 2.BritishThermalUnits());
+
+        [Fact]
+        public void NumberToCaloriesTest() =>
+            Assert.Equal(Energy.FromCalories(2), 2.Calories());
+
+        [Fact]
+        public void NumberToDecathermsEcTest() =>
+            Assert.Equal(Energy.FromDecathermsEc(2), 2.DecathermsEc());
+
+        [Fact]
+        public void NumberToDecathermsImperialTest() =>
+            Assert.Equal(Energy.FromDecathermsImperial(2), 2.DecathermsImperial());
+
+        [Fact]
+        public void NumberToDecathermsUsTest() =>
+            Assert.Equal(Energy.FromDecathermsUs(2), 2.DecathermsUs());
+
+        [Fact]
+        public void NumberToElectronVoltsTest() =>
+            Assert.Equal(Energy.FromElectronVolts(2), 2.ElectronVolts());
+
+        [Fact]
+        public void NumberToErgsTest() =>
+            Assert.Equal(Energy.FromErgs(2), 2.Ergs());
+
+        [Fact]
+        public void NumberToFootPoundsTest() =>
+            Assert.Equal(Energy.FromFootPounds(2), 2.FootPounds());
+
+        [Fact]
+        public void NumberToGigabritishThermalUnitsTest() =>
+            Assert.Equal(Energy.FromGigabritishThermalUnits(2), 2.GigabritishThermalUnits());
+
+        [Fact]
+        public void NumberToGigajoulesTest() =>
+            Assert.Equal(Energy.FromGigajoules(2), 2.Gigajoules());
+
+        [Fact]
+        public void NumberToGigawattHoursTest() =>
+            Assert.Equal(Energy.FromGigawattHours(2), 2.GigawattHours());
+
+        [Fact]
+        public void NumberToJoulesTest() =>
+            Assert.Equal(Energy.FromJoules(2), 2.Joules());
+
+        [Fact]
+        public void NumberToKilobritishThermalUnitsTest() =>
+            Assert.Equal(Energy.FromKilobritishThermalUnits(2), 2.KilobritishThermalUnits());
+
+        [Fact]
+        public void NumberToKilocaloriesTest() =>
+            Assert.Equal(Energy.FromKilocalories(2), 2.Kilocalories());
+
+        [Fact]
+        public void NumberToKilojoulesTest() =>
+            Assert.Equal(Energy.FromKilojoules(2), 2.Kilojoules());
+
+        [Fact]
+        public void NumberToKilowattHoursTest() =>
+            Assert.Equal(Energy.FromKilowattHours(2), 2.KilowattHours());
+
+        [Fact]
+        public void NumberToMegabritishThermalUnitsTest() =>
+            Assert.Equal(Energy.FromMegabritishThermalUnits(2), 2.MegabritishThermalUnits());
+
+        [Fact]
+        public void NumberToMegacaloriesTest() =>
+            Assert.Equal(Energy.FromMegacalories(2), 2.Megacalories());
+
+        [Fact]
+        public void NumberToMegajoulesTest() =>
+            Assert.Equal(Energy.FromMegajoules(2), 2.Megajoules());
+
+        [Fact]
+        public void NumberToMegawattHoursTest() =>
+            Assert.Equal(Energy.FromMegawattHours(2), 2.MegawattHours());
+
+        [Fact]
+        public void NumberToMillijoulesTest() =>
+            Assert.Equal(Energy.FromMillijoules(2), 2.Millijoules());
+
+        [Fact]
+        public void NumberToTerawattHoursTest() =>
+            Assert.Equal(Energy.FromTerawattHours(2), 2.TerawattHours());
+
+        [Fact]
+        public void NumberToThermsEcTest() =>
+            Assert.Equal(Energy.FromThermsEc(2), 2.ThermsEc());
+
+        [Fact]
+        public void NumberToThermsImperialTest() =>
+            Assert.Equal(Energy.FromThermsImperial(2), 2.ThermsImperial());
+
+        [Fact]
+        public void NumberToThermsUsTest() =>
+            Assert.Equal(Energy.FromThermsUs(2), 2.ThermsUs());
+
+        [Fact]
+        public void NumberToWattHoursTest() =>
+            Assert.Equal(Energy.FromWattHours(2), 2.WattHours());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEntropyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEntropyExtensionsTest.g.cs
new file mode 100644
index 0000000000..c6cf992847
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToEntropyExtensionsTest.g.cs
@@ -0,0 +1,56 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToEntropy;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToEntropyExtensionsTests
+    {
+        [Fact]
+        public void NumberToCaloriesPerKelvinTest() =>
+            Assert.Equal(Entropy.FromCaloriesPerKelvin(2), 2.CaloriesPerKelvin());
+
+        [Fact]
+        public void NumberToJoulesPerDegreeCelsiusTest() =>
+            Assert.Equal(Entropy.FromJoulesPerDegreeCelsius(2), 2.JoulesPerDegreeCelsius());
+
+        [Fact]
+        public void NumberToJoulesPerKelvinTest() =>
+            Assert.Equal(Entropy.FromJoulesPerKelvin(2), 2.JoulesPerKelvin());
+
+        [Fact]
+        public void NumberToKilocaloriesPerKelvinTest() =>
+            Assert.Equal(Entropy.FromKilocaloriesPerKelvin(2), 2.KilocaloriesPerKelvin());
+
+        [Fact]
+        public void NumberToKilojoulesPerDegreeCelsiusTest() =>
+            Assert.Equal(Entropy.FromKilojoulesPerDegreeCelsius(2), 2.KilojoulesPerDegreeCelsius());
+
+        [Fact]
+        public void NumberToKilojoulesPerKelvinTest() =>
+            Assert.Equal(Entropy.FromKilojoulesPerKelvin(2), 2.KilojoulesPerKelvin());
+
+        [Fact]
+        public void NumberToMegajoulesPerKelvinTest() =>
+            Assert.Equal(Entropy.FromMegajoulesPerKelvin(2), 2.MegajoulesPerKelvin());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs
new file mode 100644
index 0000000000..c94a756ed7
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceChangeRateExtensionsTest.g.cs
@@ -0,0 +1,72 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToForceChangeRate;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToForceChangeRateExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentinewtonsPerSecondTest() =>
+            Assert.Equal(ForceChangeRate.FromCentinewtonsPerSecond(2), 2.CentinewtonsPerSecond());
+
+        [Fact]
+        public void NumberToDecanewtonsPerMinuteTest() =>
+            Assert.Equal(ForceChangeRate.FromDecanewtonsPerMinute(2), 2.DecanewtonsPerMinute());
+
+        [Fact]
+        public void NumberToDecanewtonsPerSecondTest() =>
+            Assert.Equal(ForceChangeRate.FromDecanewtonsPerSecond(2), 2.DecanewtonsPerSecond());
+
+        [Fact]
+        public void NumberToDecinewtonsPerSecondTest() =>
+            Assert.Equal(ForceChangeRate.FromDecinewtonsPerSecond(2), 2.DecinewtonsPerSecond());
+
+        [Fact]
+        public void NumberToKilonewtonsPerMinuteTest() =>
+            Assert.Equal(ForceChangeRate.FromKilonewtonsPerMinute(2), 2.KilonewtonsPerMinute());
+
+        [Fact]
+        public void NumberToKilonewtonsPerSecondTest() =>
+            Assert.Equal(ForceChangeRate.FromKilonewtonsPerSecond(2), 2.KilonewtonsPerSecond());
+
+        [Fact]
+        public void NumberToMicronewtonsPerSecondTest() =>
+            Assert.Equal(ForceChangeRate.FromMicronewtonsPerSecond(2), 2.MicronewtonsPerSecond());
+
+        [Fact]
+        public void NumberToMillinewtonsPerSecondTest() =>
+            Assert.Equal(ForceChangeRate.FromMillinewtonsPerSecond(2), 2.MillinewtonsPerSecond());
+
+        [Fact]
+        public void NumberToNanonewtonsPerSecondTest() =>
+            Assert.Equal(ForceChangeRate.FromNanonewtonsPerSecond(2), 2.NanonewtonsPerSecond());
+
+        [Fact]
+        public void NumberToNewtonsPerMinuteTest() =>
+            Assert.Equal(ForceChangeRate.FromNewtonsPerMinute(2), 2.NewtonsPerMinute());
+
+        [Fact]
+        public void NumberToNewtonsPerSecondTest() =>
+            Assert.Equal(ForceChangeRate.FromNewtonsPerSecond(2), 2.NewtonsPerSecond());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
new file mode 100644
index 0000000000..ab58f62a76
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForceExtensionsTest.g.cs
@@ -0,0 +1,80 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToForce;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToForceExtensionsTests
+    {
+        [Fact]
+        public void NumberToDecanewtonsTest() =>
+            Assert.Equal(Force.FromDecanewtons(2), 2.Decanewtons());
+
+        [Fact]
+        public void NumberToDyneTest() =>
+            Assert.Equal(Force.FromDyne(2), 2.Dyne());
+
+        [Fact]
+        public void NumberToKilogramsForceTest() =>
+            Assert.Equal(Force.FromKilogramsForce(2), 2.KilogramsForce());
+
+        [Fact]
+        public void NumberToKilonewtonsTest() =>
+            Assert.Equal(Force.FromKilonewtons(2), 2.Kilonewtons());
+
+        [Fact]
+        public void NumberToKiloPondsTest() =>
+            Assert.Equal(Force.FromKiloPonds(2), 2.KiloPonds());
+
+        [Fact]
+        public void NumberToMeganewtonsTest() =>
+            Assert.Equal(Force.FromMeganewtons(2), 2.Meganewtons());
+
+        [Fact]
+        public void NumberToMicronewtonsTest() =>
+            Assert.Equal(Force.FromMicronewtons(2), 2.Micronewtons());
+
+        [Fact]
+        public void NumberToMillinewtonsTest() =>
+            Assert.Equal(Force.FromMillinewtons(2), 2.Millinewtons());
+
+        [Fact]
+        public void NumberToNewtonsTest() =>
+            Assert.Equal(Force.FromNewtons(2), 2.Newtons());
+
+        [Fact]
+        public void NumberToOunceForceTest() =>
+            Assert.Equal(Force.FromOunceForce(2), 2.OunceForce());
+
+        [Fact]
+        public void NumberToPoundalsTest() =>
+            Assert.Equal(Force.FromPoundals(2), 2.Poundals());
+
+        [Fact]
+        public void NumberToPoundsForceTest() =>
+            Assert.Equal(Force.FromPoundsForce(2), 2.PoundsForce());
+
+        [Fact]
+        public void NumberToTonnesForceTest() =>
+            Assert.Equal(Force.FromTonnesForce(2), 2.TonnesForce());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForcePerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForcePerLengthExtensionsTest.g.cs
new file mode 100644
index 0000000000..15966ca721
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToForcePerLengthExtensionsTest.g.cs
@@ -0,0 +1,76 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToForcePerLength;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToForcePerLengthExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentinewtonsPerMeterTest() =>
+            Assert.Equal(ForcePerLength.FromCentinewtonsPerMeter(2), 2.CentinewtonsPerMeter());
+
+        [Fact]
+        public void NumberToDecinewtonsPerMeterTest() =>
+            Assert.Equal(ForcePerLength.FromDecinewtonsPerMeter(2), 2.DecinewtonsPerMeter());
+
+        [Fact]
+        public void NumberToKilogramsForcePerMeterTest() =>
+            Assert.Equal(ForcePerLength.FromKilogramsForcePerMeter(2), 2.KilogramsForcePerMeter());
+
+        [Fact]
+        public void NumberToKilonewtonsPerMeterTest() =>
+            Assert.Equal(ForcePerLength.FromKilonewtonsPerMeter(2), 2.KilonewtonsPerMeter());
+
+        [Fact]
+        public void NumberToMeganewtonsPerMeterTest() =>
+            Assert.Equal(ForcePerLength.FromMeganewtonsPerMeter(2), 2.MeganewtonsPerMeter());
+
+        [Fact]
+        public void NumberToMicronewtonsPerMeterTest() =>
+            Assert.Equal(ForcePerLength.FromMicronewtonsPerMeter(2), 2.MicronewtonsPerMeter());
+
+        [Fact]
+        public void NumberToMillinewtonsPerMeterTest() =>
+            Assert.Equal(ForcePerLength.FromMillinewtonsPerMeter(2), 2.MillinewtonsPerMeter());
+
+        [Fact]
+        public void NumberToNanonewtonsPerMeterTest() =>
+            Assert.Equal(ForcePerLength.FromNanonewtonsPerMeter(2), 2.NanonewtonsPerMeter());
+
+        [Fact]
+        public void NumberToNewtonsPerMeterTest() =>
+            Assert.Equal(ForcePerLength.FromNewtonsPerMeter(2), 2.NewtonsPerMeter());
+
+        [Fact]
+        public void NumberToPoundsForcePerFootTest() =>
+            Assert.Equal(ForcePerLength.FromPoundsForcePerFoot(2), 2.PoundsForcePerFoot());
+
+        [Fact]
+        public void NumberToPoundsForcePerInchTest() =>
+            Assert.Equal(ForcePerLength.FromPoundsForcePerInch(2), 2.PoundsForcePerInch());
+
+        [Fact]
+        public void NumberToPoundsForcePerYardTest() =>
+            Assert.Equal(ForcePerLength.FromPoundsForcePerYard(2), 2.PoundsForcePerYard());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs
new file mode 100644
index 0000000000..936cea2dc2
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFrequencyExtensionsTest.g.cs
@@ -0,0 +1,64 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToFrequency;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToFrequencyExtensionsTests
+    {
+        [Fact]
+        public void NumberToBeatsPerMinuteTest() =>
+            Assert.Equal(Frequency.FromBeatsPerMinute(2), 2.BeatsPerMinute());
+
+        [Fact]
+        public void NumberToCyclesPerHourTest() =>
+            Assert.Equal(Frequency.FromCyclesPerHour(2), 2.CyclesPerHour());
+
+        [Fact]
+        public void NumberToCyclesPerMinuteTest() =>
+            Assert.Equal(Frequency.FromCyclesPerMinute(2), 2.CyclesPerMinute());
+
+        [Fact]
+        public void NumberToGigahertzTest() =>
+            Assert.Equal(Frequency.FromGigahertz(2), 2.Gigahertz());
+
+        [Fact]
+        public void NumberToHertzTest() =>
+            Assert.Equal(Frequency.FromHertz(2), 2.Hertz());
+
+        [Fact]
+        public void NumberToKilohertzTest() =>
+            Assert.Equal(Frequency.FromKilohertz(2), 2.Kilohertz());
+
+        [Fact]
+        public void NumberToMegahertzTest() =>
+            Assert.Equal(Frequency.FromMegahertz(2), 2.Megahertz());
+
+        [Fact]
+        public void NumberToRadiansPerSecondTest() =>
+            Assert.Equal(Frequency.FromRadiansPerSecond(2), 2.RadiansPerSecond());
+
+        [Fact]
+        public void NumberToTerahertzTest() =>
+            Assert.Equal(Frequency.FromTerahertz(2), 2.Terahertz());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs
new file mode 100644
index 0000000000..a4a8ef5c87
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToFuelEfficiencyExtensionsTest.g.cs
@@ -0,0 +1,44 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToFuelEfficiency;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToFuelEfficiencyExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilometersPerLitersTest() =>
+            Assert.Equal(FuelEfficiency.FromKilometersPerLiters(2), 2.KilometersPerLiters());
+
+        [Fact]
+        public void NumberToLitersPer100KilometersTest() =>
+            Assert.Equal(FuelEfficiency.FromLitersPer100Kilometers(2), 2.LitersPer100Kilometers());
+
+        [Fact]
+        public void NumberToMilesPerUkGallonTest() =>
+            Assert.Equal(FuelEfficiency.FromMilesPerUkGallon(2), 2.MilesPerUkGallon());
+
+        [Fact]
+        public void NumberToMilesPerUsGallonTest() =>
+            Assert.Equal(FuelEfficiency.FromMilesPerUsGallon(2), 2.MilesPerUsGallon());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
new file mode 100644
index 0000000000..1c6e35a100
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatFluxExtensionsTest.g.cs
@@ -0,0 +1,100 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToHeatFlux;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToHeatFluxExtensionsTests
+    {
+        [Fact]
+        public void NumberToBtusPerHourSquareFootTest() =>
+            Assert.Equal(HeatFlux.FromBtusPerHourSquareFoot(2), 2.BtusPerHourSquareFoot());
+
+        [Fact]
+        public void NumberToBtusPerMinuteSquareFootTest() =>
+            Assert.Equal(HeatFlux.FromBtusPerMinuteSquareFoot(2), 2.BtusPerMinuteSquareFoot());
+
+        [Fact]
+        public void NumberToBtusPerSecondSquareFootTest() =>
+            Assert.Equal(HeatFlux.FromBtusPerSecondSquareFoot(2), 2.BtusPerSecondSquareFoot());
+
+        [Fact]
+        public void NumberToBtusPerSecondSquareInchTest() =>
+            Assert.Equal(HeatFlux.FromBtusPerSecondSquareInch(2), 2.BtusPerSecondSquareInch());
+
+        [Fact]
+        public void NumberToCaloriesPerSecondSquareCentimeterTest() =>
+            Assert.Equal(HeatFlux.FromCaloriesPerSecondSquareCentimeter(2), 2.CaloriesPerSecondSquareCentimeter());
+
+        [Fact]
+        public void NumberToCentiwattsPerSquareMeterTest() =>
+            Assert.Equal(HeatFlux.FromCentiwattsPerSquareMeter(2), 2.CentiwattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToDeciwattsPerSquareMeterTest() =>
+            Assert.Equal(HeatFlux.FromDeciwattsPerSquareMeter(2), 2.DeciwattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToKilocaloriesPerHourSquareMeterTest() =>
+            Assert.Equal(HeatFlux.FromKilocaloriesPerHourSquareMeter(2), 2.KilocaloriesPerHourSquareMeter());
+
+        [Fact]
+        public void NumberToKilocaloriesPerSecondSquareCentimeterTest() =>
+            Assert.Equal(HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(2), 2.KilocaloriesPerSecondSquareCentimeter());
+
+        [Fact]
+        public void NumberToKilowattsPerSquareMeterTest() =>
+            Assert.Equal(HeatFlux.FromKilowattsPerSquareMeter(2), 2.KilowattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToMicrowattsPerSquareMeterTest() =>
+            Assert.Equal(HeatFlux.FromMicrowattsPerSquareMeter(2), 2.MicrowattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToMilliwattsPerSquareMeterTest() =>
+            Assert.Equal(HeatFlux.FromMilliwattsPerSquareMeter(2), 2.MilliwattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToNanowattsPerSquareMeterTest() =>
+            Assert.Equal(HeatFlux.FromNanowattsPerSquareMeter(2), 2.NanowattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToPoundsForcePerFootSecondTest() =>
+            Assert.Equal(HeatFlux.FromPoundsForcePerFootSecond(2), 2.PoundsForcePerFootSecond());
+
+        [Fact]
+        public void NumberToPoundsPerSecondCubedTest() =>
+            Assert.Equal(HeatFlux.FromPoundsPerSecondCubed(2), 2.PoundsPerSecondCubed());
+
+        [Fact]
+        public void NumberToWattsPerSquareFootTest() =>
+            Assert.Equal(HeatFlux.FromWattsPerSquareFoot(2), 2.WattsPerSquareFoot());
+
+        [Fact]
+        public void NumberToWattsPerSquareInchTest() =>
+            Assert.Equal(HeatFlux.FromWattsPerSquareInch(2), 2.WattsPerSquareInch());
+
+        [Fact]
+        public void NumberToWattsPerSquareMeterTest() =>
+            Assert.Equal(HeatFlux.FromWattsPerSquareMeter(2), 2.WattsPerSquareMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
new file mode 100644
index 0000000000..511070611b
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToHeatTransferCoefficientExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToHeatTransferCoefficient;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToHeatTransferCoefficientExtensionsTests
+    {
+        [Fact]
+        public void NumberToBtusPerSquareFootDegreeFahrenheitTest() =>
+            Assert.Equal(HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(2), 2.BtusPerSquareFootDegreeFahrenheit());
+
+        [Fact]
+        public void NumberToWattsPerSquareMeterCelsiusTest() =>
+            Assert.Equal(HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(2), 2.WattsPerSquareMeterCelsius());
+
+        [Fact]
+        public void NumberToWattsPerSquareMeterKelvinTest() =>
+            Assert.Equal(HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(2), 2.WattsPerSquareMeterKelvin());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIlluminanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIlluminanceExtensionsTest.g.cs
new file mode 100644
index 0000000000..f39ff3cdbd
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIlluminanceExtensionsTest.g.cs
@@ -0,0 +1,44 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToIlluminance;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToIlluminanceExtensionsTests
+    {
+        [Fact]
+        public void NumberToKiloluxTest() =>
+            Assert.Equal(Illuminance.FromKilolux(2), 2.Kilolux());
+
+        [Fact]
+        public void NumberToLuxTest() =>
+            Assert.Equal(Illuminance.FromLux(2), 2.Lux());
+
+        [Fact]
+        public void NumberToMegaluxTest() =>
+            Assert.Equal(Illuminance.FromMegalux(2), 2.Megalux());
+
+        [Fact]
+        public void NumberToMilliluxTest() =>
+            Assert.Equal(Illuminance.FromMillilux(2), 2.Millilux());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs
new file mode 100644
index 0000000000..3f566f4025
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToInformationExtensionsTest.g.cs
@@ -0,0 +1,132 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToInformation;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToInformationExtensionsTests
+    {
+        [Fact]
+        public void NumberToBitsTest() =>
+            Assert.Equal(Information.FromBits(2), 2.Bits());
+
+        [Fact]
+        public void NumberToBytesTest() =>
+            Assert.Equal(Information.FromBytes(2), 2.Bytes());
+
+        [Fact]
+        public void NumberToExabitsTest() =>
+            Assert.Equal(Information.FromExabits(2), 2.Exabits());
+
+        [Fact]
+        public void NumberToExabytesTest() =>
+            Assert.Equal(Information.FromExabytes(2), 2.Exabytes());
+
+        [Fact]
+        public void NumberToExbibitsTest() =>
+            Assert.Equal(Information.FromExbibits(2), 2.Exbibits());
+
+        [Fact]
+        public void NumberToExbibytesTest() =>
+            Assert.Equal(Information.FromExbibytes(2), 2.Exbibytes());
+
+        [Fact]
+        public void NumberToGibibitsTest() =>
+            Assert.Equal(Information.FromGibibits(2), 2.Gibibits());
+
+        [Fact]
+        public void NumberToGibibytesTest() =>
+            Assert.Equal(Information.FromGibibytes(2), 2.Gibibytes());
+
+        [Fact]
+        public void NumberToGigabitsTest() =>
+            Assert.Equal(Information.FromGigabits(2), 2.Gigabits());
+
+        [Fact]
+        public void NumberToGigabytesTest() =>
+            Assert.Equal(Information.FromGigabytes(2), 2.Gigabytes());
+
+        [Fact]
+        public void NumberToKibibitsTest() =>
+            Assert.Equal(Information.FromKibibits(2), 2.Kibibits());
+
+        [Fact]
+        public void NumberToKibibytesTest() =>
+            Assert.Equal(Information.FromKibibytes(2), 2.Kibibytes());
+
+        [Fact]
+        public void NumberToKilobitsTest() =>
+            Assert.Equal(Information.FromKilobits(2), 2.Kilobits());
+
+        [Fact]
+        public void NumberToKilobytesTest() =>
+            Assert.Equal(Information.FromKilobytes(2), 2.Kilobytes());
+
+        [Fact]
+        public void NumberToMebibitsTest() =>
+            Assert.Equal(Information.FromMebibits(2), 2.Mebibits());
+
+        [Fact]
+        public void NumberToMebibytesTest() =>
+            Assert.Equal(Information.FromMebibytes(2), 2.Mebibytes());
+
+        [Fact]
+        public void NumberToMegabitsTest() =>
+            Assert.Equal(Information.FromMegabits(2), 2.Megabits());
+
+        [Fact]
+        public void NumberToMegabytesTest() =>
+            Assert.Equal(Information.FromMegabytes(2), 2.Megabytes());
+
+        [Fact]
+        public void NumberToPebibitsTest() =>
+            Assert.Equal(Information.FromPebibits(2), 2.Pebibits());
+
+        [Fact]
+        public void NumberToPebibytesTest() =>
+            Assert.Equal(Information.FromPebibytes(2), 2.Pebibytes());
+
+        [Fact]
+        public void NumberToPetabitsTest() =>
+            Assert.Equal(Information.FromPetabits(2), 2.Petabits());
+
+        [Fact]
+        public void NumberToPetabytesTest() =>
+            Assert.Equal(Information.FromPetabytes(2), 2.Petabytes());
+
+        [Fact]
+        public void NumberToTebibitsTest() =>
+            Assert.Equal(Information.FromTebibits(2), 2.Tebibits());
+
+        [Fact]
+        public void NumberToTebibytesTest() =>
+            Assert.Equal(Information.FromTebibytes(2), 2.Tebibytes());
+
+        [Fact]
+        public void NumberToTerabitsTest() =>
+            Assert.Equal(Information.FromTerabits(2), 2.Terabits());
+
+        [Fact]
+        public void NumberToTerabytesTest() =>
+            Assert.Equal(Information.FromTerabytes(2), 2.Terabytes());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradianceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradianceExtensionsTest.g.cs
new file mode 100644
index 0000000000..93a9cb1cbc
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradianceExtensionsTest.g.cs
@@ -0,0 +1,84 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToIrradiance;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToIrradianceExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilowattsPerSquareCentimeterTest() =>
+            Assert.Equal(Irradiance.FromKilowattsPerSquareCentimeter(2), 2.KilowattsPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToKilowattsPerSquareMeterTest() =>
+            Assert.Equal(Irradiance.FromKilowattsPerSquareMeter(2), 2.KilowattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToMegawattsPerSquareCentimeterTest() =>
+            Assert.Equal(Irradiance.FromMegawattsPerSquareCentimeter(2), 2.MegawattsPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToMegawattsPerSquareMeterTest() =>
+            Assert.Equal(Irradiance.FromMegawattsPerSquareMeter(2), 2.MegawattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToMicrowattsPerSquareCentimeterTest() =>
+            Assert.Equal(Irradiance.FromMicrowattsPerSquareCentimeter(2), 2.MicrowattsPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToMicrowattsPerSquareMeterTest() =>
+            Assert.Equal(Irradiance.FromMicrowattsPerSquareMeter(2), 2.MicrowattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToMilliwattsPerSquareCentimeterTest() =>
+            Assert.Equal(Irradiance.FromMilliwattsPerSquareCentimeter(2), 2.MilliwattsPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToMilliwattsPerSquareMeterTest() =>
+            Assert.Equal(Irradiance.FromMilliwattsPerSquareMeter(2), 2.MilliwattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToNanowattsPerSquareCentimeterTest() =>
+            Assert.Equal(Irradiance.FromNanowattsPerSquareCentimeter(2), 2.NanowattsPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToNanowattsPerSquareMeterTest() =>
+            Assert.Equal(Irradiance.FromNanowattsPerSquareMeter(2), 2.NanowattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToPicowattsPerSquareCentimeterTest() =>
+            Assert.Equal(Irradiance.FromPicowattsPerSquareCentimeter(2), 2.PicowattsPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToPicowattsPerSquareMeterTest() =>
+            Assert.Equal(Irradiance.FromPicowattsPerSquareMeter(2), 2.PicowattsPerSquareMeter());
+
+        [Fact]
+        public void NumberToWattsPerSquareCentimeterTest() =>
+            Assert.Equal(Irradiance.FromWattsPerSquareCentimeter(2), 2.WattsPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToWattsPerSquareMeterTest() =>
+            Assert.Equal(Irradiance.FromWattsPerSquareMeter(2), 2.WattsPerSquareMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradiationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradiationExtensionsTest.g.cs
new file mode 100644
index 0000000000..f14afa4cb6
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToIrradiationExtensionsTest.g.cs
@@ -0,0 +1,56 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToIrradiation;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToIrradiationExtensionsTests
+    {
+        [Fact]
+        public void NumberToJoulesPerSquareCentimeterTest() =>
+            Assert.Equal(Irradiation.FromJoulesPerSquareCentimeter(2), 2.JoulesPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToJoulesPerSquareMeterTest() =>
+            Assert.Equal(Irradiation.FromJoulesPerSquareMeter(2), 2.JoulesPerSquareMeter());
+
+        [Fact]
+        public void NumberToJoulesPerSquareMillimeterTest() =>
+            Assert.Equal(Irradiation.FromJoulesPerSquareMillimeter(2), 2.JoulesPerSquareMillimeter());
+
+        [Fact]
+        public void NumberToKilojoulesPerSquareMeterTest() =>
+            Assert.Equal(Irradiation.FromKilojoulesPerSquareMeter(2), 2.KilojoulesPerSquareMeter());
+
+        [Fact]
+        public void NumberToKilowattHoursPerSquareMeterTest() =>
+            Assert.Equal(Irradiation.FromKilowattHoursPerSquareMeter(2), 2.KilowattHoursPerSquareMeter());
+
+        [Fact]
+        public void NumberToMillijoulesPerSquareCentimeterTest() =>
+            Assert.Equal(Irradiation.FromMillijoulesPerSquareCentimeter(2), 2.MillijoulesPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToWattHoursPerSquareMeterTest() =>
+            Assert.Equal(Irradiation.FromWattHoursPerSquareMeter(2), 2.WattHoursPerSquareMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToKinematicViscosityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToKinematicViscosityExtensionsTest.g.cs
new file mode 100644
index 0000000000..54ac9d71c4
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToKinematicViscosityExtensionsTest.g.cs
@@ -0,0 +1,60 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToKinematicViscosity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToKinematicViscosityExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentistokesTest() =>
+            Assert.Equal(KinematicViscosity.FromCentistokes(2), 2.Centistokes());
+
+        [Fact]
+        public void NumberToDecistokesTest() =>
+            Assert.Equal(KinematicViscosity.FromDecistokes(2), 2.Decistokes());
+
+        [Fact]
+        public void NumberToKilostokesTest() =>
+            Assert.Equal(KinematicViscosity.FromKilostokes(2), 2.Kilostokes());
+
+        [Fact]
+        public void NumberToMicrostokesTest() =>
+            Assert.Equal(KinematicViscosity.FromMicrostokes(2), 2.Microstokes());
+
+        [Fact]
+        public void NumberToMillistokesTest() =>
+            Assert.Equal(KinematicViscosity.FromMillistokes(2), 2.Millistokes());
+
+        [Fact]
+        public void NumberToNanostokesTest() =>
+            Assert.Equal(KinematicViscosity.FromNanostokes(2), 2.Nanostokes());
+
+        [Fact]
+        public void NumberToSquareMetersPerSecondTest() =>
+            Assert.Equal(KinematicViscosity.FromSquareMetersPerSecond(2), 2.SquareMetersPerSecond());
+
+        [Fact]
+        public void NumberToStokesTest() =>
+            Assert.Equal(KinematicViscosity.FromStokes(2), 2.Stokes());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLapseRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLapseRateExtensionsTest.g.cs
new file mode 100644
index 0000000000..a18304b716
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLapseRateExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToLapseRate;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToLapseRateExtensionsTests
+    {
+        [Fact]
+        public void NumberToDegreesCelciusPerKilometerTest() =>
+            Assert.Equal(LapseRate.FromDegreesCelciusPerKilometer(2), 2.DegreesCelciusPerKilometer());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLengthExtensionsTest.g.cs
new file mode 100644
index 0000000000..9bab6a3398
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLengthExtensionsTest.g.cs
@@ -0,0 +1,156 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToLength;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToLengthExtensionsTests
+    {
+        [Fact]
+        public void NumberToAstronomicalUnitsTest() =>
+            Assert.Equal(Length.FromAstronomicalUnits(2), 2.AstronomicalUnits());
+
+        [Fact]
+        public void NumberToCentimetersTest() =>
+            Assert.Equal(Length.FromCentimeters(2), 2.Centimeters());
+
+        [Fact]
+        public void NumberToDecimetersTest() =>
+            Assert.Equal(Length.FromDecimeters(2), 2.Decimeters());
+
+        [Fact]
+        public void NumberToDtpPicasTest() =>
+            Assert.Equal(Length.FromDtpPicas(2), 2.DtpPicas());
+
+        [Fact]
+        public void NumberToDtpPointsTest() =>
+            Assert.Equal(Length.FromDtpPoints(2), 2.DtpPoints());
+
+        [Fact]
+        public void NumberToFathomsTest() =>
+            Assert.Equal(Length.FromFathoms(2), 2.Fathoms());
+
+        [Fact]
+        public void NumberToFeetTest() =>
+            Assert.Equal(Length.FromFeet(2), 2.Feet());
+
+        [Fact]
+        public void NumberToHandsTest() =>
+            Assert.Equal(Length.FromHands(2), 2.Hands());
+
+        [Fact]
+        public void NumberToHectometersTest() =>
+            Assert.Equal(Length.FromHectometers(2), 2.Hectometers());
+
+        [Fact]
+        public void NumberToInchesTest() =>
+            Assert.Equal(Length.FromInches(2), 2.Inches());
+
+        [Fact]
+        public void NumberToKilolightYearsTest() =>
+            Assert.Equal(Length.FromKilolightYears(2), 2.KilolightYears());
+
+        [Fact]
+        public void NumberToKilometersTest() =>
+            Assert.Equal(Length.FromKilometers(2), 2.Kilometers());
+
+        [Fact]
+        public void NumberToKiloparsecsTest() =>
+            Assert.Equal(Length.FromKiloparsecs(2), 2.Kiloparsecs());
+
+        [Fact]
+        public void NumberToLightYearsTest() =>
+            Assert.Equal(Length.FromLightYears(2), 2.LightYears());
+
+        [Fact]
+        public void NumberToMegalightYearsTest() =>
+            Assert.Equal(Length.FromMegalightYears(2), 2.MegalightYears());
+
+        [Fact]
+        public void NumberToMegaparsecsTest() =>
+            Assert.Equal(Length.FromMegaparsecs(2), 2.Megaparsecs());
+
+        [Fact]
+        public void NumberToMetersTest() =>
+            Assert.Equal(Length.FromMeters(2), 2.Meters());
+
+        [Fact]
+        public void NumberToMicroinchesTest() =>
+            Assert.Equal(Length.FromMicroinches(2), 2.Microinches());
+
+        [Fact]
+        public void NumberToMicrometersTest() =>
+            Assert.Equal(Length.FromMicrometers(2), 2.Micrometers());
+
+        [Fact]
+        public void NumberToMilsTest() =>
+            Assert.Equal(Length.FromMils(2), 2.Mils());
+
+        [Fact]
+        public void NumberToMilesTest() =>
+            Assert.Equal(Length.FromMiles(2), 2.Miles());
+
+        [Fact]
+        public void NumberToMillimetersTest() =>
+            Assert.Equal(Length.FromMillimeters(2), 2.Millimeters());
+
+        [Fact]
+        public void NumberToNanometersTest() =>
+            Assert.Equal(Length.FromNanometers(2), 2.Nanometers());
+
+        [Fact]
+        public void NumberToNauticalMilesTest() =>
+            Assert.Equal(Length.FromNauticalMiles(2), 2.NauticalMiles());
+
+        [Fact]
+        public void NumberToParsecsTest() =>
+            Assert.Equal(Length.FromParsecs(2), 2.Parsecs());
+
+        [Fact]
+        public void NumberToPrinterPicasTest() =>
+            Assert.Equal(Length.FromPrinterPicas(2), 2.PrinterPicas());
+
+        [Fact]
+        public void NumberToPrinterPointsTest() =>
+            Assert.Equal(Length.FromPrinterPoints(2), 2.PrinterPoints());
+
+        [Fact]
+        public void NumberToShacklesTest() =>
+            Assert.Equal(Length.FromShackles(2), 2.Shackles());
+
+        [Fact]
+        public void NumberToSolarRadiusesTest() =>
+            Assert.Equal(Length.FromSolarRadiuses(2), 2.SolarRadiuses());
+
+        [Fact]
+        public void NumberToTwipsTest() =>
+            Assert.Equal(Length.FromTwips(2), 2.Twips());
+
+        [Fact]
+        public void NumberToUsSurveyFeetTest() =>
+            Assert.Equal(Length.FromUsSurveyFeet(2), 2.UsSurveyFeet());
+
+        [Fact]
+        public void NumberToYardsTest() =>
+            Assert.Equal(Length.FromYards(2), 2.Yards());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLevelExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLevelExtensionsTest.g.cs
new file mode 100644
index 0000000000..02fc9efc9c
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLevelExtensionsTest.g.cs
@@ -0,0 +1,36 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToLevel;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToLevelExtensionsTests
+    {
+        [Fact]
+        public void NumberToDecibelsTest() =>
+            Assert.Equal(Level.FromDecibels(2), 2.Decibels());
+
+        [Fact]
+        public void NumberToNepersTest() =>
+            Assert.Equal(Level.FromNepers(2), 2.Nepers());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearDensityExtensionsTest.g.cs
new file mode 100644
index 0000000000..20dcf51546
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLinearDensityExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToLinearDensity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToLinearDensityExtensionsTests
+    {
+        [Fact]
+        public void NumberToGramsPerMeterTest() =>
+            Assert.Equal(LinearDensity.FromGramsPerMeter(2), 2.GramsPerMeter());
+
+        [Fact]
+        public void NumberToKilogramsPerMeterTest() =>
+            Assert.Equal(LinearDensity.FromKilogramsPerMeter(2), 2.KilogramsPerMeter());
+
+        [Fact]
+        public void NumberToPoundsPerFootTest() =>
+            Assert.Equal(LinearDensity.FromPoundsPerFoot(2), 2.PoundsPerFoot());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminosityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminosityExtensionsTest.g.cs
new file mode 100644
index 0000000000..0e4a7d8c7a
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminosityExtensionsTest.g.cs
@@ -0,0 +1,84 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToLuminosity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToLuminosityExtensionsTests
+    {
+        [Fact]
+        public void NumberToDecawattsTest() =>
+            Assert.Equal(Luminosity.FromDecawatts(2), 2.Decawatts());
+
+        [Fact]
+        public void NumberToDeciwattsTest() =>
+            Assert.Equal(Luminosity.FromDeciwatts(2), 2.Deciwatts());
+
+        [Fact]
+        public void NumberToFemtowattsTest() =>
+            Assert.Equal(Luminosity.FromFemtowatts(2), 2.Femtowatts());
+
+        [Fact]
+        public void NumberToGigawattsTest() =>
+            Assert.Equal(Luminosity.FromGigawatts(2), 2.Gigawatts());
+
+        [Fact]
+        public void NumberToKilowattsTest() =>
+            Assert.Equal(Luminosity.FromKilowatts(2), 2.Kilowatts());
+
+        [Fact]
+        public void NumberToMegawattsTest() =>
+            Assert.Equal(Luminosity.FromMegawatts(2), 2.Megawatts());
+
+        [Fact]
+        public void NumberToMicrowattsTest() =>
+            Assert.Equal(Luminosity.FromMicrowatts(2), 2.Microwatts());
+
+        [Fact]
+        public void NumberToMilliwattsTest() =>
+            Assert.Equal(Luminosity.FromMilliwatts(2), 2.Milliwatts());
+
+        [Fact]
+        public void NumberToNanowattsTest() =>
+            Assert.Equal(Luminosity.FromNanowatts(2), 2.Nanowatts());
+
+        [Fact]
+        public void NumberToPetawattsTest() =>
+            Assert.Equal(Luminosity.FromPetawatts(2), 2.Petawatts());
+
+        [Fact]
+        public void NumberToPicowattsTest() =>
+            Assert.Equal(Luminosity.FromPicowatts(2), 2.Picowatts());
+
+        [Fact]
+        public void NumberToSolarLuminositiesTest() =>
+            Assert.Equal(Luminosity.FromSolarLuminosities(2), 2.SolarLuminosities());
+
+        [Fact]
+        public void NumberToTerawattsTest() =>
+            Assert.Equal(Luminosity.FromTerawatts(2), 2.Terawatts());
+
+        [Fact]
+        public void NumberToWattsTest() =>
+            Assert.Equal(Luminosity.FromWatts(2), 2.Watts());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousFluxExtensionsTest.g.cs
new file mode 100644
index 0000000000..4f2c476c67
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousFluxExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToLuminousFlux;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToLuminousFluxExtensionsTests
+    {
+        [Fact]
+        public void NumberToLumensTest() =>
+            Assert.Equal(LuminousFlux.FromLumens(2), 2.Lumens());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousIntensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousIntensityExtensionsTest.g.cs
new file mode 100644
index 0000000000..c5b91b4349
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToLuminousIntensityExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToLuminousIntensity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToLuminousIntensityExtensionsTests
+    {
+        [Fact]
+        public void NumberToCandelaTest() =>
+            Assert.Equal(LuminousIntensity.FromCandela(2), 2.Candela());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFieldExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFieldExtensionsTest.g.cs
new file mode 100644
index 0000000000..bbb90f6fbf
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFieldExtensionsTest.g.cs
@@ -0,0 +1,44 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMagneticField;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMagneticFieldExtensionsTests
+    {
+        [Fact]
+        public void NumberToMicroteslasTest() =>
+            Assert.Equal(MagneticField.FromMicroteslas(2), 2.Microteslas());
+
+        [Fact]
+        public void NumberToMilliteslasTest() =>
+            Assert.Equal(MagneticField.FromMilliteslas(2), 2.Milliteslas());
+
+        [Fact]
+        public void NumberToNanoteslasTest() =>
+            Assert.Equal(MagneticField.FromNanoteslas(2), 2.Nanoteslas());
+
+        [Fact]
+        public void NumberToTeslasTest() =>
+            Assert.Equal(MagneticField.FromTeslas(2), 2.Teslas());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFluxExtensionsTest.g.cs
new file mode 100644
index 0000000000..5a801aba5f
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagneticFluxExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMagneticFlux;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMagneticFluxExtensionsTests
+    {
+        [Fact]
+        public void NumberToWebersTest() =>
+            Assert.Equal(MagneticFlux.FromWebers(2), 2.Webers());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagnetizationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagnetizationExtensionsTest.g.cs
new file mode 100644
index 0000000000..ed0696ed14
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMagnetizationExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMagnetization;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMagnetizationExtensionsTests
+    {
+        [Fact]
+        public void NumberToAmperesPerMeterTest() =>
+            Assert.Equal(Magnetization.FromAmperesPerMeter(2), 2.AmperesPerMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs
new file mode 100644
index 0000000000..9a73fc4969
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs
@@ -0,0 +1,188 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMassConcentration;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMassConcentrationExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentigramsPerDeciliterTest() =>
+            Assert.Equal(MassConcentration.FromCentigramsPerDeciliter(2), 2.CentigramsPerDeciliter());
+
+        [Fact]
+        public void NumberToCentigramsPerLiterTest() =>
+            Assert.Equal(MassConcentration.FromCentigramsPerLiter(2), 2.CentigramsPerLiter());
+
+        [Fact]
+        public void NumberToCentigramsPerMilliliterTest() =>
+            Assert.Equal(MassConcentration.FromCentigramsPerMilliliter(2), 2.CentigramsPerMilliliter());
+
+        [Fact]
+        public void NumberToDecigramsPerDeciliterTest() =>
+            Assert.Equal(MassConcentration.FromDecigramsPerDeciliter(2), 2.DecigramsPerDeciliter());
+
+        [Fact]
+        public void NumberToDecigramsPerLiterTest() =>
+            Assert.Equal(MassConcentration.FromDecigramsPerLiter(2), 2.DecigramsPerLiter());
+
+        [Fact]
+        public void NumberToDecigramsPerMilliliterTest() =>
+            Assert.Equal(MassConcentration.FromDecigramsPerMilliliter(2), 2.DecigramsPerMilliliter());
+
+        [Fact]
+        public void NumberToGramsPerCubicCentimeterTest() =>
+            Assert.Equal(MassConcentration.FromGramsPerCubicCentimeter(2), 2.GramsPerCubicCentimeter());
+
+        [Fact]
+        public void NumberToGramsPerCubicMeterTest() =>
+            Assert.Equal(MassConcentration.FromGramsPerCubicMeter(2), 2.GramsPerCubicMeter());
+
+        [Fact]
+        public void NumberToGramsPerCubicMillimeterTest() =>
+            Assert.Equal(MassConcentration.FromGramsPerCubicMillimeter(2), 2.GramsPerCubicMillimeter());
+
+        [Fact]
+        public void NumberToGramsPerDeciliterTest() =>
+            Assert.Equal(MassConcentration.FromGramsPerDeciliter(2), 2.GramsPerDeciliter());
+
+        [Fact]
+        public void NumberToGramsPerLiterTest() =>
+            Assert.Equal(MassConcentration.FromGramsPerLiter(2), 2.GramsPerLiter());
+
+        [Fact]
+        public void NumberToGramsPerMilliliterTest() =>
+            Assert.Equal(MassConcentration.FromGramsPerMilliliter(2), 2.GramsPerMilliliter());
+
+        [Fact]
+        public void NumberToKilogramsPerCubicCentimeterTest() =>
+            Assert.Equal(MassConcentration.FromKilogramsPerCubicCentimeter(2), 2.KilogramsPerCubicCentimeter());
+
+        [Fact]
+        public void NumberToKilogramsPerCubicMeterTest() =>
+            Assert.Equal(MassConcentration.FromKilogramsPerCubicMeter(2), 2.KilogramsPerCubicMeter());
+
+        [Fact]
+        public void NumberToKilogramsPerCubicMillimeterTest() =>
+            Assert.Equal(MassConcentration.FromKilogramsPerCubicMillimeter(2), 2.KilogramsPerCubicMillimeter());
+
+        [Fact]
+        public void NumberToKilogramsPerLiterTest() =>
+            Assert.Equal(MassConcentration.FromKilogramsPerLiter(2), 2.KilogramsPerLiter());
+
+        [Fact]
+        public void NumberToKilopoundsPerCubicFootTest() =>
+            Assert.Equal(MassConcentration.FromKilopoundsPerCubicFoot(2), 2.KilopoundsPerCubicFoot());
+
+        [Fact]
+        public void NumberToKilopoundsPerCubicInchTest() =>
+            Assert.Equal(MassConcentration.FromKilopoundsPerCubicInch(2), 2.KilopoundsPerCubicInch());
+
+        [Fact]
+        public void NumberToMicrogramsPerCubicMeterTest() =>
+            Assert.Equal(MassConcentration.FromMicrogramsPerCubicMeter(2), 2.MicrogramsPerCubicMeter());
+
+        [Fact]
+        public void NumberToMicrogramsPerDeciliterTest() =>
+            Assert.Equal(MassConcentration.FromMicrogramsPerDeciliter(2), 2.MicrogramsPerDeciliter());
+
+        [Fact]
+        public void NumberToMicrogramsPerLiterTest() =>
+            Assert.Equal(MassConcentration.FromMicrogramsPerLiter(2), 2.MicrogramsPerLiter());
+
+        [Fact]
+        public void NumberToMicrogramsPerMilliliterTest() =>
+            Assert.Equal(MassConcentration.FromMicrogramsPerMilliliter(2), 2.MicrogramsPerMilliliter());
+
+        [Fact]
+        public void NumberToMilligramsPerCubicMeterTest() =>
+            Assert.Equal(MassConcentration.FromMilligramsPerCubicMeter(2), 2.MilligramsPerCubicMeter());
+
+        [Fact]
+        public void NumberToMilligramsPerDeciliterTest() =>
+            Assert.Equal(MassConcentration.FromMilligramsPerDeciliter(2), 2.MilligramsPerDeciliter());
+
+        [Fact]
+        public void NumberToMilligramsPerLiterTest() =>
+            Assert.Equal(MassConcentration.FromMilligramsPerLiter(2), 2.MilligramsPerLiter());
+
+        [Fact]
+        public void NumberToMilligramsPerMilliliterTest() =>
+            Assert.Equal(MassConcentration.FromMilligramsPerMilliliter(2), 2.MilligramsPerMilliliter());
+
+        [Fact]
+        public void NumberToNanogramsPerDeciliterTest() =>
+            Assert.Equal(MassConcentration.FromNanogramsPerDeciliter(2), 2.NanogramsPerDeciliter());
+
+        [Fact]
+        public void NumberToNanogramsPerLiterTest() =>
+            Assert.Equal(MassConcentration.FromNanogramsPerLiter(2), 2.NanogramsPerLiter());
+
+        [Fact]
+        public void NumberToNanogramsPerMilliliterTest() =>
+            Assert.Equal(MassConcentration.FromNanogramsPerMilliliter(2), 2.NanogramsPerMilliliter());
+
+        [Fact]
+        public void NumberToPicogramsPerDeciliterTest() =>
+            Assert.Equal(MassConcentration.FromPicogramsPerDeciliter(2), 2.PicogramsPerDeciliter());
+
+        [Fact]
+        public void NumberToPicogramsPerLiterTest() =>
+            Assert.Equal(MassConcentration.FromPicogramsPerLiter(2), 2.PicogramsPerLiter());
+
+        [Fact]
+        public void NumberToPicogramsPerMilliliterTest() =>
+            Assert.Equal(MassConcentration.FromPicogramsPerMilliliter(2), 2.PicogramsPerMilliliter());
+
+        [Fact]
+        public void NumberToPoundsPerCubicFootTest() =>
+            Assert.Equal(MassConcentration.FromPoundsPerCubicFoot(2), 2.PoundsPerCubicFoot());
+
+        [Fact]
+        public void NumberToPoundsPerCubicInchTest() =>
+            Assert.Equal(MassConcentration.FromPoundsPerCubicInch(2), 2.PoundsPerCubicInch());
+
+        [Fact]
+        public void NumberToPoundsPerImperialGallonTest() =>
+            Assert.Equal(MassConcentration.FromPoundsPerImperialGallon(2), 2.PoundsPerImperialGallon());
+
+        [Fact]
+        public void NumberToPoundsPerUSGallonTest() =>
+            Assert.Equal(MassConcentration.FromPoundsPerUSGallon(2), 2.PoundsPerUSGallon());
+
+        [Fact]
+        public void NumberToSlugsPerCubicFootTest() =>
+            Assert.Equal(MassConcentration.FromSlugsPerCubicFoot(2), 2.SlugsPerCubicFoot());
+
+        [Fact]
+        public void NumberToTonnesPerCubicCentimeterTest() =>
+            Assert.Equal(MassConcentration.FromTonnesPerCubicCentimeter(2), 2.TonnesPerCubicCentimeter());
+
+        [Fact]
+        public void NumberToTonnesPerCubicMeterTest() =>
+            Assert.Equal(MassConcentration.FromTonnesPerCubicMeter(2), 2.TonnesPerCubicMeter());
+
+        [Fact]
+        public void NumberToTonnesPerCubicMillimeterTest() =>
+            Assert.Equal(MassConcentration.FromTonnesPerCubicMillimeter(2), 2.TonnesPerCubicMillimeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassExtensionsTest.g.cs
new file mode 100644
index 0000000000..55dbe6f344
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassExtensionsTest.g.cs
@@ -0,0 +1,128 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMass;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMassExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentigramsTest() =>
+            Assert.Equal(Mass.FromCentigrams(2), 2.Centigrams());
+
+        [Fact]
+        public void NumberToDecagramsTest() =>
+            Assert.Equal(Mass.FromDecagrams(2), 2.Decagrams());
+
+        [Fact]
+        public void NumberToDecigramsTest() =>
+            Assert.Equal(Mass.FromDecigrams(2), 2.Decigrams());
+
+        [Fact]
+        public void NumberToEarthMassesTest() =>
+            Assert.Equal(Mass.FromEarthMasses(2), 2.EarthMasses());
+
+        [Fact]
+        public void NumberToGrainsTest() =>
+            Assert.Equal(Mass.FromGrains(2), 2.Grains());
+
+        [Fact]
+        public void NumberToGramsTest() =>
+            Assert.Equal(Mass.FromGrams(2), 2.Grams());
+
+        [Fact]
+        public void NumberToHectogramsTest() =>
+            Assert.Equal(Mass.FromHectograms(2), 2.Hectograms());
+
+        [Fact]
+        public void NumberToKilogramsTest() =>
+            Assert.Equal(Mass.FromKilograms(2), 2.Kilograms());
+
+        [Fact]
+        public void NumberToKilopoundsTest() =>
+            Assert.Equal(Mass.FromKilopounds(2), 2.Kilopounds());
+
+        [Fact]
+        public void NumberToKilotonnesTest() =>
+            Assert.Equal(Mass.FromKilotonnes(2), 2.Kilotonnes());
+
+        [Fact]
+        public void NumberToLongHundredweightTest() =>
+            Assert.Equal(Mass.FromLongHundredweight(2), 2.LongHundredweight());
+
+        [Fact]
+        public void NumberToLongTonsTest() =>
+            Assert.Equal(Mass.FromLongTons(2), 2.LongTons());
+
+        [Fact]
+        public void NumberToMegapoundsTest() =>
+            Assert.Equal(Mass.FromMegapounds(2), 2.Megapounds());
+
+        [Fact]
+        public void NumberToMegatonnesTest() =>
+            Assert.Equal(Mass.FromMegatonnes(2), 2.Megatonnes());
+
+        [Fact]
+        public void NumberToMicrogramsTest() =>
+            Assert.Equal(Mass.FromMicrograms(2), 2.Micrograms());
+
+        [Fact]
+        public void NumberToMilligramsTest() =>
+            Assert.Equal(Mass.FromMilligrams(2), 2.Milligrams());
+
+        [Fact]
+        public void NumberToNanogramsTest() =>
+            Assert.Equal(Mass.FromNanograms(2), 2.Nanograms());
+
+        [Fact]
+        public void NumberToOuncesTest() =>
+            Assert.Equal(Mass.FromOunces(2), 2.Ounces());
+
+        [Fact]
+        public void NumberToPoundsTest() =>
+            Assert.Equal(Mass.FromPounds(2), 2.Pounds());
+
+        [Fact]
+        public void NumberToShortHundredweightTest() =>
+            Assert.Equal(Mass.FromShortHundredweight(2), 2.ShortHundredweight());
+
+        [Fact]
+        public void NumberToShortTonsTest() =>
+            Assert.Equal(Mass.FromShortTons(2), 2.ShortTons());
+
+        [Fact]
+        public void NumberToSlugsTest() =>
+            Assert.Equal(Mass.FromSlugs(2), 2.Slugs());
+
+        [Fact]
+        public void NumberToSolarMassesTest() =>
+            Assert.Equal(Mass.FromSolarMasses(2), 2.SolarMasses());
+
+        [Fact]
+        public void NumberToStoneTest() =>
+            Assert.Equal(Mass.FromStone(2), 2.Stone());
+
+        [Fact]
+        public void NumberToTonnesTest() =>
+            Assert.Equal(Mass.FromTonnes(2), 2.Tonnes());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFlowExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFlowExtensionsTest.g.cs
new file mode 100644
index 0000000000..4a18fd2c38
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFlowExtensionsTest.g.cs
@@ -0,0 +1,160 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMassFlow;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMassFlowExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentigramsPerDayTest() =>
+            Assert.Equal(MassFlow.FromCentigramsPerDay(2), 2.CentigramsPerDay());
+
+        [Fact]
+        public void NumberToCentigramsPerSecondTest() =>
+            Assert.Equal(MassFlow.FromCentigramsPerSecond(2), 2.CentigramsPerSecond());
+
+        [Fact]
+        public void NumberToDecagramsPerDayTest() =>
+            Assert.Equal(MassFlow.FromDecagramsPerDay(2), 2.DecagramsPerDay());
+
+        [Fact]
+        public void NumberToDecagramsPerSecondTest() =>
+            Assert.Equal(MassFlow.FromDecagramsPerSecond(2), 2.DecagramsPerSecond());
+
+        [Fact]
+        public void NumberToDecigramsPerDayTest() =>
+            Assert.Equal(MassFlow.FromDecigramsPerDay(2), 2.DecigramsPerDay());
+
+        [Fact]
+        public void NumberToDecigramsPerSecondTest() =>
+            Assert.Equal(MassFlow.FromDecigramsPerSecond(2), 2.DecigramsPerSecond());
+
+        [Fact]
+        public void NumberToGramsPerDayTest() =>
+            Assert.Equal(MassFlow.FromGramsPerDay(2), 2.GramsPerDay());
+
+        [Fact]
+        public void NumberToGramsPerHourTest() =>
+            Assert.Equal(MassFlow.FromGramsPerHour(2), 2.GramsPerHour());
+
+        [Fact]
+        public void NumberToGramsPerSecondTest() =>
+            Assert.Equal(MassFlow.FromGramsPerSecond(2), 2.GramsPerSecond());
+
+        [Fact]
+        public void NumberToHectogramsPerDayTest() =>
+            Assert.Equal(MassFlow.FromHectogramsPerDay(2), 2.HectogramsPerDay());
+
+        [Fact]
+        public void NumberToHectogramsPerSecondTest() =>
+            Assert.Equal(MassFlow.FromHectogramsPerSecond(2), 2.HectogramsPerSecond());
+
+        [Fact]
+        public void NumberToKilogramsPerDayTest() =>
+            Assert.Equal(MassFlow.FromKilogramsPerDay(2), 2.KilogramsPerDay());
+
+        [Fact]
+        public void NumberToKilogramsPerHourTest() =>
+            Assert.Equal(MassFlow.FromKilogramsPerHour(2), 2.KilogramsPerHour());
+
+        [Fact]
+        public void NumberToKilogramsPerMinuteTest() =>
+            Assert.Equal(MassFlow.FromKilogramsPerMinute(2), 2.KilogramsPerMinute());
+
+        [Fact]
+        public void NumberToKilogramsPerSecondTest() =>
+            Assert.Equal(MassFlow.FromKilogramsPerSecond(2), 2.KilogramsPerSecond());
+
+        [Fact]
+        public void NumberToMegagramsPerDayTest() =>
+            Assert.Equal(MassFlow.FromMegagramsPerDay(2), 2.MegagramsPerDay());
+
+        [Fact]
+        public void NumberToMegapoundsPerDayTest() =>
+            Assert.Equal(MassFlow.FromMegapoundsPerDay(2), 2.MegapoundsPerDay());
+
+        [Fact]
+        public void NumberToMegapoundsPerHourTest() =>
+            Assert.Equal(MassFlow.FromMegapoundsPerHour(2), 2.MegapoundsPerHour());
+
+        [Fact]
+        public void NumberToMegapoundsPerMinuteTest() =>
+            Assert.Equal(MassFlow.FromMegapoundsPerMinute(2), 2.MegapoundsPerMinute());
+
+        [Fact]
+        public void NumberToMegapoundsPerSecondTest() =>
+            Assert.Equal(MassFlow.FromMegapoundsPerSecond(2), 2.MegapoundsPerSecond());
+
+        [Fact]
+        public void NumberToMicrogramsPerDayTest() =>
+            Assert.Equal(MassFlow.FromMicrogramsPerDay(2), 2.MicrogramsPerDay());
+
+        [Fact]
+        public void NumberToMicrogramsPerSecondTest() =>
+            Assert.Equal(MassFlow.FromMicrogramsPerSecond(2), 2.MicrogramsPerSecond());
+
+        [Fact]
+        public void NumberToMilligramsPerDayTest() =>
+            Assert.Equal(MassFlow.FromMilligramsPerDay(2), 2.MilligramsPerDay());
+
+        [Fact]
+        public void NumberToMilligramsPerSecondTest() =>
+            Assert.Equal(MassFlow.FromMilligramsPerSecond(2), 2.MilligramsPerSecond());
+
+        [Fact]
+        public void NumberToNanogramsPerDayTest() =>
+            Assert.Equal(MassFlow.FromNanogramsPerDay(2), 2.NanogramsPerDay());
+
+        [Fact]
+        public void NumberToNanogramsPerSecondTest() =>
+            Assert.Equal(MassFlow.FromNanogramsPerSecond(2), 2.NanogramsPerSecond());
+
+        [Fact]
+        public void NumberToPoundsPerDayTest() =>
+            Assert.Equal(MassFlow.FromPoundsPerDay(2), 2.PoundsPerDay());
+
+        [Fact]
+        public void NumberToPoundsPerHourTest() =>
+            Assert.Equal(MassFlow.FromPoundsPerHour(2), 2.PoundsPerHour());
+
+        [Fact]
+        public void NumberToPoundsPerMinuteTest() =>
+            Assert.Equal(MassFlow.FromPoundsPerMinute(2), 2.PoundsPerMinute());
+
+        [Fact]
+        public void NumberToPoundsPerSecondTest() =>
+            Assert.Equal(MassFlow.FromPoundsPerSecond(2), 2.PoundsPerSecond());
+
+        [Fact]
+        public void NumberToShortTonsPerHourTest() =>
+            Assert.Equal(MassFlow.FromShortTonsPerHour(2), 2.ShortTonsPerHour());
+
+        [Fact]
+        public void NumberToTonnesPerDayTest() =>
+            Assert.Equal(MassFlow.FromTonnesPerDay(2), 2.TonnesPerDay());
+
+        [Fact]
+        public void NumberToTonnesPerHourTest() =>
+            Assert.Equal(MassFlow.FromTonnesPerHour(2), 2.TonnesPerHour());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFluxExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFluxExtensionsTest.g.cs
new file mode 100644
index 0000000000..e87a915ee0
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFluxExtensionsTest.g.cs
@@ -0,0 +1,36 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMassFlux;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMassFluxExtensionsTests
+    {
+        [Fact]
+        public void NumberToGramsPerSecondPerSquareMeterTest() =>
+            Assert.Equal(MassFlux.FromGramsPerSecondPerSquareMeter(2), 2.GramsPerSecondPerSquareMeter());
+
+        [Fact]
+        public void NumberToKilogramsPerSecondPerSquareMeterTest() =>
+            Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(2), 2.KilogramsPerSecondPerSquareMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFractionExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFractionExtensionsTest.g.cs
new file mode 100644
index 0000000000..30a444bb35
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassFractionExtensionsTest.g.cs
@@ -0,0 +1,124 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMassFraction;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMassFractionExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentigramsPerGramTest() =>
+            Assert.Equal(MassFraction.FromCentigramsPerGram(2), 2.CentigramsPerGram());
+
+        [Fact]
+        public void NumberToCentigramsPerKilogramTest() =>
+            Assert.Equal(MassFraction.FromCentigramsPerKilogram(2), 2.CentigramsPerKilogram());
+
+        [Fact]
+        public void NumberToDecagramsPerGramTest() =>
+            Assert.Equal(MassFraction.FromDecagramsPerGram(2), 2.DecagramsPerGram());
+
+        [Fact]
+        public void NumberToDecagramsPerKilogramTest() =>
+            Assert.Equal(MassFraction.FromDecagramsPerKilogram(2), 2.DecagramsPerKilogram());
+
+        [Fact]
+        public void NumberToDecigramsPerGramTest() =>
+            Assert.Equal(MassFraction.FromDecigramsPerGram(2), 2.DecigramsPerGram());
+
+        [Fact]
+        public void NumberToDecigramsPerKilogramTest() =>
+            Assert.Equal(MassFraction.FromDecigramsPerKilogram(2), 2.DecigramsPerKilogram());
+
+        [Fact]
+        public void NumberToDecimalFractionsTest() =>
+            Assert.Equal(MassFraction.FromDecimalFractions(2), 2.DecimalFractions());
+
+        [Fact]
+        public void NumberToGramsPerGramTest() =>
+            Assert.Equal(MassFraction.FromGramsPerGram(2), 2.GramsPerGram());
+
+        [Fact]
+        public void NumberToGramsPerKilogramTest() =>
+            Assert.Equal(MassFraction.FromGramsPerKilogram(2), 2.GramsPerKilogram());
+
+        [Fact]
+        public void NumberToHectogramsPerGramTest() =>
+            Assert.Equal(MassFraction.FromHectogramsPerGram(2), 2.HectogramsPerGram());
+
+        [Fact]
+        public void NumberToHectogramsPerKilogramTest() =>
+            Assert.Equal(MassFraction.FromHectogramsPerKilogram(2), 2.HectogramsPerKilogram());
+
+        [Fact]
+        public void NumberToKilogramsPerGramTest() =>
+            Assert.Equal(MassFraction.FromKilogramsPerGram(2), 2.KilogramsPerGram());
+
+        [Fact]
+        public void NumberToKilogramsPerKilogramTest() =>
+            Assert.Equal(MassFraction.FromKilogramsPerKilogram(2), 2.KilogramsPerKilogram());
+
+        [Fact]
+        public void NumberToMicrogramsPerGramTest() =>
+            Assert.Equal(MassFraction.FromMicrogramsPerGram(2), 2.MicrogramsPerGram());
+
+        [Fact]
+        public void NumberToMicrogramsPerKilogramTest() =>
+            Assert.Equal(MassFraction.FromMicrogramsPerKilogram(2), 2.MicrogramsPerKilogram());
+
+        [Fact]
+        public void NumberToMilligramsPerGramTest() =>
+            Assert.Equal(MassFraction.FromMilligramsPerGram(2), 2.MilligramsPerGram());
+
+        [Fact]
+        public void NumberToMilligramsPerKilogramTest() =>
+            Assert.Equal(MassFraction.FromMilligramsPerKilogram(2), 2.MilligramsPerKilogram());
+
+        [Fact]
+        public void NumberToNanogramsPerGramTest() =>
+            Assert.Equal(MassFraction.FromNanogramsPerGram(2), 2.NanogramsPerGram());
+
+        [Fact]
+        public void NumberToNanogramsPerKilogramTest() =>
+            Assert.Equal(MassFraction.FromNanogramsPerKilogram(2), 2.NanogramsPerKilogram());
+
+        [Fact]
+        public void NumberToPartsPerBillionTest() =>
+            Assert.Equal(MassFraction.FromPartsPerBillion(2), 2.PartsPerBillion());
+
+        [Fact]
+        public void NumberToPartsPerMillionTest() =>
+            Assert.Equal(MassFraction.FromPartsPerMillion(2), 2.PartsPerMillion());
+
+        [Fact]
+        public void NumberToPartsPerThousandTest() =>
+            Assert.Equal(MassFraction.FromPartsPerThousand(2), 2.PartsPerThousand());
+
+        [Fact]
+        public void NumberToPartsPerTrillionTest() =>
+            Assert.Equal(MassFraction.FromPartsPerTrillion(2), 2.PartsPerTrillion());
+
+        [Fact]
+        public void NumberToPercentTest() =>
+            Assert.Equal(MassFraction.FromPercent(2), 2.Percent());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassMomentOfInertiaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassMomentOfInertiaExtensionsTest.g.cs
new file mode 100644
index 0000000000..533cb88df1
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassMomentOfInertiaExtensionsTest.g.cs
@@ -0,0 +1,140 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMassMomentOfInertia;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMassMomentOfInertiaExtensionsTests
+    {
+        [Fact]
+        public void NumberToGramSquareCentimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromGramSquareCentimeters(2), 2.GramSquareCentimeters());
+
+        [Fact]
+        public void NumberToGramSquareDecimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromGramSquareDecimeters(2), 2.GramSquareDecimeters());
+
+        [Fact]
+        public void NumberToGramSquareMetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromGramSquareMeters(2), 2.GramSquareMeters());
+
+        [Fact]
+        public void NumberToGramSquareMillimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromGramSquareMillimeters(2), 2.GramSquareMillimeters());
+
+        [Fact]
+        public void NumberToKilogramSquareCentimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromKilogramSquareCentimeters(2), 2.KilogramSquareCentimeters());
+
+        [Fact]
+        public void NumberToKilogramSquareDecimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromKilogramSquareDecimeters(2), 2.KilogramSquareDecimeters());
+
+        [Fact]
+        public void NumberToKilogramSquareMetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromKilogramSquareMeters(2), 2.KilogramSquareMeters());
+
+        [Fact]
+        public void NumberToKilogramSquareMillimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromKilogramSquareMillimeters(2), 2.KilogramSquareMillimeters());
+
+        [Fact]
+        public void NumberToKilotonneSquareCentimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromKilotonneSquareCentimeters(2), 2.KilotonneSquareCentimeters());
+
+        [Fact]
+        public void NumberToKilotonneSquareDecimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromKilotonneSquareDecimeters(2), 2.KilotonneSquareDecimeters());
+
+        [Fact]
+        public void NumberToKilotonneSquareMetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromKilotonneSquareMeters(2), 2.KilotonneSquareMeters());
+
+        [Fact]
+        public void NumberToKilotonneSquareMilimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromKilotonneSquareMilimeters(2), 2.KilotonneSquareMilimeters());
+
+        [Fact]
+        public void NumberToMegatonneSquareCentimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromMegatonneSquareCentimeters(2), 2.MegatonneSquareCentimeters());
+
+        [Fact]
+        public void NumberToMegatonneSquareDecimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromMegatonneSquareDecimeters(2), 2.MegatonneSquareDecimeters());
+
+        [Fact]
+        public void NumberToMegatonneSquareMetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromMegatonneSquareMeters(2), 2.MegatonneSquareMeters());
+
+        [Fact]
+        public void NumberToMegatonneSquareMilimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromMegatonneSquareMilimeters(2), 2.MegatonneSquareMilimeters());
+
+        [Fact]
+        public void NumberToMilligramSquareCentimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromMilligramSquareCentimeters(2), 2.MilligramSquareCentimeters());
+
+        [Fact]
+        public void NumberToMilligramSquareDecimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromMilligramSquareDecimeters(2), 2.MilligramSquareDecimeters());
+
+        [Fact]
+        public void NumberToMilligramSquareMetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromMilligramSquareMeters(2), 2.MilligramSquareMeters());
+
+        [Fact]
+        public void NumberToMilligramSquareMillimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromMilligramSquareMillimeters(2), 2.MilligramSquareMillimeters());
+
+        [Fact]
+        public void NumberToPoundSquareFeetTest() =>
+            Assert.Equal(MassMomentOfInertia.FromPoundSquareFeet(2), 2.PoundSquareFeet());
+
+        [Fact]
+        public void NumberToPoundSquareInchesTest() =>
+            Assert.Equal(MassMomentOfInertia.FromPoundSquareInches(2), 2.PoundSquareInches());
+
+        [Fact]
+        public void NumberToSlugSquareFeetTest() =>
+            Assert.Equal(MassMomentOfInertia.FromSlugSquareFeet(2), 2.SlugSquareFeet());
+
+        [Fact]
+        public void NumberToSlugSquareInchesTest() =>
+            Assert.Equal(MassMomentOfInertia.FromSlugSquareInches(2), 2.SlugSquareInches());
+
+        [Fact]
+        public void NumberToTonneSquareCentimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromTonneSquareCentimeters(2), 2.TonneSquareCentimeters());
+
+        [Fact]
+        public void NumberToTonneSquareDecimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromTonneSquareDecimeters(2), 2.TonneSquareDecimeters());
+
+        [Fact]
+        public void NumberToTonneSquareMetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromTonneSquareMeters(2), 2.TonneSquareMeters());
+
+        [Fact]
+        public void NumberToTonneSquareMilimetersTest() =>
+            Assert.Equal(MassMomentOfInertia.FromTonneSquareMilimeters(2), 2.TonneSquareMilimeters());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEnergyExtensionsTest.g.cs
new file mode 100644
index 0000000000..888625a0aa
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEnergyExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMolarEnergy;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMolarEnergyExtensionsTests
+    {
+        [Fact]
+        public void NumberToJoulesPerMoleTest() =>
+            Assert.Equal(MolarEnergy.FromJoulesPerMole(2), 2.JoulesPerMole());
+
+        [Fact]
+        public void NumberToKilojoulesPerMoleTest() =>
+            Assert.Equal(MolarEnergy.FromKilojoulesPerMole(2), 2.KilojoulesPerMole());
+
+        [Fact]
+        public void NumberToMegajoulesPerMoleTest() =>
+            Assert.Equal(MolarEnergy.FromMegajoulesPerMole(2), 2.MegajoulesPerMole());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEntropyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEntropyExtensionsTest.g.cs
new file mode 100644
index 0000000000..c38670149e
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarEntropyExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMolarEntropy;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMolarEntropyExtensionsTests
+    {
+        [Fact]
+        public void NumberToJoulesPerMoleKelvinTest() =>
+            Assert.Equal(MolarEntropy.FromJoulesPerMoleKelvin(2), 2.JoulesPerMoleKelvin());
+
+        [Fact]
+        public void NumberToKilojoulesPerMoleKelvinTest() =>
+            Assert.Equal(MolarEntropy.FromKilojoulesPerMoleKelvin(2), 2.KilojoulesPerMoleKelvin());
+
+        [Fact]
+        public void NumberToMegajoulesPerMoleKelvinTest() =>
+            Assert.Equal(MolarEntropy.FromMegajoulesPerMoleKelvin(2), 2.MegajoulesPerMoleKelvin());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
new file mode 100644
index 0000000000..435f467260
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarMassExtensionsTest.g.cs
@@ -0,0 +1,76 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMolarMass;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMolarMassExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentigramsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromCentigramsPerMole(2), 2.CentigramsPerMole());
+
+        [Fact]
+        public void NumberToDecagramsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromDecagramsPerMole(2), 2.DecagramsPerMole());
+
+        [Fact]
+        public void NumberToDecigramsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromDecigramsPerMole(2), 2.DecigramsPerMole());
+
+        [Fact]
+        public void NumberToGramsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromGramsPerMole(2), 2.GramsPerMole());
+
+        [Fact]
+        public void NumberToHectogramsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromHectogramsPerMole(2), 2.HectogramsPerMole());
+
+        [Fact]
+        public void NumberToKilogramsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromKilogramsPerMole(2), 2.KilogramsPerMole());
+
+        [Fact]
+        public void NumberToKilopoundsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromKilopoundsPerMole(2), 2.KilopoundsPerMole());
+
+        [Fact]
+        public void NumberToMegapoundsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromMegapoundsPerMole(2), 2.MegapoundsPerMole());
+
+        [Fact]
+        public void NumberToMicrogramsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromMicrogramsPerMole(2), 2.MicrogramsPerMole());
+
+        [Fact]
+        public void NumberToMilligramsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromMilligramsPerMole(2), 2.MilligramsPerMole());
+
+        [Fact]
+        public void NumberToNanogramsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromNanogramsPerMole(2), 2.NanogramsPerMole());
+
+        [Fact]
+        public void NumberToPoundsPerMoleTest() =>
+            Assert.Equal(MolarMass.FromPoundsPerMole(2), 2.PoundsPerMole());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarityExtensionsTest.g.cs
new file mode 100644
index 0000000000..6e77305d5d
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMolarityExtensionsTest.g.cs
@@ -0,0 +1,60 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToMolarity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToMolarityExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentimolesPerLiterTest() =>
+            Assert.Equal(Molarity.FromCentimolesPerLiter(2), 2.CentimolesPerLiter());
+
+        [Fact]
+        public void NumberToDecimolesPerLiterTest() =>
+            Assert.Equal(Molarity.FromDecimolesPerLiter(2), 2.DecimolesPerLiter());
+
+        [Fact]
+        public void NumberToMicromolesPerLiterTest() =>
+            Assert.Equal(Molarity.FromMicromolesPerLiter(2), 2.MicromolesPerLiter());
+
+        [Fact]
+        public void NumberToMillimolesPerLiterTest() =>
+            Assert.Equal(Molarity.FromMillimolesPerLiter(2), 2.MillimolesPerLiter());
+
+        [Fact]
+        public void NumberToMolesPerCubicMeterTest() =>
+            Assert.Equal(Molarity.FromMolesPerCubicMeter(2), 2.MolesPerCubicMeter());
+
+        [Fact]
+        public void NumberToMolesPerLiterTest() =>
+            Assert.Equal(Molarity.FromMolesPerLiter(2), 2.MolesPerLiter());
+
+        [Fact]
+        public void NumberToNanomolesPerLiterTest() =>
+            Assert.Equal(Molarity.FromNanomolesPerLiter(2), 2.NanomolesPerLiter());
+
+        [Fact]
+        public void NumberToPicomolesPerLiterTest() =>
+            Assert.Equal(Molarity.FromPicomolesPerLiter(2), 2.PicomolesPerLiter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermeabilityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermeabilityExtensionsTest.g.cs
new file mode 100644
index 0000000000..adcc4a1ec7
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermeabilityExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToPermeability;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToPermeabilityExtensionsTests
+    {
+        [Fact]
+        public void NumberToHenriesPerMeterTest() =>
+            Assert.Equal(Permeability.FromHenriesPerMeter(2), 2.HenriesPerMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermittivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermittivityExtensionsTest.g.cs
new file mode 100644
index 0000000000..7dbc097268
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPermittivityExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToPermittivity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToPermittivityExtensionsTests
+    {
+        [Fact]
+        public void NumberToFaradsPerMeterTest() =>
+            Assert.Equal(Permittivity.FromFaradsPerMeter(2), 2.FaradsPerMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
new file mode 100644
index 0000000000..44a77db4e3
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerDensityExtensionsTest.g.cs
@@ -0,0 +1,204 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToPowerDensity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToPowerDensityExtensionsTests
+    {
+        [Fact]
+        public void NumberToDecawattsPerCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromDecawattsPerCubicFoot(2), 2.DecawattsPerCubicFoot());
+
+        [Fact]
+        public void NumberToDecawattsPerCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromDecawattsPerCubicInch(2), 2.DecawattsPerCubicInch());
+
+        [Fact]
+        public void NumberToDecawattsPerCubicMeterTest() =>
+            Assert.Equal(PowerDensity.FromDecawattsPerCubicMeter(2), 2.DecawattsPerCubicMeter());
+
+        [Fact]
+        public void NumberToDecawattsPerLiterTest() =>
+            Assert.Equal(PowerDensity.FromDecawattsPerLiter(2), 2.DecawattsPerLiter());
+
+        [Fact]
+        public void NumberToDeciwattsPerCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromDeciwattsPerCubicFoot(2), 2.DeciwattsPerCubicFoot());
+
+        [Fact]
+        public void NumberToDeciwattsPerCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromDeciwattsPerCubicInch(2), 2.DeciwattsPerCubicInch());
+
+        [Fact]
+        public void NumberToDeciwattsPerCubicMeterTest() =>
+            Assert.Equal(PowerDensity.FromDeciwattsPerCubicMeter(2), 2.DeciwattsPerCubicMeter());
+
+        [Fact]
+        public void NumberToDeciwattsPerLiterTest() =>
+            Assert.Equal(PowerDensity.FromDeciwattsPerLiter(2), 2.DeciwattsPerLiter());
+
+        [Fact]
+        public void NumberToGigawattsPerCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromGigawattsPerCubicFoot(2), 2.GigawattsPerCubicFoot());
+
+        [Fact]
+        public void NumberToGigawattsPerCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromGigawattsPerCubicInch(2), 2.GigawattsPerCubicInch());
+
+        [Fact]
+        public void NumberToGigawattsPerCubicMeterTest() =>
+            Assert.Equal(PowerDensity.FromGigawattsPerCubicMeter(2), 2.GigawattsPerCubicMeter());
+
+        [Fact]
+        public void NumberToGigawattsPerLiterTest() =>
+            Assert.Equal(PowerDensity.FromGigawattsPerLiter(2), 2.GigawattsPerLiter());
+
+        [Fact]
+        public void NumberToKilowattsPerCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromKilowattsPerCubicFoot(2), 2.KilowattsPerCubicFoot());
+
+        [Fact]
+        public void NumberToKilowattsPerCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromKilowattsPerCubicInch(2), 2.KilowattsPerCubicInch());
+
+        [Fact]
+        public void NumberToKilowattsPerCubicMeterTest() =>
+            Assert.Equal(PowerDensity.FromKilowattsPerCubicMeter(2), 2.KilowattsPerCubicMeter());
+
+        [Fact]
+        public void NumberToKilowattsPerLiterTest() =>
+            Assert.Equal(PowerDensity.FromKilowattsPerLiter(2), 2.KilowattsPerLiter());
+
+        [Fact]
+        public void NumberToMegawattsPerCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromMegawattsPerCubicFoot(2), 2.MegawattsPerCubicFoot());
+
+        [Fact]
+        public void NumberToMegawattsPerCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromMegawattsPerCubicInch(2), 2.MegawattsPerCubicInch());
+
+        [Fact]
+        public void NumberToMegawattsPerCubicMeterTest() =>
+            Assert.Equal(PowerDensity.FromMegawattsPerCubicMeter(2), 2.MegawattsPerCubicMeter());
+
+        [Fact]
+        public void NumberToMegawattsPerLiterTest() =>
+            Assert.Equal(PowerDensity.FromMegawattsPerLiter(2), 2.MegawattsPerLiter());
+
+        [Fact]
+        public void NumberToMicrowattsPerCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromMicrowattsPerCubicFoot(2), 2.MicrowattsPerCubicFoot());
+
+        [Fact]
+        public void NumberToMicrowattsPerCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromMicrowattsPerCubicInch(2), 2.MicrowattsPerCubicInch());
+
+        [Fact]
+        public void NumberToMicrowattsPerCubicMeterTest() =>
+            Assert.Equal(PowerDensity.FromMicrowattsPerCubicMeter(2), 2.MicrowattsPerCubicMeter());
+
+        [Fact]
+        public void NumberToMicrowattsPerLiterTest() =>
+            Assert.Equal(PowerDensity.FromMicrowattsPerLiter(2), 2.MicrowattsPerLiter());
+
+        [Fact]
+        public void NumberToMilliwattsPerCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromMilliwattsPerCubicFoot(2), 2.MilliwattsPerCubicFoot());
+
+        [Fact]
+        public void NumberToMilliwattsPerCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromMilliwattsPerCubicInch(2), 2.MilliwattsPerCubicInch());
+
+        [Fact]
+        public void NumberToMilliwattsPerCubicMeterTest() =>
+            Assert.Equal(PowerDensity.FromMilliwattsPerCubicMeter(2), 2.MilliwattsPerCubicMeter());
+
+        [Fact]
+        public void NumberToMilliwattsPerLiterTest() =>
+            Assert.Equal(PowerDensity.FromMilliwattsPerLiter(2), 2.MilliwattsPerLiter());
+
+        [Fact]
+        public void NumberToNanowattsPerCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromNanowattsPerCubicFoot(2), 2.NanowattsPerCubicFoot());
+
+        [Fact]
+        public void NumberToNanowattsPerCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromNanowattsPerCubicInch(2), 2.NanowattsPerCubicInch());
+
+        [Fact]
+        public void NumberToNanowattsPerCubicMeterTest() =>
+            Assert.Equal(PowerDensity.FromNanowattsPerCubicMeter(2), 2.NanowattsPerCubicMeter());
+
+        [Fact]
+        public void NumberToNanowattsPerLiterTest() =>
+            Assert.Equal(PowerDensity.FromNanowattsPerLiter(2), 2.NanowattsPerLiter());
+
+        [Fact]
+        public void NumberToPicowattsPerCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromPicowattsPerCubicFoot(2), 2.PicowattsPerCubicFoot());
+
+        [Fact]
+        public void NumberToPicowattsPerCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromPicowattsPerCubicInch(2), 2.PicowattsPerCubicInch());
+
+        [Fact]
+        public void NumberToPicowattsPerCubicMeterTest() =>
+            Assert.Equal(PowerDensity.FromPicowattsPerCubicMeter(2), 2.PicowattsPerCubicMeter());
+
+        [Fact]
+        public void NumberToPicowattsPerLiterTest() =>
+            Assert.Equal(PowerDensity.FromPicowattsPerLiter(2), 2.PicowattsPerLiter());
+
+        [Fact]
+        public void NumberToTerawattsPerCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromTerawattsPerCubicFoot(2), 2.TerawattsPerCubicFoot());
+
+        [Fact]
+        public void NumberToTerawattsPerCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromTerawattsPerCubicInch(2), 2.TerawattsPerCubicInch());
+
+        [Fact]
+        public void NumberToTerawattsPerCubicMeterTest() =>
+            Assert.Equal(PowerDensity.FromTerawattsPerCubicMeter(2), 2.TerawattsPerCubicMeter());
+
+        [Fact]
+        public void NumberToTerawattsPerLiterTest() =>
+            Assert.Equal(PowerDensity.FromTerawattsPerLiter(2), 2.TerawattsPerLiter());
+
+        [Fact]
+        public void NumberToWattsPerCubicFootTest() =>
+            Assert.Equal(PowerDensity.FromWattsPerCubicFoot(2), 2.WattsPerCubicFoot());
+
+        [Fact]
+        public void NumberToWattsPerCubicInchTest() =>
+            Assert.Equal(PowerDensity.FromWattsPerCubicInch(2), 2.WattsPerCubicInch());
+
+        [Fact]
+        public void NumberToWattsPerCubicMeterTest() =>
+            Assert.Equal(PowerDensity.FromWattsPerCubicMeter(2), 2.WattsPerCubicMeter());
+
+        [Fact]
+        public void NumberToWattsPerLiterTest() =>
+            Assert.Equal(PowerDensity.FromWattsPerLiter(2), 2.WattsPerLiter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs
new file mode 100644
index 0000000000..a9cf5b5f94
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerExtensionsTest.g.cs
@@ -0,0 +1,128 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToPower;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToPowerExtensionsTests
+    {
+        [Fact]
+        public void NumberToBoilerHorsepowerTest() =>
+            Assert.Equal(Power.FromBoilerHorsepower(2), 2.BoilerHorsepower());
+
+        [Fact]
+        public void NumberToBritishThermalUnitsPerHourTest() =>
+            Assert.Equal(Power.FromBritishThermalUnitsPerHour(2), 2.BritishThermalUnitsPerHour());
+
+        [Fact]
+        public void NumberToDecawattsTest() =>
+            Assert.Equal(Power.FromDecawatts(2), 2.Decawatts());
+
+        [Fact]
+        public void NumberToDeciwattsTest() =>
+            Assert.Equal(Power.FromDeciwatts(2), 2.Deciwatts());
+
+        [Fact]
+        public void NumberToElectricalHorsepowerTest() =>
+            Assert.Equal(Power.FromElectricalHorsepower(2), 2.ElectricalHorsepower());
+
+        [Fact]
+        public void NumberToFemtowattsTest() =>
+            Assert.Equal(Power.FromFemtowatts(2), 2.Femtowatts());
+
+        [Fact]
+        public void NumberToGigajoulesPerHourTest() =>
+            Assert.Equal(Power.FromGigajoulesPerHour(2), 2.GigajoulesPerHour());
+
+        [Fact]
+        public void NumberToGigawattsTest() =>
+            Assert.Equal(Power.FromGigawatts(2), 2.Gigawatts());
+
+        [Fact]
+        public void NumberToHydraulicHorsepowerTest() =>
+            Assert.Equal(Power.FromHydraulicHorsepower(2), 2.HydraulicHorsepower());
+
+        [Fact]
+        public void NumberToJoulesPerHourTest() =>
+            Assert.Equal(Power.FromJoulesPerHour(2), 2.JoulesPerHour());
+
+        [Fact]
+        public void NumberToKilobritishThermalUnitsPerHourTest() =>
+            Assert.Equal(Power.FromKilobritishThermalUnitsPerHour(2), 2.KilobritishThermalUnitsPerHour());
+
+        [Fact]
+        public void NumberToKilojoulesPerHourTest() =>
+            Assert.Equal(Power.FromKilojoulesPerHour(2), 2.KilojoulesPerHour());
+
+        [Fact]
+        public void NumberToKilowattsTest() =>
+            Assert.Equal(Power.FromKilowatts(2), 2.Kilowatts());
+
+        [Fact]
+        public void NumberToMechanicalHorsepowerTest() =>
+            Assert.Equal(Power.FromMechanicalHorsepower(2), 2.MechanicalHorsepower());
+
+        [Fact]
+        public void NumberToMegajoulesPerHourTest() =>
+            Assert.Equal(Power.FromMegajoulesPerHour(2), 2.MegajoulesPerHour());
+
+        [Fact]
+        public void NumberToMegawattsTest() =>
+            Assert.Equal(Power.FromMegawatts(2), 2.Megawatts());
+
+        [Fact]
+        public void NumberToMetricHorsepowerTest() =>
+            Assert.Equal(Power.FromMetricHorsepower(2), 2.MetricHorsepower());
+
+        [Fact]
+        public void NumberToMicrowattsTest() =>
+            Assert.Equal(Power.FromMicrowatts(2), 2.Microwatts());
+
+        [Fact]
+        public void NumberToMillijoulesPerHourTest() =>
+            Assert.Equal(Power.FromMillijoulesPerHour(2), 2.MillijoulesPerHour());
+
+        [Fact]
+        public void NumberToMilliwattsTest() =>
+            Assert.Equal(Power.FromMilliwatts(2), 2.Milliwatts());
+
+        [Fact]
+        public void NumberToNanowattsTest() =>
+            Assert.Equal(Power.FromNanowatts(2), 2.Nanowatts());
+
+        [Fact]
+        public void NumberToPetawattsTest() =>
+            Assert.Equal(Power.FromPetawatts(2), 2.Petawatts());
+
+        [Fact]
+        public void NumberToPicowattsTest() =>
+            Assert.Equal(Power.FromPicowatts(2), 2.Picowatts());
+
+        [Fact]
+        public void NumberToTerawattsTest() =>
+            Assert.Equal(Power.FromTerawatts(2), 2.Terawatts());
+
+        [Fact]
+        public void NumberToWattsTest() =>
+            Assert.Equal(Power.FromWatts(2), 2.Watts());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerRatioExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerRatioExtensionsTest.g.cs
new file mode 100644
index 0000000000..f9cb9ce23d
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPowerRatioExtensionsTest.g.cs
@@ -0,0 +1,36 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToPowerRatio;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToPowerRatioExtensionsTests
+    {
+        [Fact]
+        public void NumberToDecibelMilliwattsTest() =>
+            Assert.Equal(PowerRatio.FromDecibelMilliwatts(2), 2.DecibelMilliwatts());
+
+        [Fact]
+        public void NumberToDecibelWattsTest() =>
+            Assert.Equal(PowerRatio.FromDecibelWatts(2), 2.DecibelWatts());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs
new file mode 100644
index 0000000000..5187b44395
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureChangeRateExtensionsTest.g.cs
@@ -0,0 +1,56 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToPressureChangeRate;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToPressureChangeRateExtensionsTests
+    {
+        [Fact]
+        public void NumberToAtmospheresPerSecondTest() =>
+            Assert.Equal(PressureChangeRate.FromAtmospheresPerSecond(2), 2.AtmospheresPerSecond());
+
+        [Fact]
+        public void NumberToKilopascalsPerMinuteTest() =>
+            Assert.Equal(PressureChangeRate.FromKilopascalsPerMinute(2), 2.KilopascalsPerMinute());
+
+        [Fact]
+        public void NumberToKilopascalsPerSecondTest() =>
+            Assert.Equal(PressureChangeRate.FromKilopascalsPerSecond(2), 2.KilopascalsPerSecond());
+
+        [Fact]
+        public void NumberToMegapascalsPerMinuteTest() =>
+            Assert.Equal(PressureChangeRate.FromMegapascalsPerMinute(2), 2.MegapascalsPerMinute());
+
+        [Fact]
+        public void NumberToMegapascalsPerSecondTest() =>
+            Assert.Equal(PressureChangeRate.FromMegapascalsPerSecond(2), 2.MegapascalsPerSecond());
+
+        [Fact]
+        public void NumberToPascalsPerMinuteTest() =>
+            Assert.Equal(PressureChangeRate.FromPascalsPerMinute(2), 2.PascalsPerMinute());
+
+        [Fact]
+        public void NumberToPascalsPerSecondTest() =>
+            Assert.Equal(PressureChangeRate.FromPascalsPerSecond(2), 2.PascalsPerSecond());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
new file mode 100644
index 0000000000..5995faa37c
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToPressureExtensionsTest.g.cs
@@ -0,0 +1,196 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToPressure;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToPressureExtensionsTests
+    {
+        [Fact]
+        public void NumberToAtmospheresTest() =>
+            Assert.Equal(Pressure.FromAtmospheres(2), 2.Atmospheres());
+
+        [Fact]
+        public void NumberToBarsTest() =>
+            Assert.Equal(Pressure.FromBars(2), 2.Bars());
+
+        [Fact]
+        public void NumberToCentibarsTest() =>
+            Assert.Equal(Pressure.FromCentibars(2), 2.Centibars());
+
+        [Fact]
+        public void NumberToDecapascalsTest() =>
+            Assert.Equal(Pressure.FromDecapascals(2), 2.Decapascals());
+
+        [Fact]
+        public void NumberToDecibarsTest() =>
+            Assert.Equal(Pressure.FromDecibars(2), 2.Decibars());
+
+        [Fact]
+        public void NumberToDynesPerSquareCentimeterTest() =>
+            Assert.Equal(Pressure.FromDynesPerSquareCentimeter(2), 2.DynesPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToFeetOfHeadTest() =>
+            Assert.Equal(Pressure.FromFeetOfHead(2), 2.FeetOfHead());
+
+        [Fact]
+        public void NumberToGigapascalsTest() =>
+            Assert.Equal(Pressure.FromGigapascals(2), 2.Gigapascals());
+
+        [Fact]
+        public void NumberToHectopascalsTest() =>
+            Assert.Equal(Pressure.FromHectopascals(2), 2.Hectopascals());
+
+        [Fact]
+        public void NumberToInchesOfMercuryTest() =>
+            Assert.Equal(Pressure.FromInchesOfMercury(2), 2.InchesOfMercury());
+
+        [Fact]
+        public void NumberToInchesOfWaterColumnTest() =>
+            Assert.Equal(Pressure.FromInchesOfWaterColumn(2), 2.InchesOfWaterColumn());
+
+        [Fact]
+        public void NumberToKilobarsTest() =>
+            Assert.Equal(Pressure.FromKilobars(2), 2.Kilobars());
+
+        [Fact]
+        public void NumberToKilogramsForcePerSquareCentimeterTest() =>
+            Assert.Equal(Pressure.FromKilogramsForcePerSquareCentimeter(2), 2.KilogramsForcePerSquareCentimeter());
+
+        [Fact]
+        public void NumberToKilogramsForcePerSquareMeterTest() =>
+            Assert.Equal(Pressure.FromKilogramsForcePerSquareMeter(2), 2.KilogramsForcePerSquareMeter());
+
+        [Fact]
+        public void NumberToKilogramsForcePerSquareMillimeterTest() =>
+            Assert.Equal(Pressure.FromKilogramsForcePerSquareMillimeter(2), 2.KilogramsForcePerSquareMillimeter());
+
+        [Fact]
+        public void NumberToKilonewtonsPerSquareCentimeterTest() =>
+            Assert.Equal(Pressure.FromKilonewtonsPerSquareCentimeter(2), 2.KilonewtonsPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToKilonewtonsPerSquareMeterTest() =>
+            Assert.Equal(Pressure.FromKilonewtonsPerSquareMeter(2), 2.KilonewtonsPerSquareMeter());
+
+        [Fact]
+        public void NumberToKilonewtonsPerSquareMillimeterTest() =>
+            Assert.Equal(Pressure.FromKilonewtonsPerSquareMillimeter(2), 2.KilonewtonsPerSquareMillimeter());
+
+        [Fact]
+        public void NumberToKilopascalsTest() =>
+            Assert.Equal(Pressure.FromKilopascals(2), 2.Kilopascals());
+
+        [Fact]
+        public void NumberToKilopoundsForcePerSquareFootTest() =>
+            Assert.Equal(Pressure.FromKilopoundsForcePerSquareFoot(2), 2.KilopoundsForcePerSquareFoot());
+
+        [Fact]
+        public void NumberToKilopoundsForcePerSquareInchTest() =>
+            Assert.Equal(Pressure.FromKilopoundsForcePerSquareInch(2), 2.KilopoundsForcePerSquareInch());
+
+        [Fact]
+        public void NumberToMegabarsTest() =>
+            Assert.Equal(Pressure.FromMegabars(2), 2.Megabars());
+
+        [Fact]
+        public void NumberToMeganewtonsPerSquareMeterTest() =>
+            Assert.Equal(Pressure.FromMeganewtonsPerSquareMeter(2), 2.MeganewtonsPerSquareMeter());
+
+        [Fact]
+        public void NumberToMegapascalsTest() =>
+            Assert.Equal(Pressure.FromMegapascals(2), 2.Megapascals());
+
+        [Fact]
+        public void NumberToMetersOfHeadTest() =>
+            Assert.Equal(Pressure.FromMetersOfHead(2), 2.MetersOfHead());
+
+        [Fact]
+        public void NumberToMicrobarsTest() =>
+            Assert.Equal(Pressure.FromMicrobars(2), 2.Microbars());
+
+        [Fact]
+        public void NumberToMicropascalsTest() =>
+            Assert.Equal(Pressure.FromMicropascals(2), 2.Micropascals());
+
+        [Fact]
+        public void NumberToMillibarsTest() =>
+            Assert.Equal(Pressure.FromMillibars(2), 2.Millibars());
+
+        [Fact]
+        public void NumberToMillimetersOfMercuryTest() =>
+            Assert.Equal(Pressure.FromMillimetersOfMercury(2), 2.MillimetersOfMercury());
+
+        [Fact]
+        public void NumberToMillipascalsTest() =>
+            Assert.Equal(Pressure.FromMillipascals(2), 2.Millipascals());
+
+        [Fact]
+        public void NumberToNewtonsPerSquareCentimeterTest() =>
+            Assert.Equal(Pressure.FromNewtonsPerSquareCentimeter(2), 2.NewtonsPerSquareCentimeter());
+
+        [Fact]
+        public void NumberToNewtonsPerSquareMeterTest() =>
+            Assert.Equal(Pressure.FromNewtonsPerSquareMeter(2), 2.NewtonsPerSquareMeter());
+
+        [Fact]
+        public void NumberToNewtonsPerSquareMillimeterTest() =>
+            Assert.Equal(Pressure.FromNewtonsPerSquareMillimeter(2), 2.NewtonsPerSquareMillimeter());
+
+        [Fact]
+        public void NumberToPascalsTest() =>
+            Assert.Equal(Pressure.FromPascals(2), 2.Pascals());
+
+        [Fact]
+        public void NumberToPoundsForcePerSquareFootTest() =>
+            Assert.Equal(Pressure.FromPoundsForcePerSquareFoot(2), 2.PoundsForcePerSquareFoot());
+
+        [Fact]
+        public void NumberToPoundsForcePerSquareInchTest() =>
+            Assert.Equal(Pressure.FromPoundsForcePerSquareInch(2), 2.PoundsForcePerSquareInch());
+
+        [Fact]
+        public void NumberToPoundsPerInchSecondSquaredTest() =>
+            Assert.Equal(Pressure.FromPoundsPerInchSecondSquared(2), 2.PoundsPerInchSecondSquared());
+
+        [Fact]
+        public void NumberToTechnicalAtmospheresTest() =>
+            Assert.Equal(Pressure.FromTechnicalAtmospheres(2), 2.TechnicalAtmospheres());
+
+        [Fact]
+        public void NumberToTonnesForcePerSquareCentimeterTest() =>
+            Assert.Equal(Pressure.FromTonnesForcePerSquareCentimeter(2), 2.TonnesForcePerSquareCentimeter());
+
+        [Fact]
+        public void NumberToTonnesForcePerSquareMeterTest() =>
+            Assert.Equal(Pressure.FromTonnesForcePerSquareMeter(2), 2.TonnesForcePerSquareMeter());
+
+        [Fact]
+        public void NumberToTonnesForcePerSquareMillimeterTest() =>
+            Assert.Equal(Pressure.FromTonnesForcePerSquareMillimeter(2), 2.TonnesForcePerSquareMillimeter());
+
+        [Fact]
+        public void NumberToTorrsTest() =>
+            Assert.Equal(Pressure.FromTorrs(2), 2.Torrs());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioChangeRateExtensionsTest.g.cs
new file mode 100644
index 0000000000..2c8909a213
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioChangeRateExtensionsTest.g.cs
@@ -0,0 +1,36 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToRatioChangeRate;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToRatioChangeRateExtensionsTests
+    {
+        [Fact]
+        public void NumberToDecimalFractionsPerSecondTest() =>
+            Assert.Equal(RatioChangeRate.FromDecimalFractionsPerSecond(2), 2.DecimalFractionsPerSecond());
+
+        [Fact]
+        public void NumberToPercentsPerSecondTest() =>
+            Assert.Equal(RatioChangeRate.FromPercentsPerSecond(2), 2.PercentsPerSecond());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs
new file mode 100644
index 0000000000..29cd75e5d6
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRatioExtensionsTest.g.cs
@@ -0,0 +1,52 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToRatio;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToRatioExtensionsTests
+    {
+        [Fact]
+        public void NumberToDecimalFractionsTest() =>
+            Assert.Equal(Ratio.FromDecimalFractions(2), 2.DecimalFractions());
+
+        [Fact]
+        public void NumberToPartsPerBillionTest() =>
+            Assert.Equal(Ratio.FromPartsPerBillion(2), 2.PartsPerBillion());
+
+        [Fact]
+        public void NumberToPartsPerMillionTest() =>
+            Assert.Equal(Ratio.FromPartsPerMillion(2), 2.PartsPerMillion());
+
+        [Fact]
+        public void NumberToPartsPerThousandTest() =>
+            Assert.Equal(Ratio.FromPartsPerThousand(2), 2.PartsPerThousand());
+
+        [Fact]
+        public void NumberToPartsPerTrillionTest() =>
+            Assert.Equal(Ratio.FromPartsPerTrillion(2), 2.PartsPerTrillion());
+
+        [Fact]
+        public void NumberToPercentTest() =>
+            Assert.Equal(Ratio.FromPercent(2), 2.Percent());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactiveEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactiveEnergyExtensionsTest.g.cs
new file mode 100644
index 0000000000..76b08293df
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactiveEnergyExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToReactiveEnergy;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToReactiveEnergyExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilovoltampereReactiveHoursTest() =>
+            Assert.Equal(ReactiveEnergy.FromKilovoltampereReactiveHours(2), 2.KilovoltampereReactiveHours());
+
+        [Fact]
+        public void NumberToMegavoltampereReactiveHoursTest() =>
+            Assert.Equal(ReactiveEnergy.FromMegavoltampereReactiveHours(2), 2.MegavoltampereReactiveHours());
+
+        [Fact]
+        public void NumberToVoltampereReactiveHoursTest() =>
+            Assert.Equal(ReactiveEnergy.FromVoltampereReactiveHours(2), 2.VoltampereReactiveHours());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactivePowerExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactivePowerExtensionsTest.g.cs
new file mode 100644
index 0000000000..5634f70bef
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToReactivePowerExtensionsTest.g.cs
@@ -0,0 +1,44 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToReactivePower;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToReactivePowerExtensionsTests
+    {
+        [Fact]
+        public void NumberToGigavoltamperesReactiveTest() =>
+            Assert.Equal(ReactivePower.FromGigavoltamperesReactive(2), 2.GigavoltamperesReactive());
+
+        [Fact]
+        public void NumberToKilovoltamperesReactiveTest() =>
+            Assert.Equal(ReactivePower.FromKilovoltamperesReactive(2), 2.KilovoltamperesReactive());
+
+        [Fact]
+        public void NumberToMegavoltamperesReactiveTest() =>
+            Assert.Equal(ReactivePower.FromMegavoltamperesReactive(2), 2.MegavoltamperesReactive());
+
+        [Fact]
+        public void NumberToVoltamperesReactiveTest() =>
+            Assert.Equal(ReactivePower.FromVoltamperesReactive(2), 2.VoltamperesReactive());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalAccelerationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalAccelerationExtensionsTest.g.cs
new file mode 100644
index 0000000000..76ec15463c
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalAccelerationExtensionsTest.g.cs
@@ -0,0 +1,44 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToRotationalAcceleration;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToRotationalAccelerationExtensionsTests
+    {
+        [Fact]
+        public void NumberToDegreesPerSecondSquaredTest() =>
+            Assert.Equal(RotationalAcceleration.FromDegreesPerSecondSquared(2), 2.DegreesPerSecondSquared());
+
+        [Fact]
+        public void NumberToRadiansPerSecondSquaredTest() =>
+            Assert.Equal(RotationalAcceleration.FromRadiansPerSecondSquared(2), 2.RadiansPerSecondSquared());
+
+        [Fact]
+        public void NumberToRevolutionsPerMinutePerSecondTest() =>
+            Assert.Equal(RotationalAcceleration.FromRevolutionsPerMinutePerSecond(2), 2.RevolutionsPerMinutePerSecond());
+
+        [Fact]
+        public void NumberToRevolutionsPerSecondSquaredTest() =>
+            Assert.Equal(RotationalAcceleration.FromRevolutionsPerSecondSquared(2), 2.RevolutionsPerSecondSquared());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalSpeedExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalSpeedExtensionsTest.g.cs
new file mode 100644
index 0000000000..15ee76c684
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalSpeedExtensionsTest.g.cs
@@ -0,0 +1,80 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToRotationalSpeed;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToRotationalSpeedExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentiradiansPerSecondTest() =>
+            Assert.Equal(RotationalSpeed.FromCentiradiansPerSecond(2), 2.CentiradiansPerSecond());
+
+        [Fact]
+        public void NumberToDeciradiansPerSecondTest() =>
+            Assert.Equal(RotationalSpeed.FromDeciradiansPerSecond(2), 2.DeciradiansPerSecond());
+
+        [Fact]
+        public void NumberToDegreesPerMinuteTest() =>
+            Assert.Equal(RotationalSpeed.FromDegreesPerMinute(2), 2.DegreesPerMinute());
+
+        [Fact]
+        public void NumberToDegreesPerSecondTest() =>
+            Assert.Equal(RotationalSpeed.FromDegreesPerSecond(2), 2.DegreesPerSecond());
+
+        [Fact]
+        public void NumberToMicrodegreesPerSecondTest() =>
+            Assert.Equal(RotationalSpeed.FromMicrodegreesPerSecond(2), 2.MicrodegreesPerSecond());
+
+        [Fact]
+        public void NumberToMicroradiansPerSecondTest() =>
+            Assert.Equal(RotationalSpeed.FromMicroradiansPerSecond(2), 2.MicroradiansPerSecond());
+
+        [Fact]
+        public void NumberToMillidegreesPerSecondTest() =>
+            Assert.Equal(RotationalSpeed.FromMillidegreesPerSecond(2), 2.MillidegreesPerSecond());
+
+        [Fact]
+        public void NumberToMilliradiansPerSecondTest() =>
+            Assert.Equal(RotationalSpeed.FromMilliradiansPerSecond(2), 2.MilliradiansPerSecond());
+
+        [Fact]
+        public void NumberToNanodegreesPerSecondTest() =>
+            Assert.Equal(RotationalSpeed.FromNanodegreesPerSecond(2), 2.NanodegreesPerSecond());
+
+        [Fact]
+        public void NumberToNanoradiansPerSecondTest() =>
+            Assert.Equal(RotationalSpeed.FromNanoradiansPerSecond(2), 2.NanoradiansPerSecond());
+
+        [Fact]
+        public void NumberToRadiansPerSecondTest() =>
+            Assert.Equal(RotationalSpeed.FromRadiansPerSecond(2), 2.RadiansPerSecond());
+
+        [Fact]
+        public void NumberToRevolutionsPerMinuteTest() =>
+            Assert.Equal(RotationalSpeed.FromRevolutionsPerMinute(2), 2.RevolutionsPerMinute());
+
+        [Fact]
+        public void NumberToRevolutionsPerSecondTest() =>
+            Assert.Equal(RotationalSpeed.FromRevolutionsPerSecond(2), 2.RevolutionsPerSecond());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessExtensionsTest.g.cs
new file mode 100644
index 0000000000..f7a3f1c86e
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToRotationalStiffness;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToRotationalStiffnessExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilonewtonMetersPerRadianTest() =>
+            Assert.Equal(RotationalStiffness.FromKilonewtonMetersPerRadian(2), 2.KilonewtonMetersPerRadian());
+
+        [Fact]
+        public void NumberToMeganewtonMetersPerRadianTest() =>
+            Assert.Equal(RotationalStiffness.FromMeganewtonMetersPerRadian(2), 2.MeganewtonMetersPerRadian());
+
+        [Fact]
+        public void NumberToNewtonMetersPerRadianTest() =>
+            Assert.Equal(RotationalStiffness.FromNewtonMetersPerRadian(2), 2.NewtonMetersPerRadian());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensionsTest.g.cs
new file mode 100644
index 0000000000..39ab459765
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToRotationalStiffnessPerLength;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToRotationalStiffnessPerLengthExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilonewtonMetersPerRadianPerMeterTest() =>
+            Assert.Equal(RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(2), 2.KilonewtonMetersPerRadianPerMeter());
+
+        [Fact]
+        public void NumberToMeganewtonMetersPerRadianPerMeterTest() =>
+            Assert.Equal(RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(2), 2.MeganewtonMetersPerRadianPerMeter());
+
+        [Fact]
+        public void NumberToNewtonMetersPerRadianPerMeterTest() =>
+            Assert.Equal(RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(2), 2.NewtonMetersPerRadianPerMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSolidAngleExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSolidAngleExtensionsTest.g.cs
new file mode 100644
index 0000000000..2f62ef1c62
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSolidAngleExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToSolidAngle;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToSolidAngleExtensionsTests
+    {
+        [Fact]
+        public void NumberToSteradiansTest() =>
+            Assert.Equal(SolidAngle.FromSteradians(2), 2.Steradians());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEnergyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEnergyExtensionsTest.g.cs
new file mode 100644
index 0000000000..7dde90984b
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEnergyExtensionsTest.g.cs
@@ -0,0 +1,64 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToSpecificEnergy;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToSpecificEnergyExtensionsTests
+    {
+        [Fact]
+        public void NumberToBtuPerPoundTest() =>
+            Assert.Equal(SpecificEnergy.FromBtuPerPound(2), 2.BtuPerPound());
+
+        [Fact]
+        public void NumberToCaloriesPerGramTest() =>
+            Assert.Equal(SpecificEnergy.FromCaloriesPerGram(2), 2.CaloriesPerGram());
+
+        [Fact]
+        public void NumberToJoulesPerKilogramTest() =>
+            Assert.Equal(SpecificEnergy.FromJoulesPerKilogram(2), 2.JoulesPerKilogram());
+
+        [Fact]
+        public void NumberToKilocaloriesPerGramTest() =>
+            Assert.Equal(SpecificEnergy.FromKilocaloriesPerGram(2), 2.KilocaloriesPerGram());
+
+        [Fact]
+        public void NumberToKilojoulesPerKilogramTest() =>
+            Assert.Equal(SpecificEnergy.FromKilojoulesPerKilogram(2), 2.KilojoulesPerKilogram());
+
+        [Fact]
+        public void NumberToKilowattHoursPerKilogramTest() =>
+            Assert.Equal(SpecificEnergy.FromKilowattHoursPerKilogram(2), 2.KilowattHoursPerKilogram());
+
+        [Fact]
+        public void NumberToMegajoulesPerKilogramTest() =>
+            Assert.Equal(SpecificEnergy.FromMegajoulesPerKilogram(2), 2.MegajoulesPerKilogram());
+
+        [Fact]
+        public void NumberToMegawattHoursPerKilogramTest() =>
+            Assert.Equal(SpecificEnergy.FromMegawattHoursPerKilogram(2), 2.MegawattHoursPerKilogram());
+
+        [Fact]
+        public void NumberToWattHoursPerKilogramTest() =>
+            Assert.Equal(SpecificEnergy.FromWattHoursPerKilogram(2), 2.WattHoursPerKilogram());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEntropyExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEntropyExtensionsTest.g.cs
new file mode 100644
index 0000000000..95593fbdf9
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificEntropyExtensionsTest.g.cs
@@ -0,0 +1,64 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToSpecificEntropy;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToSpecificEntropyExtensionsTests
+    {
+        [Fact]
+        public void NumberToBtusPerPoundFahrenheitTest() =>
+            Assert.Equal(SpecificEntropy.FromBtusPerPoundFahrenheit(2), 2.BtusPerPoundFahrenheit());
+
+        [Fact]
+        public void NumberToCaloriesPerGramKelvinTest() =>
+            Assert.Equal(SpecificEntropy.FromCaloriesPerGramKelvin(2), 2.CaloriesPerGramKelvin());
+
+        [Fact]
+        public void NumberToJoulesPerKilogramDegreeCelsiusTest() =>
+            Assert.Equal(SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(2), 2.JoulesPerKilogramDegreeCelsius());
+
+        [Fact]
+        public void NumberToJoulesPerKilogramKelvinTest() =>
+            Assert.Equal(SpecificEntropy.FromJoulesPerKilogramKelvin(2), 2.JoulesPerKilogramKelvin());
+
+        [Fact]
+        public void NumberToKilocaloriesPerGramKelvinTest() =>
+            Assert.Equal(SpecificEntropy.FromKilocaloriesPerGramKelvin(2), 2.KilocaloriesPerGramKelvin());
+
+        [Fact]
+        public void NumberToKilojoulesPerKilogramDegreeCelsiusTest() =>
+            Assert.Equal(SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(2), 2.KilojoulesPerKilogramDegreeCelsius());
+
+        [Fact]
+        public void NumberToKilojoulesPerKilogramKelvinTest() =>
+            Assert.Equal(SpecificEntropy.FromKilojoulesPerKilogramKelvin(2), 2.KilojoulesPerKilogramKelvin());
+
+        [Fact]
+        public void NumberToMegajoulesPerKilogramDegreeCelsiusTest() =>
+            Assert.Equal(SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(2), 2.MegajoulesPerKilogramDegreeCelsius());
+
+        [Fact]
+        public void NumberToMegajoulesPerKilogramKelvinTest() =>
+            Assert.Equal(SpecificEntropy.FromMegajoulesPerKilogramKelvin(2), 2.MegajoulesPerKilogramKelvin());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
new file mode 100644
index 0000000000..f38987467e
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificVolumeExtensionsTest.g.cs
@@ -0,0 +1,40 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToSpecificVolume;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToSpecificVolumeExtensionsTests
+    {
+        [Fact]
+        public void NumberToCubicFeetPerPoundTest() =>
+            Assert.Equal(SpecificVolume.FromCubicFeetPerPound(2), 2.CubicFeetPerPound());
+
+        [Fact]
+        public void NumberToCubicMetersPerKilogramTest() =>
+            Assert.Equal(SpecificVolume.FromCubicMetersPerKilogram(2), 2.CubicMetersPerKilogram());
+
+        [Fact]
+        public void NumberToMillicubicMetersPerKilogramTest() =>
+            Assert.Equal(SpecificVolume.FromMillicubicMetersPerKilogram(2), 2.MillicubicMetersPerKilogram());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificWeightExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificWeightExtensionsTest.g.cs
new file mode 100644
index 0000000000..5b86231aee
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpecificWeightExtensionsTest.g.cs
@@ -0,0 +1,96 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToSpecificWeight;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToSpecificWeightExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilogramsForcePerCubicCentimeterTest() =>
+            Assert.Equal(SpecificWeight.FromKilogramsForcePerCubicCentimeter(2), 2.KilogramsForcePerCubicCentimeter());
+
+        [Fact]
+        public void NumberToKilogramsForcePerCubicMeterTest() =>
+            Assert.Equal(SpecificWeight.FromKilogramsForcePerCubicMeter(2), 2.KilogramsForcePerCubicMeter());
+
+        [Fact]
+        public void NumberToKilogramsForcePerCubicMillimeterTest() =>
+            Assert.Equal(SpecificWeight.FromKilogramsForcePerCubicMillimeter(2), 2.KilogramsForcePerCubicMillimeter());
+
+        [Fact]
+        public void NumberToKilonewtonsPerCubicCentimeterTest() =>
+            Assert.Equal(SpecificWeight.FromKilonewtonsPerCubicCentimeter(2), 2.KilonewtonsPerCubicCentimeter());
+
+        [Fact]
+        public void NumberToKilonewtonsPerCubicMeterTest() =>
+            Assert.Equal(SpecificWeight.FromKilonewtonsPerCubicMeter(2), 2.KilonewtonsPerCubicMeter());
+
+        [Fact]
+        public void NumberToKilonewtonsPerCubicMillimeterTest() =>
+            Assert.Equal(SpecificWeight.FromKilonewtonsPerCubicMillimeter(2), 2.KilonewtonsPerCubicMillimeter());
+
+        [Fact]
+        public void NumberToKilopoundsForcePerCubicFootTest() =>
+            Assert.Equal(SpecificWeight.FromKilopoundsForcePerCubicFoot(2), 2.KilopoundsForcePerCubicFoot());
+
+        [Fact]
+        public void NumberToKilopoundsForcePerCubicInchTest() =>
+            Assert.Equal(SpecificWeight.FromKilopoundsForcePerCubicInch(2), 2.KilopoundsForcePerCubicInch());
+
+        [Fact]
+        public void NumberToMeganewtonsPerCubicMeterTest() =>
+            Assert.Equal(SpecificWeight.FromMeganewtonsPerCubicMeter(2), 2.MeganewtonsPerCubicMeter());
+
+        [Fact]
+        public void NumberToNewtonsPerCubicCentimeterTest() =>
+            Assert.Equal(SpecificWeight.FromNewtonsPerCubicCentimeter(2), 2.NewtonsPerCubicCentimeter());
+
+        [Fact]
+        public void NumberToNewtonsPerCubicMeterTest() =>
+            Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(2), 2.NewtonsPerCubicMeter());
+
+        [Fact]
+        public void NumberToNewtonsPerCubicMillimeterTest() =>
+            Assert.Equal(SpecificWeight.FromNewtonsPerCubicMillimeter(2), 2.NewtonsPerCubicMillimeter());
+
+        [Fact]
+        public void NumberToPoundsForcePerCubicFootTest() =>
+            Assert.Equal(SpecificWeight.FromPoundsForcePerCubicFoot(2), 2.PoundsForcePerCubicFoot());
+
+        [Fact]
+        public void NumberToPoundsForcePerCubicInchTest() =>
+            Assert.Equal(SpecificWeight.FromPoundsForcePerCubicInch(2), 2.PoundsForcePerCubicInch());
+
+        [Fact]
+        public void NumberToTonnesForcePerCubicCentimeterTest() =>
+            Assert.Equal(SpecificWeight.FromTonnesForcePerCubicCentimeter(2), 2.TonnesForcePerCubicCentimeter());
+
+        [Fact]
+        public void NumberToTonnesForcePerCubicMeterTest() =>
+            Assert.Equal(SpecificWeight.FromTonnesForcePerCubicMeter(2), 2.TonnesForcePerCubicMeter());
+
+        [Fact]
+        public void NumberToTonnesForcePerCubicMillimeterTest() =>
+            Assert.Equal(SpecificWeight.FromTonnesForcePerCubicMillimeter(2), 2.TonnesForcePerCubicMillimeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs
new file mode 100644
index 0000000000..cf82f33e6c
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToSpeedExtensionsTest.g.cs
@@ -0,0 +1,156 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToSpeed;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToSpeedExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentimetersPerHourTest() =>
+            Assert.Equal(Speed.FromCentimetersPerHour(2), 2.CentimetersPerHour());
+
+        [Fact]
+        public void NumberToCentimetersPerMinutesTest() =>
+            Assert.Equal(Speed.FromCentimetersPerMinutes(2), 2.CentimetersPerMinutes());
+
+        [Fact]
+        public void NumberToCentimetersPerSecondTest() =>
+            Assert.Equal(Speed.FromCentimetersPerSecond(2), 2.CentimetersPerSecond());
+
+        [Fact]
+        public void NumberToDecimetersPerMinutesTest() =>
+            Assert.Equal(Speed.FromDecimetersPerMinutes(2), 2.DecimetersPerMinutes());
+
+        [Fact]
+        public void NumberToDecimetersPerSecondTest() =>
+            Assert.Equal(Speed.FromDecimetersPerSecond(2), 2.DecimetersPerSecond());
+
+        [Fact]
+        public void NumberToFeetPerHourTest() =>
+            Assert.Equal(Speed.FromFeetPerHour(2), 2.FeetPerHour());
+
+        [Fact]
+        public void NumberToFeetPerMinuteTest() =>
+            Assert.Equal(Speed.FromFeetPerMinute(2), 2.FeetPerMinute());
+
+        [Fact]
+        public void NumberToFeetPerSecondTest() =>
+            Assert.Equal(Speed.FromFeetPerSecond(2), 2.FeetPerSecond());
+
+        [Fact]
+        public void NumberToInchesPerHourTest() =>
+            Assert.Equal(Speed.FromInchesPerHour(2), 2.InchesPerHour());
+
+        [Fact]
+        public void NumberToInchesPerMinuteTest() =>
+            Assert.Equal(Speed.FromInchesPerMinute(2), 2.InchesPerMinute());
+
+        [Fact]
+        public void NumberToInchesPerSecondTest() =>
+            Assert.Equal(Speed.FromInchesPerSecond(2), 2.InchesPerSecond());
+
+        [Fact]
+        public void NumberToKilometersPerHourTest() =>
+            Assert.Equal(Speed.FromKilometersPerHour(2), 2.KilometersPerHour());
+
+        [Fact]
+        public void NumberToKilometersPerMinutesTest() =>
+            Assert.Equal(Speed.FromKilometersPerMinutes(2), 2.KilometersPerMinutes());
+
+        [Fact]
+        public void NumberToKilometersPerSecondTest() =>
+            Assert.Equal(Speed.FromKilometersPerSecond(2), 2.KilometersPerSecond());
+
+        [Fact]
+        public void NumberToKnotsTest() =>
+            Assert.Equal(Speed.FromKnots(2), 2.Knots());
+
+        [Fact]
+        public void NumberToMetersPerHourTest() =>
+            Assert.Equal(Speed.FromMetersPerHour(2), 2.MetersPerHour());
+
+        [Fact]
+        public void NumberToMetersPerMinutesTest() =>
+            Assert.Equal(Speed.FromMetersPerMinutes(2), 2.MetersPerMinutes());
+
+        [Fact]
+        public void NumberToMetersPerSecondTest() =>
+            Assert.Equal(Speed.FromMetersPerSecond(2), 2.MetersPerSecond());
+
+        [Fact]
+        public void NumberToMicrometersPerMinutesTest() =>
+            Assert.Equal(Speed.FromMicrometersPerMinutes(2), 2.MicrometersPerMinutes());
+
+        [Fact]
+        public void NumberToMicrometersPerSecondTest() =>
+            Assert.Equal(Speed.FromMicrometersPerSecond(2), 2.MicrometersPerSecond());
+
+        [Fact]
+        public void NumberToMilesPerHourTest() =>
+            Assert.Equal(Speed.FromMilesPerHour(2), 2.MilesPerHour());
+
+        [Fact]
+        public void NumberToMillimetersPerHourTest() =>
+            Assert.Equal(Speed.FromMillimetersPerHour(2), 2.MillimetersPerHour());
+
+        [Fact]
+        public void NumberToMillimetersPerMinutesTest() =>
+            Assert.Equal(Speed.FromMillimetersPerMinutes(2), 2.MillimetersPerMinutes());
+
+        [Fact]
+        public void NumberToMillimetersPerSecondTest() =>
+            Assert.Equal(Speed.FromMillimetersPerSecond(2), 2.MillimetersPerSecond());
+
+        [Fact]
+        public void NumberToNanometersPerMinutesTest() =>
+            Assert.Equal(Speed.FromNanometersPerMinutes(2), 2.NanometersPerMinutes());
+
+        [Fact]
+        public void NumberToNanometersPerSecondTest() =>
+            Assert.Equal(Speed.FromNanometersPerSecond(2), 2.NanometersPerSecond());
+
+        [Fact]
+        public void NumberToUsSurveyFeetPerHourTest() =>
+            Assert.Equal(Speed.FromUsSurveyFeetPerHour(2), 2.UsSurveyFeetPerHour());
+
+        [Fact]
+        public void NumberToUsSurveyFeetPerMinuteTest() =>
+            Assert.Equal(Speed.FromUsSurveyFeetPerMinute(2), 2.UsSurveyFeetPerMinute());
+
+        [Fact]
+        public void NumberToUsSurveyFeetPerSecondTest() =>
+            Assert.Equal(Speed.FromUsSurveyFeetPerSecond(2), 2.UsSurveyFeetPerSecond());
+
+        [Fact]
+        public void NumberToYardsPerHourTest() =>
+            Assert.Equal(Speed.FromYardsPerHour(2), 2.YardsPerHour());
+
+        [Fact]
+        public void NumberToYardsPerMinuteTest() =>
+            Assert.Equal(Speed.FromYardsPerMinute(2), 2.YardsPerMinute());
+
+        [Fact]
+        public void NumberToYardsPerSecondTest() =>
+            Assert.Equal(Speed.FromYardsPerSecond(2), 2.YardsPerSecond());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureChangeRateExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureChangeRateExtensionsTest.g.cs
new file mode 100644
index 0000000000..957a586266
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureChangeRateExtensionsTest.g.cs
@@ -0,0 +1,68 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToTemperatureChangeRate;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToTemperatureChangeRateExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentidegreesCelsiusPerSecondTest() =>
+            Assert.Equal(TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(2), 2.CentidegreesCelsiusPerSecond());
+
+        [Fact]
+        public void NumberToDecadegreesCelsiusPerSecondTest() =>
+            Assert.Equal(TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(2), 2.DecadegreesCelsiusPerSecond());
+
+        [Fact]
+        public void NumberToDecidegreesCelsiusPerSecondTest() =>
+            Assert.Equal(TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(2), 2.DecidegreesCelsiusPerSecond());
+
+        [Fact]
+        public void NumberToDegreesCelsiusPerMinuteTest() =>
+            Assert.Equal(TemperatureChangeRate.FromDegreesCelsiusPerMinute(2), 2.DegreesCelsiusPerMinute());
+
+        [Fact]
+        public void NumberToDegreesCelsiusPerSecondTest() =>
+            Assert.Equal(TemperatureChangeRate.FromDegreesCelsiusPerSecond(2), 2.DegreesCelsiusPerSecond());
+
+        [Fact]
+        public void NumberToHectodegreesCelsiusPerSecondTest() =>
+            Assert.Equal(TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(2), 2.HectodegreesCelsiusPerSecond());
+
+        [Fact]
+        public void NumberToKilodegreesCelsiusPerSecondTest() =>
+            Assert.Equal(TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(2), 2.KilodegreesCelsiusPerSecond());
+
+        [Fact]
+        public void NumberToMicrodegreesCelsiusPerSecondTest() =>
+            Assert.Equal(TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(2), 2.MicrodegreesCelsiusPerSecond());
+
+        [Fact]
+        public void NumberToMillidegreesCelsiusPerSecondTest() =>
+            Assert.Equal(TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(2), 2.MillidegreesCelsiusPerSecond());
+
+        [Fact]
+        public void NumberToNanodegreesCelsiusPerSecondTest() =>
+            Assert.Equal(TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(2), 2.NanodegreesCelsiusPerSecond());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureDeltaExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureDeltaExtensionsTest.g.cs
new file mode 100644
index 0000000000..2356c2d7b0
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureDeltaExtensionsTest.g.cs
@@ -0,0 +1,60 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToTemperatureDelta;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToTemperatureDeltaExtensionsTests
+    {
+        [Fact]
+        public void NumberToDegreesCelsiusTest() =>
+            Assert.Equal(TemperatureDelta.FromDegreesCelsius(2), 2.DegreesCelsius());
+
+        [Fact]
+        public void NumberToDegreesDelisleTest() =>
+            Assert.Equal(TemperatureDelta.FromDegreesDelisle(2), 2.DegreesDelisle());
+
+        [Fact]
+        public void NumberToDegreesFahrenheitTest() =>
+            Assert.Equal(TemperatureDelta.FromDegreesFahrenheit(2), 2.DegreesFahrenheit());
+
+        [Fact]
+        public void NumberToDegreesNewtonTest() =>
+            Assert.Equal(TemperatureDelta.FromDegreesNewton(2), 2.DegreesNewton());
+
+        [Fact]
+        public void NumberToDegreesRankineTest() =>
+            Assert.Equal(TemperatureDelta.FromDegreesRankine(2), 2.DegreesRankine());
+
+        [Fact]
+        public void NumberToDegreesReaumurTest() =>
+            Assert.Equal(TemperatureDelta.FromDegreesReaumur(2), 2.DegreesReaumur());
+
+        [Fact]
+        public void NumberToDegreesRoemerTest() =>
+            Assert.Equal(TemperatureDelta.FromDegreesRoemer(2), 2.DegreesRoemer());
+
+        [Fact]
+        public void NumberToKelvinsTest() =>
+            Assert.Equal(TemperatureDelta.FromKelvins(2), 2.Kelvins());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureExtensionsTest.g.cs
new file mode 100644
index 0000000000..9f3f3ba050
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTemperatureExtensionsTest.g.cs
@@ -0,0 +1,64 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToTemperature;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToTemperatureExtensionsTests
+    {
+        [Fact]
+        public void NumberToDegreesCelsiusTest() =>
+            Assert.Equal(Temperature.FromDegreesCelsius(2), 2.DegreesCelsius());
+
+        [Fact]
+        public void NumberToDegreesDelisleTest() =>
+            Assert.Equal(Temperature.FromDegreesDelisle(2), 2.DegreesDelisle());
+
+        [Fact]
+        public void NumberToDegreesFahrenheitTest() =>
+            Assert.Equal(Temperature.FromDegreesFahrenheit(2), 2.DegreesFahrenheit());
+
+        [Fact]
+        public void NumberToDegreesNewtonTest() =>
+            Assert.Equal(Temperature.FromDegreesNewton(2), 2.DegreesNewton());
+
+        [Fact]
+        public void NumberToDegreesRankineTest() =>
+            Assert.Equal(Temperature.FromDegreesRankine(2), 2.DegreesRankine());
+
+        [Fact]
+        public void NumberToDegreesReaumurTest() =>
+            Assert.Equal(Temperature.FromDegreesReaumur(2), 2.DegreesReaumur());
+
+        [Fact]
+        public void NumberToDegreesRoemerTest() =>
+            Assert.Equal(Temperature.FromDegreesRoemer(2), 2.DegreesRoemer());
+
+        [Fact]
+        public void NumberToKelvinsTest() =>
+            Assert.Equal(Temperature.FromKelvins(2), 2.Kelvins());
+
+        [Fact]
+        public void NumberToSolarTemperaturesTest() =>
+            Assert.Equal(Temperature.FromSolarTemperatures(2), 2.SolarTemperatures());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
new file mode 100644
index 0000000000..8a5e51b160
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalConductivityExtensionsTest.g.cs
@@ -0,0 +1,36 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToThermalConductivity;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToThermalConductivityExtensionsTests
+    {
+        [Fact]
+        public void NumberToBtusPerHourFootFahrenheitTest() =>
+            Assert.Equal(ThermalConductivity.FromBtusPerHourFootFahrenheit(2), 2.BtusPerHourFootFahrenheit());
+
+        [Fact]
+        public void NumberToWattsPerMeterKelvinTest() =>
+            Assert.Equal(ThermalConductivity.FromWattsPerMeterKelvin(2), 2.WattsPerMeterKelvin());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalResistanceExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalResistanceExtensionsTest.g.cs
new file mode 100644
index 0000000000..bd498813b2
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToThermalResistanceExtensionsTest.g.cs
@@ -0,0 +1,48 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToThermalResistance;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToThermalResistanceExtensionsTests
+    {
+        [Fact]
+        public void NumberToHourSquareFeetDegreesFahrenheitPerBtuTest() =>
+            Assert.Equal(ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(2), 2.HourSquareFeetDegreesFahrenheitPerBtu());
+
+        [Fact]
+        public void NumberToSquareCentimeterHourDegreesCelsiusPerKilocalorieTest() =>
+            Assert.Equal(ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(2), 2.SquareCentimeterHourDegreesCelsiusPerKilocalorie());
+
+        [Fact]
+        public void NumberToSquareCentimeterKelvinsPerWattTest() =>
+            Assert.Equal(ThermalResistance.FromSquareCentimeterKelvinsPerWatt(2), 2.SquareCentimeterKelvinsPerWatt());
+
+        [Fact]
+        public void NumberToSquareMeterDegreesCelsiusPerWattTest() =>
+            Assert.Equal(ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(2), 2.SquareMeterDegreesCelsiusPerWatt());
+
+        [Fact]
+        public void NumberToSquareMeterKelvinsPerKilowattTest() =>
+            Assert.Equal(ThermalResistance.FromSquareMeterKelvinsPerKilowatt(2), 2.SquareMeterKelvinsPerKilowatt());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
new file mode 100644
index 0000000000..961ed028e0
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorqueExtensionsTest.g.cs
@@ -0,0 +1,112 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToTorque;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToTorqueExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilogramForceCentimetersTest() =>
+            Assert.Equal(Torque.FromKilogramForceCentimeters(2), 2.KilogramForceCentimeters());
+
+        [Fact]
+        public void NumberToKilogramForceMetersTest() =>
+            Assert.Equal(Torque.FromKilogramForceMeters(2), 2.KilogramForceMeters());
+
+        [Fact]
+        public void NumberToKilogramForceMillimetersTest() =>
+            Assert.Equal(Torque.FromKilogramForceMillimeters(2), 2.KilogramForceMillimeters());
+
+        [Fact]
+        public void NumberToKilonewtonCentimetersTest() =>
+            Assert.Equal(Torque.FromKilonewtonCentimeters(2), 2.KilonewtonCentimeters());
+
+        [Fact]
+        public void NumberToKilonewtonMetersTest() =>
+            Assert.Equal(Torque.FromKilonewtonMeters(2), 2.KilonewtonMeters());
+
+        [Fact]
+        public void NumberToKilonewtonMillimetersTest() =>
+            Assert.Equal(Torque.FromKilonewtonMillimeters(2), 2.KilonewtonMillimeters());
+
+        [Fact]
+        public void NumberToKilopoundForceFeetTest() =>
+            Assert.Equal(Torque.FromKilopoundForceFeet(2), 2.KilopoundForceFeet());
+
+        [Fact]
+        public void NumberToKilopoundForceInchesTest() =>
+            Assert.Equal(Torque.FromKilopoundForceInches(2), 2.KilopoundForceInches());
+
+        [Fact]
+        public void NumberToMeganewtonCentimetersTest() =>
+            Assert.Equal(Torque.FromMeganewtonCentimeters(2), 2.MeganewtonCentimeters());
+
+        [Fact]
+        public void NumberToMeganewtonMetersTest() =>
+            Assert.Equal(Torque.FromMeganewtonMeters(2), 2.MeganewtonMeters());
+
+        [Fact]
+        public void NumberToMeganewtonMillimetersTest() =>
+            Assert.Equal(Torque.FromMeganewtonMillimeters(2), 2.MeganewtonMillimeters());
+
+        [Fact]
+        public void NumberToMegapoundForceFeetTest() =>
+            Assert.Equal(Torque.FromMegapoundForceFeet(2), 2.MegapoundForceFeet());
+
+        [Fact]
+        public void NumberToMegapoundForceInchesTest() =>
+            Assert.Equal(Torque.FromMegapoundForceInches(2), 2.MegapoundForceInches());
+
+        [Fact]
+        public void NumberToNewtonCentimetersTest() =>
+            Assert.Equal(Torque.FromNewtonCentimeters(2), 2.NewtonCentimeters());
+
+        [Fact]
+        public void NumberToNewtonMetersTest() =>
+            Assert.Equal(Torque.FromNewtonMeters(2), 2.NewtonMeters());
+
+        [Fact]
+        public void NumberToNewtonMillimetersTest() =>
+            Assert.Equal(Torque.FromNewtonMillimeters(2), 2.NewtonMillimeters());
+
+        [Fact]
+        public void NumberToPoundForceFeetTest() =>
+            Assert.Equal(Torque.FromPoundForceFeet(2), 2.PoundForceFeet());
+
+        [Fact]
+        public void NumberToPoundForceInchesTest() =>
+            Assert.Equal(Torque.FromPoundForceInches(2), 2.PoundForceInches());
+
+        [Fact]
+        public void NumberToTonneForceCentimetersTest() =>
+            Assert.Equal(Torque.FromTonneForceCentimeters(2), 2.TonneForceCentimeters());
+
+        [Fact]
+        public void NumberToTonneForceMetersTest() =>
+            Assert.Equal(Torque.FromTonneForceMeters(2), 2.TonneForceMeters());
+
+        [Fact]
+        public void NumberToTonneForceMillimetersTest() =>
+            Assert.Equal(Torque.FromTonneForceMillimeters(2), 2.TonneForceMillimeters());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorquePerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorquePerLengthExtensionsTest.g.cs
new file mode 100644
index 0000000000..ea0406f6b3
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToTorquePerLengthExtensionsTest.g.cs
@@ -0,0 +1,112 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToTorquePerLength;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToTorquePerLengthExtensionsTests
+    {
+        [Fact]
+        public void NumberToKilogramForceCentimetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromKilogramForceCentimetersPerMeter(2), 2.KilogramForceCentimetersPerMeter());
+
+        [Fact]
+        public void NumberToKilogramForceMetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromKilogramForceMetersPerMeter(2), 2.KilogramForceMetersPerMeter());
+
+        [Fact]
+        public void NumberToKilogramForceMillimetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromKilogramForceMillimetersPerMeter(2), 2.KilogramForceMillimetersPerMeter());
+
+        [Fact]
+        public void NumberToKilonewtonCentimetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromKilonewtonCentimetersPerMeter(2), 2.KilonewtonCentimetersPerMeter());
+
+        [Fact]
+        public void NumberToKilonewtonMetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromKilonewtonMetersPerMeter(2), 2.KilonewtonMetersPerMeter());
+
+        [Fact]
+        public void NumberToKilonewtonMillimetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromKilonewtonMillimetersPerMeter(2), 2.KilonewtonMillimetersPerMeter());
+
+        [Fact]
+        public void NumberToKilopoundForceFeetPerFootTest() =>
+            Assert.Equal(TorquePerLength.FromKilopoundForceFeetPerFoot(2), 2.KilopoundForceFeetPerFoot());
+
+        [Fact]
+        public void NumberToKilopoundForceInchesPerFootTest() =>
+            Assert.Equal(TorquePerLength.FromKilopoundForceInchesPerFoot(2), 2.KilopoundForceInchesPerFoot());
+
+        [Fact]
+        public void NumberToMeganewtonCentimetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromMeganewtonCentimetersPerMeter(2), 2.MeganewtonCentimetersPerMeter());
+
+        [Fact]
+        public void NumberToMeganewtonMetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromMeganewtonMetersPerMeter(2), 2.MeganewtonMetersPerMeter());
+
+        [Fact]
+        public void NumberToMeganewtonMillimetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromMeganewtonMillimetersPerMeter(2), 2.MeganewtonMillimetersPerMeter());
+
+        [Fact]
+        public void NumberToMegapoundForceFeetPerFootTest() =>
+            Assert.Equal(TorquePerLength.FromMegapoundForceFeetPerFoot(2), 2.MegapoundForceFeetPerFoot());
+
+        [Fact]
+        public void NumberToMegapoundForceInchesPerFootTest() =>
+            Assert.Equal(TorquePerLength.FromMegapoundForceInchesPerFoot(2), 2.MegapoundForceInchesPerFoot());
+
+        [Fact]
+        public void NumberToNewtonCentimetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromNewtonCentimetersPerMeter(2), 2.NewtonCentimetersPerMeter());
+
+        [Fact]
+        public void NumberToNewtonMetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromNewtonMetersPerMeter(2), 2.NewtonMetersPerMeter());
+
+        [Fact]
+        public void NumberToNewtonMillimetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromNewtonMillimetersPerMeter(2), 2.NewtonMillimetersPerMeter());
+
+        [Fact]
+        public void NumberToPoundForceFeetPerFootTest() =>
+            Assert.Equal(TorquePerLength.FromPoundForceFeetPerFoot(2), 2.PoundForceFeetPerFoot());
+
+        [Fact]
+        public void NumberToPoundForceInchesPerFootTest() =>
+            Assert.Equal(TorquePerLength.FromPoundForceInchesPerFoot(2), 2.PoundForceInchesPerFoot());
+
+        [Fact]
+        public void NumberToTonneForceCentimetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromTonneForceCentimetersPerMeter(2), 2.TonneForceCentimetersPerMeter());
+
+        [Fact]
+        public void NumberToTonneForceMetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromTonneForceMetersPerMeter(2), 2.TonneForceMetersPerMeter());
+
+        [Fact]
+        public void NumberToTonneForceMillimetersPerMeterTest() =>
+            Assert.Equal(TorquePerLength.FromTonneForceMillimetersPerMeter(2), 2.TonneForceMillimetersPerMeter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVitaminAExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVitaminAExtensionsTest.g.cs
new file mode 100644
index 0000000000..8db270be0c
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVitaminAExtensionsTest.g.cs
@@ -0,0 +1,32 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToVitaminA;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToVitaminAExtensionsTests
+    {
+        [Fact]
+        public void NumberToInternationalUnitsTest() =>
+            Assert.Equal(VitaminA.FromInternationalUnits(2), 2.InternationalUnits());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs
new file mode 100644
index 0000000000..2fe16bdcdf
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeConcentrationExtensionsTest.g.cs
@@ -0,0 +1,108 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToVolumeConcentration;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToVolumeConcentrationExtensionsTests
+    {
+        [Fact]
+        public void NumberToCentilitersPerLiterTest() =>
+            Assert.Equal(VolumeConcentration.FromCentilitersPerLiter(2), 2.CentilitersPerLiter());
+
+        [Fact]
+        public void NumberToCentilitersPerMililiterTest() =>
+            Assert.Equal(VolumeConcentration.FromCentilitersPerMililiter(2), 2.CentilitersPerMililiter());
+
+        [Fact]
+        public void NumberToDecilitersPerLiterTest() =>
+            Assert.Equal(VolumeConcentration.FromDecilitersPerLiter(2), 2.DecilitersPerLiter());
+
+        [Fact]
+        public void NumberToDecilitersPerMililiterTest() =>
+            Assert.Equal(VolumeConcentration.FromDecilitersPerMililiter(2), 2.DecilitersPerMililiter());
+
+        [Fact]
+        public void NumberToDecimalFractionsTest() =>
+            Assert.Equal(VolumeConcentration.FromDecimalFractions(2), 2.DecimalFractions());
+
+        [Fact]
+        public void NumberToLitersPerLiterTest() =>
+            Assert.Equal(VolumeConcentration.FromLitersPerLiter(2), 2.LitersPerLiter());
+
+        [Fact]
+        public void NumberToLitersPerMililiterTest() =>
+            Assert.Equal(VolumeConcentration.FromLitersPerMililiter(2), 2.LitersPerMililiter());
+
+        [Fact]
+        public void NumberToMicrolitersPerLiterTest() =>
+            Assert.Equal(VolumeConcentration.FromMicrolitersPerLiter(2), 2.MicrolitersPerLiter());
+
+        [Fact]
+        public void NumberToMicrolitersPerMililiterTest() =>
+            Assert.Equal(VolumeConcentration.FromMicrolitersPerMililiter(2), 2.MicrolitersPerMililiter());
+
+        [Fact]
+        public void NumberToMillilitersPerLiterTest() =>
+            Assert.Equal(VolumeConcentration.FromMillilitersPerLiter(2), 2.MillilitersPerLiter());
+
+        [Fact]
+        public void NumberToMillilitersPerMililiterTest() =>
+            Assert.Equal(VolumeConcentration.FromMillilitersPerMililiter(2), 2.MillilitersPerMililiter());
+
+        [Fact]
+        public void NumberToNanolitersPerLiterTest() =>
+            Assert.Equal(VolumeConcentration.FromNanolitersPerLiter(2), 2.NanolitersPerLiter());
+
+        [Fact]
+        public void NumberToNanolitersPerMililiterTest() =>
+            Assert.Equal(VolumeConcentration.FromNanolitersPerMililiter(2), 2.NanolitersPerMililiter());
+
+        [Fact]
+        public void NumberToPartsPerBillionTest() =>
+            Assert.Equal(VolumeConcentration.FromPartsPerBillion(2), 2.PartsPerBillion());
+
+        [Fact]
+        public void NumberToPartsPerMillionTest() =>
+            Assert.Equal(VolumeConcentration.FromPartsPerMillion(2), 2.PartsPerMillion());
+
+        [Fact]
+        public void NumberToPartsPerThousandTest() =>
+            Assert.Equal(VolumeConcentration.FromPartsPerThousand(2), 2.PartsPerThousand());
+
+        [Fact]
+        public void NumberToPartsPerTrillionTest() =>
+            Assert.Equal(VolumeConcentration.FromPartsPerTrillion(2), 2.PartsPerTrillion());
+
+        [Fact]
+        public void NumberToPercentTest() =>
+            Assert.Equal(VolumeConcentration.FromPercent(2), 2.Percent());
+
+        [Fact]
+        public void NumberToPicolitersPerLiterTest() =>
+            Assert.Equal(VolumeConcentration.FromPicolitersPerLiter(2), 2.PicolitersPerLiter());
+
+        [Fact]
+        public void NumberToPicolitersPerMililiterTest() =>
+            Assert.Equal(VolumeConcentration.FromPicolitersPerMililiter(2), 2.PicolitersPerMililiter());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
new file mode 100644
index 0000000000..7db2fa9c11
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeExtensionsTest.g.cs
@@ -0,0 +1,216 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToVolume;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToVolumeExtensionsTests
+    {
+        [Fact]
+        public void NumberToAcreFeetTest() =>
+            Assert.Equal(Volume.FromAcreFeet(2), 2.AcreFeet());
+
+        [Fact]
+        public void NumberToAuTablespoonsTest() =>
+            Assert.Equal(Volume.FromAuTablespoons(2), 2.AuTablespoons());
+
+        [Fact]
+        public void NumberToCentilitersTest() =>
+            Assert.Equal(Volume.FromCentiliters(2), 2.Centiliters());
+
+        [Fact]
+        public void NumberToCubicCentimetersTest() =>
+            Assert.Equal(Volume.FromCubicCentimeters(2), 2.CubicCentimeters());
+
+        [Fact]
+        public void NumberToCubicDecimetersTest() =>
+            Assert.Equal(Volume.FromCubicDecimeters(2), 2.CubicDecimeters());
+
+        [Fact]
+        public void NumberToCubicFeetTest() =>
+            Assert.Equal(Volume.FromCubicFeet(2), 2.CubicFeet());
+
+        [Fact]
+        public void NumberToCubicHectometersTest() =>
+            Assert.Equal(Volume.FromCubicHectometers(2), 2.CubicHectometers());
+
+        [Fact]
+        public void NumberToCubicInchesTest() =>
+            Assert.Equal(Volume.FromCubicInches(2), 2.CubicInches());
+
+        [Fact]
+        public void NumberToCubicKilometersTest() =>
+            Assert.Equal(Volume.FromCubicKilometers(2), 2.CubicKilometers());
+
+        [Fact]
+        public void NumberToCubicMetersTest() =>
+            Assert.Equal(Volume.FromCubicMeters(2), 2.CubicMeters());
+
+        [Fact]
+        public void NumberToCubicMicrometersTest() =>
+            Assert.Equal(Volume.FromCubicMicrometers(2), 2.CubicMicrometers());
+
+        [Fact]
+        public void NumberToCubicMilesTest() =>
+            Assert.Equal(Volume.FromCubicMiles(2), 2.CubicMiles());
+
+        [Fact]
+        public void NumberToCubicMillimetersTest() =>
+            Assert.Equal(Volume.FromCubicMillimeters(2), 2.CubicMillimeters());
+
+        [Fact]
+        public void NumberToCubicYardsTest() =>
+            Assert.Equal(Volume.FromCubicYards(2), 2.CubicYards());
+
+        [Fact]
+        public void NumberToDecilitersTest() =>
+            Assert.Equal(Volume.FromDeciliters(2), 2.Deciliters());
+
+        [Fact]
+        public void NumberToHectocubicFeetTest() =>
+            Assert.Equal(Volume.FromHectocubicFeet(2), 2.HectocubicFeet());
+
+        [Fact]
+        public void NumberToHectocubicMetersTest() =>
+            Assert.Equal(Volume.FromHectocubicMeters(2), 2.HectocubicMeters());
+
+        [Fact]
+        public void NumberToHectolitersTest() =>
+            Assert.Equal(Volume.FromHectoliters(2), 2.Hectoliters());
+
+        [Fact]
+        public void NumberToImperialBeerBarrelsTest() =>
+            Assert.Equal(Volume.FromImperialBeerBarrels(2), 2.ImperialBeerBarrels());
+
+        [Fact]
+        public void NumberToImperialGallonsTest() =>
+            Assert.Equal(Volume.FromImperialGallons(2), 2.ImperialGallons());
+
+        [Fact]
+        public void NumberToImperialOuncesTest() =>
+            Assert.Equal(Volume.FromImperialOunces(2), 2.ImperialOunces());
+
+        [Fact]
+        public void NumberToImperialPintsTest() =>
+            Assert.Equal(Volume.FromImperialPints(2), 2.ImperialPints());
+
+        [Fact]
+        public void NumberToKilocubicFeetTest() =>
+            Assert.Equal(Volume.FromKilocubicFeet(2), 2.KilocubicFeet());
+
+        [Fact]
+        public void NumberToKilocubicMetersTest() =>
+            Assert.Equal(Volume.FromKilocubicMeters(2), 2.KilocubicMeters());
+
+        [Fact]
+        public void NumberToKiloimperialGallonsTest() =>
+            Assert.Equal(Volume.FromKiloimperialGallons(2), 2.KiloimperialGallons());
+
+        [Fact]
+        public void NumberToKilolitersTest() =>
+            Assert.Equal(Volume.FromKiloliters(2), 2.Kiloliters());
+
+        [Fact]
+        public void NumberToKilousGallonsTest() =>
+            Assert.Equal(Volume.FromKilousGallons(2), 2.KilousGallons());
+
+        [Fact]
+        public void NumberToLitersTest() =>
+            Assert.Equal(Volume.FromLiters(2), 2.Liters());
+
+        [Fact]
+        public void NumberToMegacubicFeetTest() =>
+            Assert.Equal(Volume.FromMegacubicFeet(2), 2.MegacubicFeet());
+
+        [Fact]
+        public void NumberToMegaimperialGallonsTest() =>
+            Assert.Equal(Volume.FromMegaimperialGallons(2), 2.MegaimperialGallons());
+
+        [Fact]
+        public void NumberToMegalitersTest() =>
+            Assert.Equal(Volume.FromMegaliters(2), 2.Megaliters());
+
+        [Fact]
+        public void NumberToMegausGallonsTest() =>
+            Assert.Equal(Volume.FromMegausGallons(2), 2.MegausGallons());
+
+        [Fact]
+        public void NumberToMetricCupsTest() =>
+            Assert.Equal(Volume.FromMetricCups(2), 2.MetricCups());
+
+        [Fact]
+        public void NumberToMetricTeaspoonsTest() =>
+            Assert.Equal(Volume.FromMetricTeaspoons(2), 2.MetricTeaspoons());
+
+        [Fact]
+        public void NumberToMicrolitersTest() =>
+            Assert.Equal(Volume.FromMicroliters(2), 2.Microliters());
+
+        [Fact]
+        public void NumberToMillilitersTest() =>
+            Assert.Equal(Volume.FromMilliliters(2), 2.Milliliters());
+
+        [Fact]
+        public void NumberToOilBarrelsTest() =>
+            Assert.Equal(Volume.FromOilBarrels(2), 2.OilBarrels());
+
+        [Fact]
+        public void NumberToUkTablespoonsTest() =>
+            Assert.Equal(Volume.FromUkTablespoons(2), 2.UkTablespoons());
+
+        [Fact]
+        public void NumberToUsBeerBarrelsTest() =>
+            Assert.Equal(Volume.FromUsBeerBarrels(2), 2.UsBeerBarrels());
+
+        [Fact]
+        public void NumberToUsCustomaryCupsTest() =>
+            Assert.Equal(Volume.FromUsCustomaryCups(2), 2.UsCustomaryCups());
+
+        [Fact]
+        public void NumberToUsGallonsTest() =>
+            Assert.Equal(Volume.FromUsGallons(2), 2.UsGallons());
+
+        [Fact]
+        public void NumberToUsLegalCupsTest() =>
+            Assert.Equal(Volume.FromUsLegalCups(2), 2.UsLegalCups());
+
+        [Fact]
+        public void NumberToUsOuncesTest() =>
+            Assert.Equal(Volume.FromUsOunces(2), 2.UsOunces());
+
+        [Fact]
+        public void NumberToUsPintsTest() =>
+            Assert.Equal(Volume.FromUsPints(2), 2.UsPints());
+
+        [Fact]
+        public void NumberToUsQuartsTest() =>
+            Assert.Equal(Volume.FromUsQuarts(2), 2.UsQuarts());
+
+        [Fact]
+        public void NumberToUsTablespoonsTest() =>
+            Assert.Equal(Volume.FromUsTablespoons(2), 2.UsTablespoons());
+
+        [Fact]
+        public void NumberToUsTeaspoonsTest() =>
+            Assert.Equal(Volume.FromUsTeaspoons(2), 2.UsTeaspoons());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
new file mode 100644
index 0000000000..352c4579c2
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumeFlowExtensionsTest.g.cs
@@ -0,0 +1,224 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToVolumeFlow;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToVolumeFlowExtensionsTests
+    {
+        [Fact]
+        public void NumberToAcreFeetPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromAcreFeetPerDay(2), 2.AcreFeetPerDay());
+
+        [Fact]
+        public void NumberToAcreFeetPerHourTest() =>
+            Assert.Equal(VolumeFlow.FromAcreFeetPerHour(2), 2.AcreFeetPerHour());
+
+        [Fact]
+        public void NumberToAcreFeetPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromAcreFeetPerMinute(2), 2.AcreFeetPerMinute());
+
+        [Fact]
+        public void NumberToAcreFeetPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromAcreFeetPerSecond(2), 2.AcreFeetPerSecond());
+
+        [Fact]
+        public void NumberToCentilitersPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromCentilitersPerDay(2), 2.CentilitersPerDay());
+
+        [Fact]
+        public void NumberToCentilitersPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromCentilitersPerMinute(2), 2.CentilitersPerMinute());
+
+        [Fact]
+        public void NumberToCubicDecimetersPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromCubicDecimetersPerMinute(2), 2.CubicDecimetersPerMinute());
+
+        [Fact]
+        public void NumberToCubicFeetPerHourTest() =>
+            Assert.Equal(VolumeFlow.FromCubicFeetPerHour(2), 2.CubicFeetPerHour());
+
+        [Fact]
+        public void NumberToCubicFeetPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromCubicFeetPerMinute(2), 2.CubicFeetPerMinute());
+
+        [Fact]
+        public void NumberToCubicFeetPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromCubicFeetPerSecond(2), 2.CubicFeetPerSecond());
+
+        [Fact]
+        public void NumberToCubicMetersPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromCubicMetersPerDay(2), 2.CubicMetersPerDay());
+
+        [Fact]
+        public void NumberToCubicMetersPerHourTest() =>
+            Assert.Equal(VolumeFlow.FromCubicMetersPerHour(2), 2.CubicMetersPerHour());
+
+        [Fact]
+        public void NumberToCubicMetersPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromCubicMetersPerMinute(2), 2.CubicMetersPerMinute());
+
+        [Fact]
+        public void NumberToCubicMetersPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(2), 2.CubicMetersPerSecond());
+
+        [Fact]
+        public void NumberToCubicMillimetersPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromCubicMillimetersPerSecond(2), 2.CubicMillimetersPerSecond());
+
+        [Fact]
+        public void NumberToCubicYardsPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromCubicYardsPerDay(2), 2.CubicYardsPerDay());
+
+        [Fact]
+        public void NumberToCubicYardsPerHourTest() =>
+            Assert.Equal(VolumeFlow.FromCubicYardsPerHour(2), 2.CubicYardsPerHour());
+
+        [Fact]
+        public void NumberToCubicYardsPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromCubicYardsPerMinute(2), 2.CubicYardsPerMinute());
+
+        [Fact]
+        public void NumberToCubicYardsPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromCubicYardsPerSecond(2), 2.CubicYardsPerSecond());
+
+        [Fact]
+        public void NumberToDecilitersPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromDecilitersPerDay(2), 2.DecilitersPerDay());
+
+        [Fact]
+        public void NumberToDecilitersPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromDecilitersPerMinute(2), 2.DecilitersPerMinute());
+
+        [Fact]
+        public void NumberToKilolitersPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromKilolitersPerDay(2), 2.KilolitersPerDay());
+
+        [Fact]
+        public void NumberToKilolitersPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromKilolitersPerMinute(2), 2.KilolitersPerMinute());
+
+        [Fact]
+        public void NumberToKilousGallonsPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromKilousGallonsPerMinute(2), 2.KilousGallonsPerMinute());
+
+        [Fact]
+        public void NumberToLitersPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromLitersPerDay(2), 2.LitersPerDay());
+
+        [Fact]
+        public void NumberToLitersPerHourTest() =>
+            Assert.Equal(VolumeFlow.FromLitersPerHour(2), 2.LitersPerHour());
+
+        [Fact]
+        public void NumberToLitersPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromLitersPerMinute(2), 2.LitersPerMinute());
+
+        [Fact]
+        public void NumberToLitersPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromLitersPerSecond(2), 2.LitersPerSecond());
+
+        [Fact]
+        public void NumberToMegalitersPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromMegalitersPerDay(2), 2.MegalitersPerDay());
+
+        [Fact]
+        public void NumberToMegaukGallonsPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromMegaukGallonsPerSecond(2), 2.MegaukGallonsPerSecond());
+
+        [Fact]
+        public void NumberToMicrolitersPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromMicrolitersPerDay(2), 2.MicrolitersPerDay());
+
+        [Fact]
+        public void NumberToMicrolitersPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromMicrolitersPerMinute(2), 2.MicrolitersPerMinute());
+
+        [Fact]
+        public void NumberToMillilitersPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromMillilitersPerDay(2), 2.MillilitersPerDay());
+
+        [Fact]
+        public void NumberToMillilitersPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromMillilitersPerMinute(2), 2.MillilitersPerMinute());
+
+        [Fact]
+        public void NumberToMillionUsGallonsPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromMillionUsGallonsPerDay(2), 2.MillionUsGallonsPerDay());
+
+        [Fact]
+        public void NumberToNanolitersPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromNanolitersPerDay(2), 2.NanolitersPerDay());
+
+        [Fact]
+        public void NumberToNanolitersPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromNanolitersPerMinute(2), 2.NanolitersPerMinute());
+
+        [Fact]
+        public void NumberToOilBarrelsPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromOilBarrelsPerDay(2), 2.OilBarrelsPerDay());
+
+        [Fact]
+        public void NumberToOilBarrelsPerHourTest() =>
+            Assert.Equal(VolumeFlow.FromOilBarrelsPerHour(2), 2.OilBarrelsPerHour());
+
+        [Fact]
+        public void NumberToOilBarrelsPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromOilBarrelsPerMinute(2), 2.OilBarrelsPerMinute());
+
+        [Fact]
+        public void NumberToOilBarrelsPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromOilBarrelsPerSecond(2), 2.OilBarrelsPerSecond());
+
+        [Fact]
+        public void NumberToUkGallonsPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromUkGallonsPerDay(2), 2.UkGallonsPerDay());
+
+        [Fact]
+        public void NumberToUkGallonsPerHourTest() =>
+            Assert.Equal(VolumeFlow.FromUkGallonsPerHour(2), 2.UkGallonsPerHour());
+
+        [Fact]
+        public void NumberToUkGallonsPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromUkGallonsPerMinute(2), 2.UkGallonsPerMinute());
+
+        [Fact]
+        public void NumberToUkGallonsPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromUkGallonsPerSecond(2), 2.UkGallonsPerSecond());
+
+        [Fact]
+        public void NumberToUsGallonsPerDayTest() =>
+            Assert.Equal(VolumeFlow.FromUsGallonsPerDay(2), 2.UsGallonsPerDay());
+
+        [Fact]
+        public void NumberToUsGallonsPerHourTest() =>
+            Assert.Equal(VolumeFlow.FromUsGallonsPerHour(2), 2.UsGallonsPerHour());
+
+        [Fact]
+        public void NumberToUsGallonsPerMinuteTest() =>
+            Assert.Equal(VolumeFlow.FromUsGallonsPerMinute(2), 2.UsGallonsPerMinute());
+
+        [Fact]
+        public void NumberToUsGallonsPerSecondTest() =>
+            Assert.Equal(VolumeFlow.FromUsGallonsPerSecond(2), 2.UsGallonsPerSecond());
+
+    }
+}
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumePerLengthExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumePerLengthExtensionsTest.g.cs
new file mode 100644
index 0000000000..4aeca3761a
--- /dev/null
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToVolumePerLengthExtensionsTest.g.cs
@@ -0,0 +1,48 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by \generate-code.bat.
+//
+//     Changes to this file will be lost when the code is regenerated.
+//     The build server regenerates the code before each build and a pre-build
+//     step will regenerate the code on each local build.
+//
+//     See https://github.com/angularsen/UnitsNet/wiki/Adding-a-New-Unit for how to add or edit units.
+//
+//     Add CustomCode\Quantities\MyQuantity.extra.cs files to add code to generated quantities.
+//     Add UnitDefinitions\MyQuantity.json and run generate-code.bat to generate new units or quantities.
+//
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using UnitsNet.NumberExtensions.NumberToVolumePerLength;
+using Xunit;
+
+namespace UnitsNet.Tests
+{    
+    public class NumberToVolumePerLengthExtensionsTests
+    {
+        [Fact]
+        public void NumberToCubicMetersPerMeterTest() =>
+            Assert.Equal(VolumePerLength.FromCubicMetersPerMeter(2), 2.CubicMetersPerMeter());
+
+        [Fact]
+        public void NumberToCubicYardsPerFootTest() =>
+            Assert.Equal(VolumePerLength.FromCubicYardsPerFoot(2), 2.CubicYardsPerFoot());
+
+        [Fact]
+        public void NumberToCubicYardsPerUsSurveyFootTest() =>
+            Assert.Equal(VolumePerLength.FromCubicYardsPerUsSurveyFoot(2), 2.CubicYardsPerUsSurveyFoot());
+
+        [Fact]
+        public void NumberToLitersPerMeterTest() =>
+            Assert.Equal(VolumePerLength.FromLitersPerMeter(2), 2.LitersPerMeter());
+
+        [Fact]
+        public void NumberToOilBarrelsPerFootTest() =>
+            Assert.Equal(VolumePerLength.FromOilBarrelsPerFoot(2), 2.OilBarrelsPerFoot());
+
+    }
+}
diff --git a/UnitsNet.Extensions.Tests/UnitsNet.Extensions.Tests.csproj b/UnitsNet.NumberExtensions.Tests/UnitsNet.NumberExtensions.Tests.csproj
similarity index 80%
rename from UnitsNet.Extensions.Tests/UnitsNet.Extensions.Tests.csproj
rename to UnitsNet.NumberExtensions.Tests/UnitsNet.NumberExtensions.Tests.csproj
index 751f4469f7..bf36dd26ff 100644
--- a/UnitsNet.Extensions.Tests/UnitsNet.Extensions.Tests.csproj
+++ b/UnitsNet.NumberExtensions.Tests/UnitsNet.NumberExtensions.Tests.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFrameworks>netcoreapp2.1</TargetFrameworks>
-    <RootNamespace>UnitsNet.Extensions.Tests</RootNamespace>
+    <RootNamespace>UnitsNet.NumberExtensions.Tests</RootNamespace>
     <LangVersion>latest</LangVersion>
     <MSBuildTreatWarningsAsErrors>true</MSBuildTreatWarningsAsErrors>
     <IsTestProject>true</IsTestProject>
@@ -13,7 +13,7 @@
     <AssemblyOriginatorKeyFile>../UnitsNet.snk</AssemblyOriginatorKeyFile>
     <DelaySign>false</DelaySign>
     <SignAssembly>true</SignAssembly>
-    <AssemblyName>UnitsNet.Extensions.Tests</AssemblyName>
+    <AssemblyName>UnitsNet.NumberExtensions.Tests</AssemblyName>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
   </PropertyGroup>
 
@@ -33,7 +33,11 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\UnitsNet.Extensions\UnitsNet.Extensions.csproj" />
+    <ProjectReference Include="..\UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="GeneratedCode\" />
   </ItemGroup>
 
 </Project>
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
similarity index 67%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAccelerationExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
index a67f59440d..3c14db7c0e 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAccelerationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
@@ -19,117 +19,64 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToAcceleration
+namespace UnitsNet.NumberExtensions.NumberToAcceleration
 {
     /// <summary>
     /// A number to Acceleration Extensions
     /// </summary>
     public static class NumberToAccelerationExtensions
     {
-
-        #region CentimeterPerSecondSquared
-
         /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(UnitsNet.QuantityValue)" />
         public static Acceleration CentimetersPerSecondSquared<T>(this T value) =>
-             Acceleration.FromCentimetersPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecimeterPerSecondSquared
+            Acceleration.FromCentimetersPerSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(UnitsNet.QuantityValue)" />
         public static Acceleration DecimetersPerSecondSquared<T>(this T value) =>
-             Acceleration.FromDecimetersPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region FootPerSecondSquared
+            Acceleration.FromDecimetersPerSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromFeetPerSecondSquared(UnitsNet.QuantityValue)" />
         public static Acceleration FeetPerSecondSquared<T>(this T value) =>
-             Acceleration.FromFeetPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region InchPerSecondSquared
+            Acceleration.FromFeetPerSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromInchesPerSecondSquared(UnitsNet.QuantityValue)" />
         public static Acceleration InchesPerSecondSquared<T>(this T value) =>
-             Acceleration.FromInchesPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilometerPerSecondSquared
+            Acceleration.FromInchesPerSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(UnitsNet.QuantityValue)" />
         public static Acceleration KilometersPerSecondSquared<T>(this T value) =>
-             Acceleration.FromKilometersPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KnotPerHour
+            Acceleration.FromKilometersPerSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromKnotsPerHour(UnitsNet.QuantityValue)" />
         public static Acceleration KnotsPerHour<T>(this T value) =>
-             Acceleration.FromKnotsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KnotPerMinute
+            Acceleration.FromKnotsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromKnotsPerMinute(UnitsNet.QuantityValue)" />
         public static Acceleration KnotsPerMinute<T>(this T value) =>
-             Acceleration.FromKnotsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KnotPerSecond
+            Acceleration.FromKnotsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromKnotsPerSecond(UnitsNet.QuantityValue)" />
         public static Acceleration KnotsPerSecond<T>(this T value) =>
-             Acceleration.FromKnotsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeterPerSecondSquared
+            Acceleration.FromKnotsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(UnitsNet.QuantityValue)" />
         public static Acceleration MetersPerSecondSquared<T>(this T value) =>
-             Acceleration.FromMetersPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrometerPerSecondSquared
+            Acceleration.FromMetersPerSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(UnitsNet.QuantityValue)" />
         public static Acceleration MicrometersPerSecondSquared<T>(this T value) =>
-             Acceleration.FromMicrometersPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillimeterPerSecondSquared
+            Acceleration.FromMicrometersPerSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(UnitsNet.QuantityValue)" />
         public static Acceleration MillimetersPerSecondSquared<T>(this T value) =>
-             Acceleration.FromMillimetersPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanometerPerSecondSquared
+            Acceleration.FromMillimetersPerSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(UnitsNet.QuantityValue)" />
         public static Acceleration NanometersPerSecondSquared<T>(this T value) =>
-             Acceleration.FromNanometersPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region StandardGravity
+            Acceleration.FromNanometersPerSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Acceleration.FromStandardGravity(UnitsNet.QuantityValue)" />
         public static Acceleration StandardGravity<T>(this T value) =>
-             Acceleration.FromStandardGravity(Convert.ToDouble(value));
-
-        #endregion
+            Acceleration.FromStandardGravity(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAmountOfSubstanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
similarity index 67%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAmountOfSubstanceExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
index 8daef05c79..e3df11aea9 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAmountOfSubstanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
@@ -19,133 +19,72 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToAmountOfSubstance
+namespace UnitsNet.NumberExtensions.NumberToAmountOfSubstance
 {
     /// <summary>
     /// A number to AmountOfSubstance Extensions
     /// </summary>
     public static class NumberToAmountOfSubstanceExtensions
     {
-
-        #region Centimole
-
         /// <inheritdoc cref="AmountOfSubstance.FromCentimoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance Centimoles<T>(this T value) =>
-             AmountOfSubstance.FromCentimoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentipoundMole
+            AmountOfSubstance.FromCentimoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromCentipoundMoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance CentipoundMoles<T>(this T value) =>
-             AmountOfSubstance.FromCentipoundMoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Decimole
+            AmountOfSubstance.FromCentipoundMoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromDecimoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance Decimoles<T>(this T value) =>
-             AmountOfSubstance.FromDecimoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecipoundMole
+            AmountOfSubstance.FromDecimoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromDecipoundMoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance DecipoundMoles<T>(this T value) =>
-             AmountOfSubstance.FromDecipoundMoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilomole
+            AmountOfSubstance.FromDecipoundMoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromKilomoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance Kilomoles<T>(this T value) =>
-             AmountOfSubstance.FromKilomoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundMole
+            AmountOfSubstance.FromKilomoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromKilopoundMoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance KilopoundMoles<T>(this T value) =>
-             AmountOfSubstance.FromKilopoundMoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megamole
+            AmountOfSubstance.FromKilopoundMoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromMegamoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance Megamoles<T>(this T value) =>
-             AmountOfSubstance.FromMegamoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Micromole
+            AmountOfSubstance.FromMegamoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromMicromoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance Micromoles<T>(this T value) =>
-             AmountOfSubstance.FromMicromoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicropoundMole
+            AmountOfSubstance.FromMicromoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromMicropoundMoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance MicropoundMoles<T>(this T value) =>
-             AmountOfSubstance.FromMicropoundMoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millimole
+            AmountOfSubstance.FromMicropoundMoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromMillimoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance Millimoles<T>(this T value) =>
-             AmountOfSubstance.FromMillimoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillipoundMole
+            AmountOfSubstance.FromMillimoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromMillipoundMoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance MillipoundMoles<T>(this T value) =>
-             AmountOfSubstance.FromMillipoundMoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Mole
+            AmountOfSubstance.FromMillipoundMoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromMoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance Moles<T>(this T value) =>
-             AmountOfSubstance.FromMoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanomole
+            AmountOfSubstance.FromMoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromNanomoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance Nanomoles<T>(this T value) =>
-             AmountOfSubstance.FromNanomoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanopoundMole
+            AmountOfSubstance.FromNanomoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromNanopoundMoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance NanopoundMoles<T>(this T value) =>
-             AmountOfSubstance.FromNanopoundMoles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundMole
+            AmountOfSubstance.FromNanopoundMoles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmountOfSubstance.FromPoundMoles(UnitsNet.QuantityValue)" />
         public static AmountOfSubstance PoundMoles<T>(this T value) =>
-             AmountOfSubstance.FromPoundMoles(Convert.ToDouble(value));
-
-        #endregion
+            AmountOfSubstance.FromPoundMoles(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAmplitudeRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
similarity index 77%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAmplitudeRatioExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
index 5c70c5628c..e060c52296 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAmplitudeRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
@@ -19,45 +19,28 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToAmplitudeRatio
+namespace UnitsNet.NumberExtensions.NumberToAmplitudeRatio
 {
     /// <summary>
     /// A number to AmplitudeRatio Extensions
     /// </summary>
     public static class NumberToAmplitudeRatioExtensions
     {
-
-        #region DecibelMicrovolt
-
         /// <inheritdoc cref="AmplitudeRatio.FromDecibelMicrovolts(UnitsNet.QuantityValue)" />
         public static AmplitudeRatio DecibelMicrovolts<T>(this T value) =>
-             AmplitudeRatio.FromDecibelMicrovolts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecibelMillivolt
+            AmplitudeRatio.FromDecibelMicrovolts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmplitudeRatio.FromDecibelMillivolts(UnitsNet.QuantityValue)" />
         public static AmplitudeRatio DecibelMillivolts<T>(this T value) =>
-             AmplitudeRatio.FromDecibelMillivolts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecibelUnloaded
+            AmplitudeRatio.FromDecibelMillivolts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmplitudeRatio.FromDecibelsUnloaded(UnitsNet.QuantityValue)" />
         public static AmplitudeRatio DecibelsUnloaded<T>(this T value) =>
-             AmplitudeRatio.FromDecibelsUnloaded(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecibelVolt
+            AmplitudeRatio.FromDecibelsUnloaded(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AmplitudeRatio.FromDecibelVolts(UnitsNet.QuantityValue)" />
         public static AmplitudeRatio DecibelVolts<T>(this T value) =>
-             AmplitudeRatio.FromDecibelVolts(Convert.ToDouble(value));
-
-        #endregion
+            AmplitudeRatio.FromDecibelVolts(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAngleExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
similarity index 66%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAngleExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
index 2206e364a5..507235f584 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAngleExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
@@ -19,125 +19,68 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToAngle
+namespace UnitsNet.NumberExtensions.NumberToAngle
 {
     /// <summary>
     /// A number to Angle Extensions
     /// </summary>
     public static class NumberToAngleExtensions
     {
-
-        #region Arcminute
-
         /// <inheritdoc cref="Angle.FromArcminutes(UnitsNet.QuantityValue)" />
         public static Angle Arcminutes<T>(this T value) =>
-             Angle.FromArcminutes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Arcsecond
+            Angle.FromArcminutes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromArcseconds(UnitsNet.QuantityValue)" />
         public static Angle Arcseconds<T>(this T value) =>
-             Angle.FromArcseconds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Centiradian
+            Angle.FromArcseconds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromCentiradians(UnitsNet.QuantityValue)" />
         public static Angle Centiradians<T>(this T value) =>
-             Angle.FromCentiradians(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Deciradian
+            Angle.FromCentiradians(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromDeciradians(UnitsNet.QuantityValue)" />
         public static Angle Deciradians<T>(this T value) =>
-             Angle.FromDeciradians(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Degree
+            Angle.FromDeciradians(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromDegrees(UnitsNet.QuantityValue)" />
         public static Angle Degrees<T>(this T value) =>
-             Angle.FromDegrees(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Gradian
+            Angle.FromDegrees(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromGradians(UnitsNet.QuantityValue)" />
         public static Angle Gradians<T>(this T value) =>
-             Angle.FromGradians(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microdegree
+            Angle.FromGradians(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromMicrodegrees(UnitsNet.QuantityValue)" />
         public static Angle Microdegrees<T>(this T value) =>
-             Angle.FromMicrodegrees(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microradian
+            Angle.FromMicrodegrees(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromMicroradians(UnitsNet.QuantityValue)" />
         public static Angle Microradians<T>(this T value) =>
-             Angle.FromMicroradians(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millidegree
+            Angle.FromMicroradians(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromMillidegrees(UnitsNet.QuantityValue)" />
         public static Angle Millidegrees<T>(this T value) =>
-             Angle.FromMillidegrees(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Milliradian
+            Angle.FromMillidegrees(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromMilliradians(UnitsNet.QuantityValue)" />
         public static Angle Milliradians<T>(this T value) =>
-             Angle.FromMilliradians(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanodegree
+            Angle.FromMilliradians(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromNanodegrees(UnitsNet.QuantityValue)" />
         public static Angle Nanodegrees<T>(this T value) =>
-             Angle.FromNanodegrees(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanoradian
+            Angle.FromNanodegrees(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromNanoradians(UnitsNet.QuantityValue)" />
         public static Angle Nanoradians<T>(this T value) =>
-             Angle.FromNanoradians(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Radian
+            Angle.FromNanoradians(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromRadians(UnitsNet.QuantityValue)" />
         public static Angle Radians<T>(this T value) =>
-             Angle.FromRadians(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Revolution
+            Angle.FromRadians(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Angle.FromRevolutions(UnitsNet.QuantityValue)" />
         public static Angle Revolutions<T>(this T value) =>
-             Angle.FromRevolutions(Convert.ToDouble(value));
-
-        #endregion
+            Angle.FromRevolutions(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToApparentEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentEnergyExtensions.g.cs
similarity index 79%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToApparentEnergyExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentEnergyExtensions.g.cs
index ceacfcb326..20a600ca59 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToApparentEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentEnergyExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToApparentEnergy
+namespace UnitsNet.NumberExtensions.NumberToApparentEnergy
 {
     /// <summary>
     /// A number to ApparentEnergy Extensions
     /// </summary>
     public static class NumberToApparentEnergyExtensions
     {
-
-        #region KilovoltampereHour
-
         /// <inheritdoc cref="ApparentEnergy.FromKilovoltampereHours(UnitsNet.QuantityValue)" />
         public static ApparentEnergy KilovoltampereHours<T>(this T value) =>
-             ApparentEnergy.FromKilovoltampereHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegavoltampereHour
+            ApparentEnergy.FromKilovoltampereHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ApparentEnergy.FromMegavoltampereHours(UnitsNet.QuantityValue)" />
         public static ApparentEnergy MegavoltampereHours<T>(this T value) =>
-             ApparentEnergy.FromMegavoltampereHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region VoltampereHour
+            ApparentEnergy.FromMegavoltampereHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ApparentEnergy.FromVoltampereHours(UnitsNet.QuantityValue)" />
         public static ApparentEnergy VoltampereHours<T>(this T value) =>
-             ApparentEnergy.FromVoltampereHours(Convert.ToDouble(value));
-
-        #endregion
+            ApparentEnergy.FromVoltampereHours(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToApparentPowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentPowerExtensions.g.cs
similarity index 77%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToApparentPowerExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentPowerExtensions.g.cs
index 144b2a6315..ce90e6a8bf 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToApparentPowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentPowerExtensions.g.cs
@@ -19,45 +19,28 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToApparentPower
+namespace UnitsNet.NumberExtensions.NumberToApparentPower
 {
     /// <summary>
     /// A number to ApparentPower Extensions
     /// </summary>
     public static class NumberToApparentPowerExtensions
     {
-
-        #region Gigavoltampere
-
         /// <inheritdoc cref="ApparentPower.FromGigavoltamperes(UnitsNet.QuantityValue)" />
         public static ApparentPower Gigavoltamperes<T>(this T value) =>
-             ApparentPower.FromGigavoltamperes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilovoltampere
+            ApparentPower.FromGigavoltamperes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ApparentPower.FromKilovoltamperes(UnitsNet.QuantityValue)" />
         public static ApparentPower Kilovoltamperes<T>(this T value) =>
-             ApparentPower.FromKilovoltamperes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megavoltampere
+            ApparentPower.FromKilovoltamperes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ApparentPower.FromMegavoltamperes(UnitsNet.QuantityValue)" />
         public static ApparentPower Megavoltamperes<T>(this T value) =>
-             ApparentPower.FromMegavoltamperes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Voltampere
+            ApparentPower.FromMegavoltamperes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ApparentPower.FromVoltamperes(UnitsNet.QuantityValue)" />
         public static ApparentPower Voltamperes<T>(this T value) =>
-             ApparentPower.FromVoltamperes(Convert.ToDouble(value));
-
-        #endregion
+            ApparentPower.FromVoltamperes(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
similarity index 87%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaDensityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
index aab6cc9e76..d56171d4fc 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToAreaDensity
+namespace UnitsNet.NumberExtensions.NumberToAreaDensity
 {
     /// <summary>
     /// A number to AreaDensity Extensions
     /// </summary>
     public static class NumberToAreaDensityExtensions
     {
-
-        #region KilogramPerSquareMeter
-
         /// <inheritdoc cref="AreaDensity.FromKilogramsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static AreaDensity KilogramsPerSquareMeter<T>(this T value) =>
-             AreaDensity.FromKilogramsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
+            AreaDensity.FromKilogramsPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
similarity index 66%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
index 46e854faed..cd45e9c841 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
@@ -19,125 +19,68 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToArea
+namespace UnitsNet.NumberExtensions.NumberToArea
 {
     /// <summary>
     /// A number to Area Extensions
     /// </summary>
     public static class NumberToAreaExtensions
     {
-
-        #region Acre
-
         /// <inheritdoc cref="Area.FromAcres(UnitsNet.QuantityValue)" />
         public static Area Acres<T>(this T value) =>
-             Area.FromAcres(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Hectare
+            Area.FromAcres(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromHectares(UnitsNet.QuantityValue)" />
         public static Area Hectares<T>(this T value) =>
-             Area.FromHectares(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareCentimeter
+            Area.FromHectares(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromSquareCentimeters(UnitsNet.QuantityValue)" />
         public static Area SquareCentimeters<T>(this T value) =>
-             Area.FromSquareCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareDecimeter
+            Area.FromSquareCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromSquareDecimeters(UnitsNet.QuantityValue)" />
         public static Area SquareDecimeters<T>(this T value) =>
-             Area.FromSquareDecimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareFoot
+            Area.FromSquareDecimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromSquareFeet(UnitsNet.QuantityValue)" />
         public static Area SquareFeet<T>(this T value) =>
-             Area.FromSquareFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareInch
+            Area.FromSquareFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromSquareInches(UnitsNet.QuantityValue)" />
         public static Area SquareInches<T>(this T value) =>
-             Area.FromSquareInches(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareKilometer
+            Area.FromSquareInches(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromSquareKilometers(UnitsNet.QuantityValue)" />
         public static Area SquareKilometers<T>(this T value) =>
-             Area.FromSquareKilometers(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareMeter
+            Area.FromSquareKilometers(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromSquareMeters(UnitsNet.QuantityValue)" />
         public static Area SquareMeters<T>(this T value) =>
-             Area.FromSquareMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareMicrometer
+            Area.FromSquareMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromSquareMicrometers(UnitsNet.QuantityValue)" />
         public static Area SquareMicrometers<T>(this T value) =>
-             Area.FromSquareMicrometers(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareMile
+            Area.FromSquareMicrometers(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromSquareMiles(UnitsNet.QuantityValue)" />
         public static Area SquareMiles<T>(this T value) =>
-             Area.FromSquareMiles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareMillimeter
+            Area.FromSquareMiles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromSquareMillimeters(UnitsNet.QuantityValue)" />
         public static Area SquareMillimeters<T>(this T value) =>
-             Area.FromSquareMillimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareNauticalMile
+            Area.FromSquareMillimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromSquareNauticalMiles(UnitsNet.QuantityValue)" />
         public static Area SquareNauticalMiles<T>(this T value) =>
-             Area.FromSquareNauticalMiles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareYard
+            Area.FromSquareNauticalMiles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromSquareYards(UnitsNet.QuantityValue)" />
         public static Area SquareYards<T>(this T value) =>
-             Area.FromSquareYards(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsSurveySquareFoot
+            Area.FromSquareYards(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Area.FromUsSurveySquareFeet(UnitsNet.QuantityValue)" />
         public static Area UsSurveySquareFeet<T>(this T value) =>
-             Area.FromUsSurveySquareFeet(Convert.ToDouble(value));
-
-        #endregion
+            Area.FromUsSurveySquareFeet(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
similarity index 72%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaMomentOfInertiaExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
index 5dfe62cc3b..de06c0e10c 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToAreaMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
@@ -19,61 +19,36 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToAreaMomentOfInertia
+namespace UnitsNet.NumberExtensions.NumberToAreaMomentOfInertia
 {
     /// <summary>
     /// A number to AreaMomentOfInertia Extensions
     /// </summary>
     public static class NumberToAreaMomentOfInertiaExtensions
     {
-
-        #region CentimeterToTheFourth
-
         /// <inheritdoc cref="AreaMomentOfInertia.FromCentimetersToTheFourth(UnitsNet.QuantityValue)" />
         public static AreaMomentOfInertia CentimetersToTheFourth<T>(this T value) =>
-             AreaMomentOfInertia.FromCentimetersToTheFourth(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecimeterToTheFourth
+            AreaMomentOfInertia.FromCentimetersToTheFourth(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AreaMomentOfInertia.FromDecimetersToTheFourth(UnitsNet.QuantityValue)" />
         public static AreaMomentOfInertia DecimetersToTheFourth<T>(this T value) =>
-             AreaMomentOfInertia.FromDecimetersToTheFourth(Convert.ToDouble(value));
-
-        #endregion
-
-        #region FootToTheFourth
+            AreaMomentOfInertia.FromDecimetersToTheFourth(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AreaMomentOfInertia.FromFeetToTheFourth(UnitsNet.QuantityValue)" />
         public static AreaMomentOfInertia FeetToTheFourth<T>(this T value) =>
-             AreaMomentOfInertia.FromFeetToTheFourth(Convert.ToDouble(value));
-
-        #endregion
-
-        #region InchToTheFourth
+            AreaMomentOfInertia.FromFeetToTheFourth(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AreaMomentOfInertia.FromInchesToTheFourth(UnitsNet.QuantityValue)" />
         public static AreaMomentOfInertia InchesToTheFourth<T>(this T value) =>
-             AreaMomentOfInertia.FromInchesToTheFourth(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeterToTheFourth
+            AreaMomentOfInertia.FromInchesToTheFourth(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AreaMomentOfInertia.FromMetersToTheFourth(UnitsNet.QuantityValue)" />
         public static AreaMomentOfInertia MetersToTheFourth<T>(this T value) =>
-             AreaMomentOfInertia.FromMetersToTheFourth(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillimeterToTheFourth
+            AreaMomentOfInertia.FromMetersToTheFourth(Convert.ToDouble(value));
 
         /// <inheritdoc cref="AreaMomentOfInertia.FromMillimetersToTheFourth(UnitsNet.QuantityValue)" />
         public static AreaMomentOfInertia MillimetersToTheFourth<T>(this T value) =>
-             AreaMomentOfInertia.FromMillimetersToTheFourth(Convert.ToDouble(value));
-
-        #endregion
+            AreaMomentOfInertia.FromMillimetersToTheFourth(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToBitRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
similarity index 62%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToBitRateExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
index e3b9eab958..cd41a2a8f2 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToBitRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
@@ -19,221 +19,116 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToBitRate
+namespace UnitsNet.NumberExtensions.NumberToBitRate
 {
     /// <summary>
     /// A number to BitRate Extensions
     /// </summary>
     public static class NumberToBitRateExtensions
     {
-
-        #region BitPerSecond
-
         /// <inheritdoc cref="BitRate.FromBitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate BitsPerSecond<T>(this T value) =>
-             BitRate.FromBitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region BytePerSecond
+            BitRate.FromBitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromBytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate BytesPerSecond<T>(this T value) =>
-             BitRate.FromBytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ExabitPerSecond
+            BitRate.FromBytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromExabitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate ExabitsPerSecond<T>(this T value) =>
-             BitRate.FromExabitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ExabytePerSecond
+            BitRate.FromExabitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromExabytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate ExabytesPerSecond<T>(this T value) =>
-             BitRate.FromExabytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ExbibitPerSecond
+            BitRate.FromExabytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromExbibitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate ExbibitsPerSecond<T>(this T value) =>
-             BitRate.FromExbibitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ExbibytePerSecond
+            BitRate.FromExbibitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromExbibytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate ExbibytesPerSecond<T>(this T value) =>
-             BitRate.FromExbibytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GibibitPerSecond
+            BitRate.FromExbibytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromGibibitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate GibibitsPerSecond<T>(this T value) =>
-             BitRate.FromGibibitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GibibytePerSecond
+            BitRate.FromGibibitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromGibibytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate GibibytesPerSecond<T>(this T value) =>
-             BitRate.FromGibibytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GigabitPerSecond
+            BitRate.FromGibibytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromGigabitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate GigabitsPerSecond<T>(this T value) =>
-             BitRate.FromGigabitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GigabytePerSecond
+            BitRate.FromGigabitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromGigabytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate GigabytesPerSecond<T>(this T value) =>
-             BitRate.FromGigabytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KibibitPerSecond
+            BitRate.FromGigabytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromKibibitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate KibibitsPerSecond<T>(this T value) =>
-             BitRate.FromKibibitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KibibytePerSecond
+            BitRate.FromKibibitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromKibibytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate KibibytesPerSecond<T>(this T value) =>
-             BitRate.FromKibibytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilobitPerSecond
+            BitRate.FromKibibytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromKilobitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate KilobitsPerSecond<T>(this T value) =>
-             BitRate.FromKilobitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilobytePerSecond
+            BitRate.FromKilobitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromKilobytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate KilobytesPerSecond<T>(this T value) =>
-             BitRate.FromKilobytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MebibitPerSecond
+            BitRate.FromKilobytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromMebibitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate MebibitsPerSecond<T>(this T value) =>
-             BitRate.FromMebibitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MebibytePerSecond
+            BitRate.FromMebibitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromMebibytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate MebibytesPerSecond<T>(this T value) =>
-             BitRate.FromMebibytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegabitPerSecond
+            BitRate.FromMebibytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromMegabitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate MegabitsPerSecond<T>(this T value) =>
-             BitRate.FromMegabitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegabytePerSecond
+            BitRate.FromMegabitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromMegabytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate MegabytesPerSecond<T>(this T value) =>
-             BitRate.FromMegabytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PebibitPerSecond
+            BitRate.FromMegabytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromPebibitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate PebibitsPerSecond<T>(this T value) =>
-             BitRate.FromPebibitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PebibytePerSecond
+            BitRate.FromPebibitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromPebibytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate PebibytesPerSecond<T>(this T value) =>
-             BitRate.FromPebibytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PetabitPerSecond
+            BitRate.FromPebibytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromPetabitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate PetabitsPerSecond<T>(this T value) =>
-             BitRate.FromPetabitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PetabytePerSecond
+            BitRate.FromPetabitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromPetabytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate PetabytesPerSecond<T>(this T value) =>
-             BitRate.FromPetabytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TebibitPerSecond
+            BitRate.FromPetabytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromTebibitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate TebibitsPerSecond<T>(this T value) =>
-             BitRate.FromTebibitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TebibytePerSecond
+            BitRate.FromTebibitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromTebibytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate TebibytesPerSecond<T>(this T value) =>
-             BitRate.FromTebibytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TerabitPerSecond
+            BitRate.FromTebibytesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromTerabitsPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate TerabitsPerSecond<T>(this T value) =>
-             BitRate.FromTerabitsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TerabytePerSecond
+            BitRate.FromTerabitsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BitRate.FromTerabytesPerSecond(UnitsNet.QuantityValue)" />
         public static BitRate TerabytesPerSecond<T>(this T value) =>
-             BitRate.FromTerabytesPerSecond(Convert.ToDouble(value));
-
-        #endregion
+            BitRate.FromTerabytesPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
similarity index 77%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
index a59ac31744..8c77addb30 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToBrakeSpecificFuelConsumption
+namespace UnitsNet.NumberExtensions.NumberToBrakeSpecificFuelConsumption
 {
     /// <summary>
     /// A number to BrakeSpecificFuelConsumption Extensions
     /// </summary>
     public static class NumberToBrakeSpecificFuelConsumptionExtensions
     {
-
-        #region GramPerKiloWattHour
-
         /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(UnitsNet.QuantityValue)" />
         public static BrakeSpecificFuelConsumption GramsPerKiloWattHour<T>(this T value) =>
-             BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerJoule
+            BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromKilogramsPerJoule(UnitsNet.QuantityValue)" />
         public static BrakeSpecificFuelConsumption KilogramsPerJoule<T>(this T value) =>
-             BrakeSpecificFuelConsumption.FromKilogramsPerJoule(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerMechanicalHorsepowerHour
+            BrakeSpecificFuelConsumption.FromKilogramsPerJoule(Convert.ToDouble(value));
 
         /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(UnitsNet.QuantityValue)" />
         public static BrakeSpecificFuelConsumption PoundsPerMechanicalHorsepowerHour<T>(this T value) =>
-             BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(Convert.ToDouble(value));
-
-        #endregion
+            BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToCapacitanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCapacitanceExtensions.g.cs
similarity index 72%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToCapacitanceExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToCapacitanceExtensions.g.cs
index cac147945e..ca81793938 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToCapacitanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCapacitanceExtensions.g.cs
@@ -19,69 +19,40 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToCapacitance
+namespace UnitsNet.NumberExtensions.NumberToCapacitance
 {
     /// <summary>
     /// A number to Capacitance Extensions
     /// </summary>
     public static class NumberToCapacitanceExtensions
     {
-
-        #region Farad
-
         /// <inheritdoc cref="Capacitance.FromFarads(UnitsNet.QuantityValue)" />
         public static Capacitance Farads<T>(this T value) =>
-             Capacitance.FromFarads(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilofarad
+            Capacitance.FromFarads(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Capacitance.FromKilofarads(UnitsNet.QuantityValue)" />
         public static Capacitance Kilofarads<T>(this T value) =>
-             Capacitance.FromKilofarads(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megafarad
+            Capacitance.FromKilofarads(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Capacitance.FromMegafarads(UnitsNet.QuantityValue)" />
         public static Capacitance Megafarads<T>(this T value) =>
-             Capacitance.FromMegafarads(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microfarad
+            Capacitance.FromMegafarads(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Capacitance.FromMicrofarads(UnitsNet.QuantityValue)" />
         public static Capacitance Microfarads<T>(this T value) =>
-             Capacitance.FromMicrofarads(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millifarad
+            Capacitance.FromMicrofarads(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Capacitance.FromMillifarads(UnitsNet.QuantityValue)" />
         public static Capacitance Millifarads<T>(this T value) =>
-             Capacitance.FromMillifarads(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanofarad
+            Capacitance.FromMillifarads(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Capacitance.FromNanofarads(UnitsNet.QuantityValue)" />
         public static Capacitance Nanofarads<T>(this T value) =>
-             Capacitance.FromNanofarads(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Picofarad
+            Capacitance.FromNanofarads(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Capacitance.FromPicofarads(UnitsNet.QuantityValue)" />
         public static Capacitance Picofarads<T>(this T value) =>
-             Capacitance.FromPicofarads(Convert.ToDouble(value));
-
-        #endregion
+            Capacitance.FromPicofarads(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToCoefficientOfThermalExpansionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
similarity index 77%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToCoefficientOfThermalExpansionExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
index b2584b4818..7de727e078 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToCoefficientOfThermalExpansionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToCoefficientOfThermalExpansion
+namespace UnitsNet.NumberExtensions.NumberToCoefficientOfThermalExpansion
 {
     /// <summary>
     /// A number to CoefficientOfThermalExpansion Extensions
     /// </summary>
     public static class NumberToCoefficientOfThermalExpansionExtensions
     {
-
-        #region InverseDegreeCelsius
-
         /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseDegreeCelsius(UnitsNet.QuantityValue)" />
         public static CoefficientOfThermalExpansion InverseDegreeCelsius<T>(this T value) =>
-             CoefficientOfThermalExpansion.FromInverseDegreeCelsius(Convert.ToDouble(value));
-
-        #endregion
-
-        #region InverseDegreeFahrenheit
+            CoefficientOfThermalExpansion.FromInverseDegreeCelsius(Convert.ToDouble(value));
 
         /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(UnitsNet.QuantityValue)" />
         public static CoefficientOfThermalExpansion InverseDegreeFahrenheit<T>(this T value) =>
-             CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(Convert.ToDouble(value));
-
-        #endregion
-
-        #region InverseKelvin
+            CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(Convert.ToDouble(value));
 
         /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseKelvin(UnitsNet.QuantityValue)" />
         public static CoefficientOfThermalExpansion InverseKelvin<T>(this T value) =>
-             CoefficientOfThermalExpansion.FromInverseKelvin(Convert.ToDouble(value));
-
-        #endregion
+            CoefficientOfThermalExpansion.FromInverseKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
similarity index 60%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDensityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
index 87b27e81ac..01cfb61b01 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
@@ -19,333 +19,172 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToDensity
+namespace UnitsNet.NumberExtensions.NumberToDensity
 {
     /// <summary>
     /// A number to Density Extensions
     /// </summary>
     public static class NumberToDensityExtensions
     {
-
-        #region CentigramPerDeciliter
-
         /// <inheritdoc cref="Density.FromCentigramsPerDeciLiter(UnitsNet.QuantityValue)" />
         public static Density CentigramsPerDeciLiter<T>(this T value) =>
-             Density.FromCentigramsPerDeciLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentigramPerLiter
+            Density.FromCentigramsPerDeciLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromCentigramsPerLiter(UnitsNet.QuantityValue)" />
         public static Density CentigramsPerLiter<T>(this T value) =>
-             Density.FromCentigramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentigramPerMilliliter
+            Density.FromCentigramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromCentigramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static Density CentigramsPerMilliliter<T>(this T value) =>
-             Density.FromCentigramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecigramPerDeciliter
+            Density.FromCentigramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromDecigramsPerDeciLiter(UnitsNet.QuantityValue)" />
         public static Density DecigramsPerDeciLiter<T>(this T value) =>
-             Density.FromDecigramsPerDeciLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecigramPerLiter
+            Density.FromDecigramsPerDeciLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromDecigramsPerLiter(UnitsNet.QuantityValue)" />
         public static Density DecigramsPerLiter<T>(this T value) =>
-             Density.FromDecigramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecigramPerMilliliter
+            Density.FromDecigramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromDecigramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static Density DecigramsPerMilliliter<T>(this T value) =>
-             Density.FromDecigramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerCubicCentimeter
+            Density.FromDecigramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromGramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
         public static Density GramsPerCubicCentimeter<T>(this T value) =>
-             Density.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerCubicMeter
+            Density.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromGramsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static Density GramsPerCubicMeter<T>(this T value) =>
-             Density.FromGramsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerCubicMillimeter
+            Density.FromGramsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromGramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
         public static Density GramsPerCubicMillimeter<T>(this T value) =>
-             Density.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerDeciliter
+            Density.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromGramsPerDeciLiter(UnitsNet.QuantityValue)" />
         public static Density GramsPerDeciLiter<T>(this T value) =>
-             Density.FromGramsPerDeciLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerLiter
+            Density.FromGramsPerDeciLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromGramsPerLiter(UnitsNet.QuantityValue)" />
         public static Density GramsPerLiter<T>(this T value) =>
-             Density.FromGramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerMilliliter
+            Density.FromGramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromGramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static Density GramsPerMilliliter<T>(this T value) =>
-             Density.FromGramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerCubicCentimeter
+            Density.FromGramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromKilogramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
         public static Density KilogramsPerCubicCentimeter<T>(this T value) =>
-             Density.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerCubicMeter
+            Density.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromKilogramsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static Density KilogramsPerCubicMeter<T>(this T value) =>
-             Density.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerCubicMillimeter
+            Density.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromKilogramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
         public static Density KilogramsPerCubicMillimeter<T>(this T value) =>
-             Density.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerLiter
+            Density.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromKilogramsPerLiter(UnitsNet.QuantityValue)" />
         public static Density KilogramsPerLiter<T>(this T value) =>
-             Density.FromKilogramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundPerCubicFoot
+            Density.FromKilogramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromKilopoundsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static Density KilopoundsPerCubicFoot<T>(this T value) =>
-             Density.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundPerCubicInch
+            Density.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromKilopoundsPerCubicInch(UnitsNet.QuantityValue)" />
         public static Density KilopoundsPerCubicInch<T>(this T value) =>
-             Density.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerCubicMeter
+            Density.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromMicrogramsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static Density MicrogramsPerCubicMeter<T>(this T value) =>
-             Density.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerDeciliter
+            Density.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromMicrogramsPerDeciLiter(UnitsNet.QuantityValue)" />
         public static Density MicrogramsPerDeciLiter<T>(this T value) =>
-             Density.FromMicrogramsPerDeciLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerLiter
+            Density.FromMicrogramsPerDeciLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromMicrogramsPerLiter(UnitsNet.QuantityValue)" />
         public static Density MicrogramsPerLiter<T>(this T value) =>
-             Density.FromMicrogramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerMilliliter
+            Density.FromMicrogramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromMicrogramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static Density MicrogramsPerMilliliter<T>(this T value) =>
-             Density.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerCubicMeter
+            Density.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromMilligramsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static Density MilligramsPerCubicMeter<T>(this T value) =>
-             Density.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerDeciliter
+            Density.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromMilligramsPerDeciLiter(UnitsNet.QuantityValue)" />
         public static Density MilligramsPerDeciLiter<T>(this T value) =>
-             Density.FromMilligramsPerDeciLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerLiter
+            Density.FromMilligramsPerDeciLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromMilligramsPerLiter(UnitsNet.QuantityValue)" />
         public static Density MilligramsPerLiter<T>(this T value) =>
-             Density.FromMilligramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerMilliliter
+            Density.FromMilligramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromMilligramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static Density MilligramsPerMilliliter<T>(this T value) =>
-             Density.FromMilligramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanogramPerDeciliter
+            Density.FromMilligramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromNanogramsPerDeciLiter(UnitsNet.QuantityValue)" />
         public static Density NanogramsPerDeciLiter<T>(this T value) =>
-             Density.FromNanogramsPerDeciLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanogramPerLiter
+            Density.FromNanogramsPerDeciLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromNanogramsPerLiter(UnitsNet.QuantityValue)" />
         public static Density NanogramsPerLiter<T>(this T value) =>
-             Density.FromNanogramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanogramPerMilliliter
+            Density.FromNanogramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromNanogramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static Density NanogramsPerMilliliter<T>(this T value) =>
-             Density.FromNanogramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicogramPerDeciliter
+            Density.FromNanogramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromPicogramsPerDeciLiter(UnitsNet.QuantityValue)" />
         public static Density PicogramsPerDeciLiter<T>(this T value) =>
-             Density.FromPicogramsPerDeciLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicogramPerLiter
+            Density.FromPicogramsPerDeciLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromPicogramsPerLiter(UnitsNet.QuantityValue)" />
         public static Density PicogramsPerLiter<T>(this T value) =>
-             Density.FromPicogramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicogramPerMilliliter
+            Density.FromPicogramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromPicogramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static Density PicogramsPerMilliliter<T>(this T value) =>
-             Density.FromPicogramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerCubicFoot
+            Density.FromPicogramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromPoundsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static Density PoundsPerCubicFoot<T>(this T value) =>
-             Density.FromPoundsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerCubicInch
+            Density.FromPoundsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromPoundsPerCubicInch(UnitsNet.QuantityValue)" />
         public static Density PoundsPerCubicInch<T>(this T value) =>
-             Density.FromPoundsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerImperialGallon
+            Density.FromPoundsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromPoundsPerImperialGallon(UnitsNet.QuantityValue)" />
         public static Density PoundsPerImperialGallon<T>(this T value) =>
-             Density.FromPoundsPerImperialGallon(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerUSGallon
+            Density.FromPoundsPerImperialGallon(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromPoundsPerUSGallon(UnitsNet.QuantityValue)" />
         public static Density PoundsPerUSGallon<T>(this T value) =>
-             Density.FromPoundsPerUSGallon(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SlugPerCubicFoot
+            Density.FromPoundsPerUSGallon(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromSlugsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static Density SlugsPerCubicFoot<T>(this T value) =>
-             Density.FromSlugsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonnePerCubicCentimeter
+            Density.FromSlugsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromTonnesPerCubicCentimeter(UnitsNet.QuantityValue)" />
         public static Density TonnesPerCubicCentimeter<T>(this T value) =>
-             Density.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonnePerCubicMeter
+            Density.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromTonnesPerCubicMeter(UnitsNet.QuantityValue)" />
         public static Density TonnesPerCubicMeter<T>(this T value) =>
-             Density.FromTonnesPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonnePerCubicMillimeter
+            Density.FromTonnesPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Density.FromTonnesPerCubicMillimeter(UnitsNet.QuantityValue)" />
         public static Density TonnesPerCubicMillimeter<T>(this T value) =>
-             Density.FromTonnesPerCubicMillimeter(Convert.ToDouble(value));
-
-        #endregion
+            Density.FromTonnesPerCubicMillimeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDurationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
similarity index 69%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDurationExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
index 65811813b1..103c949cc9 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDurationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
@@ -19,93 +19,52 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToDuration
+namespace UnitsNet.NumberExtensions.NumberToDuration
 {
     /// <summary>
     /// A number to Duration Extensions
     /// </summary>
     public static class NumberToDurationExtensions
     {
-
-        #region Day
-
         /// <inheritdoc cref="Duration.FromDays(UnitsNet.QuantityValue)" />
         public static Duration Days<T>(this T value) =>
-             Duration.FromDays(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Hour
+            Duration.FromDays(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Duration.FromHours(UnitsNet.QuantityValue)" />
         public static Duration Hours<T>(this T value) =>
-             Duration.FromHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microsecond
+            Duration.FromHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Duration.FromMicroseconds(UnitsNet.QuantityValue)" />
         public static Duration Microseconds<T>(this T value) =>
-             Duration.FromMicroseconds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millisecond
+            Duration.FromMicroseconds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Duration.FromMilliseconds(UnitsNet.QuantityValue)" />
         public static Duration Milliseconds<T>(this T value) =>
-             Duration.FromMilliseconds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Minute
+            Duration.FromMilliseconds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Duration.FromMinutes(UnitsNet.QuantityValue)" />
         public static Duration Minutes<T>(this T value) =>
-             Duration.FromMinutes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Month30
+            Duration.FromMinutes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Duration.FromMonths30(UnitsNet.QuantityValue)" />
         public static Duration Months30<T>(this T value) =>
-             Duration.FromMonths30(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanosecond
+            Duration.FromMonths30(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Duration.FromNanoseconds(UnitsNet.QuantityValue)" />
         public static Duration Nanoseconds<T>(this T value) =>
-             Duration.FromNanoseconds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Second
+            Duration.FromNanoseconds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Duration.FromSeconds(UnitsNet.QuantityValue)" />
         public static Duration Seconds<T>(this T value) =>
-             Duration.FromSeconds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Week
+            Duration.FromSeconds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Duration.FromWeeks(UnitsNet.QuantityValue)" />
         public static Duration Weeks<T>(this T value) =>
-             Duration.FromWeeks(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Year365
+            Duration.FromWeeks(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Duration.FromYears365(UnitsNet.QuantityValue)" />
         public static Duration Years365<T>(this T value) =>
-             Duration.FromYears365(Convert.ToDouble(value));
-
-        #endregion
+            Duration.FromYears365(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDynamicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
similarity index 68%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDynamicViscosityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
index a2ffe6931c..ceab9bfd1a 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToDynamicViscosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
@@ -19,85 +19,48 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToDynamicViscosity
+namespace UnitsNet.NumberExtensions.NumberToDynamicViscosity
 {
     /// <summary>
     /// A number to DynamicViscosity Extensions
     /// </summary>
     public static class NumberToDynamicViscosityExtensions
     {
-
-        #region Centipoise
-
         /// <inheritdoc cref="DynamicViscosity.FromCentipoise(UnitsNet.QuantityValue)" />
         public static DynamicViscosity Centipoise<T>(this T value) =>
-             DynamicViscosity.FromCentipoise(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicropascalSecond
+            DynamicViscosity.FromCentipoise(Convert.ToDouble(value));
 
         /// <inheritdoc cref="DynamicViscosity.FromMicropascalSeconds(UnitsNet.QuantityValue)" />
         public static DynamicViscosity MicropascalSeconds<T>(this T value) =>
-             DynamicViscosity.FromMicropascalSeconds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillipascalSecond
+            DynamicViscosity.FromMicropascalSeconds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="DynamicViscosity.FromMillipascalSeconds(UnitsNet.QuantityValue)" />
         public static DynamicViscosity MillipascalSeconds<T>(this T value) =>
-             DynamicViscosity.FromMillipascalSeconds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonSecondPerMeterSquared
+            DynamicViscosity.FromMillipascalSeconds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="DynamicViscosity.FromNewtonSecondsPerMeterSquared(UnitsNet.QuantityValue)" />
         public static DynamicViscosity NewtonSecondsPerMeterSquared<T>(this T value) =>
-             DynamicViscosity.FromNewtonSecondsPerMeterSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PascalSecond
+            DynamicViscosity.FromNewtonSecondsPerMeterSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="DynamicViscosity.FromPascalSeconds(UnitsNet.QuantityValue)" />
         public static DynamicViscosity PascalSeconds<T>(this T value) =>
-             DynamicViscosity.FromPascalSeconds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Poise
+            DynamicViscosity.FromPascalSeconds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="DynamicViscosity.FromPoise(UnitsNet.QuantityValue)" />
         public static DynamicViscosity Poise<T>(this T value) =>
-             DynamicViscosity.FromPoise(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForceSecondPerSquareFoot
+            DynamicViscosity.FromPoise(Convert.ToDouble(value));
 
         /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareFoot(UnitsNet.QuantityValue)" />
         public static DynamicViscosity PoundsForceSecondPerSquareFoot<T>(this T value) =>
-             DynamicViscosity.FromPoundsForceSecondPerSquareFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForceSecondPerSquareInch
+            DynamicViscosity.FromPoundsForceSecondPerSquareFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareInch(UnitsNet.QuantityValue)" />
         public static DynamicViscosity PoundsForceSecondPerSquareInch<T>(this T value) =>
-             DynamicViscosity.FromPoundsForceSecondPerSquareInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Reyn
+            DynamicViscosity.FromPoundsForceSecondPerSquareInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="DynamicViscosity.FromReyns(UnitsNet.QuantityValue)" />
         public static DynamicViscosity Reyns<T>(this T value) =>
-             DynamicViscosity.FromReyns(Convert.ToDouble(value));
-
-        #endregion
+            DynamicViscosity.FromReyns(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricAdmittanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
similarity index 77%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricAdmittanceExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
index 0c3a503050..327f48b951 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricAdmittanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
@@ -19,45 +19,28 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricAdmittance
+namespace UnitsNet.NumberExtensions.NumberToElectricAdmittance
 {
     /// <summary>
     /// A number to ElectricAdmittance Extensions
     /// </summary>
     public static class NumberToElectricAdmittanceExtensions
     {
-
-        #region Microsiemens
-
         /// <inheritdoc cref="ElectricAdmittance.FromMicrosiemens(UnitsNet.QuantityValue)" />
         public static ElectricAdmittance Microsiemens<T>(this T value) =>
-             ElectricAdmittance.FromMicrosiemens(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millisiemens
+            ElectricAdmittance.FromMicrosiemens(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricAdmittance.FromMillisiemens(UnitsNet.QuantityValue)" />
         public static ElectricAdmittance Millisiemens<T>(this T value) =>
-             ElectricAdmittance.FromMillisiemens(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanosiemens
+            ElectricAdmittance.FromMillisiemens(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricAdmittance.FromNanosiemens(UnitsNet.QuantityValue)" />
         public static ElectricAdmittance Nanosiemens<T>(this T value) =>
-             ElectricAdmittance.FromNanosiemens(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Siemens
+            ElectricAdmittance.FromNanosiemens(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricAdmittance.FromSiemens(UnitsNet.QuantityValue)" />
         public static ElectricAdmittance Siemens<T>(this T value) =>
-             ElectricAdmittance.FromSiemens(Convert.ToDouble(value));
-
-        #endregion
+            ElectricAdmittance.FromSiemens(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
similarity index 87%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricChargeDensityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
index 512041dcd8..087dab29b3 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricChargeDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricChargeDensity
+namespace UnitsNet.NumberExtensions.NumberToElectricChargeDensity
 {
     /// <summary>
     /// A number to ElectricChargeDensity Extensions
     /// </summary>
     public static class NumberToElectricChargeDensityExtensions
     {
-
-        #region CoulombPerCubicMeter
-
         /// <inheritdoc cref="ElectricChargeDensity.FromCoulombsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static ElectricChargeDensity CoulombsPerCubicMeter<T>(this T value) =>
-             ElectricChargeDensity.FromCoulombsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
+            ElectricChargeDensity.FromCoulombsPerCubicMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricChargeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
similarity index 75%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricChargeExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
index aad5c763b9..030627f6bb 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricChargeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
@@ -19,53 +19,32 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricCharge
+namespace UnitsNet.NumberExtensions.NumberToElectricCharge
 {
     /// <summary>
     /// A number to ElectricCharge Extensions
     /// </summary>
     public static class NumberToElectricChargeExtensions
     {
-
-        #region AmpereHour
-
         /// <inheritdoc cref="ElectricCharge.FromAmpereHours(UnitsNet.QuantityValue)" />
         public static ElectricCharge AmpereHours<T>(this T value) =>
-             ElectricCharge.FromAmpereHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Coulomb
+            ElectricCharge.FromAmpereHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCharge.FromCoulombs(UnitsNet.QuantityValue)" />
         public static ElectricCharge Coulombs<T>(this T value) =>
-             ElectricCharge.FromCoulombs(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KiloampereHour
+            ElectricCharge.FromCoulombs(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCharge.FromKiloampereHours(UnitsNet.QuantityValue)" />
         public static ElectricCharge KiloampereHours<T>(this T value) =>
-             ElectricCharge.FromKiloampereHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegaampereHour
+            ElectricCharge.FromKiloampereHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCharge.FromMegaampereHours(UnitsNet.QuantityValue)" />
         public static ElectricCharge MegaampereHours<T>(this T value) =>
-             ElectricCharge.FromMegaampereHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliampereHour
+            ElectricCharge.FromMegaampereHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCharge.FromMilliampereHours(UnitsNet.QuantityValue)" />
         public static ElectricCharge MilliampereHours<T>(this T value) =>
-             ElectricCharge.FromMilliampereHours(Convert.ToDouble(value));
-
-        #endregion
+            ElectricCharge.FromMilliampereHours(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricConductanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
similarity index 79%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricConductanceExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
index 4f8e7f551b..e918ca45e5 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricConductanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricConductance
+namespace UnitsNet.NumberExtensions.NumberToElectricConductance
 {
     /// <summary>
     /// A number to ElectricConductance Extensions
     /// </summary>
     public static class NumberToElectricConductanceExtensions
     {
-
-        #region Microsiemens
-
         /// <inheritdoc cref="ElectricConductance.FromMicrosiemens(UnitsNet.QuantityValue)" />
         public static ElectricConductance Microsiemens<T>(this T value) =>
-             ElectricConductance.FromMicrosiemens(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millisiemens
+            ElectricConductance.FromMicrosiemens(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricConductance.FromMillisiemens(UnitsNet.QuantityValue)" />
         public static ElectricConductance Millisiemens<T>(this T value) =>
-             ElectricConductance.FromMillisiemens(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Siemens
+            ElectricConductance.FromMillisiemens(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricConductance.FromSiemens(UnitsNet.QuantityValue)" />
         public static ElectricConductance Siemens<T>(this T value) =>
-             ElectricConductance.FromSiemens(Convert.ToDouble(value));
-
-        #endregion
+            ElectricConductance.FromSiemens(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricConductivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
similarity index 79%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricConductivityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
index 2b8d087938..4657b9293d 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricConductivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricConductivity
+namespace UnitsNet.NumberExtensions.NumberToElectricConductivity
 {
     /// <summary>
     /// A number to ElectricConductivity Extensions
     /// </summary>
     public static class NumberToElectricConductivityExtensions
     {
-
-        #region SiemensPerFoot
-
         /// <inheritdoc cref="ElectricConductivity.FromSiemensPerFoot(UnitsNet.QuantityValue)" />
         public static ElectricConductivity SiemensPerFoot<T>(this T value) =>
-             ElectricConductivity.FromSiemensPerFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SiemensPerInch
+            ElectricConductivity.FromSiemensPerFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricConductivity.FromSiemensPerInch(UnitsNet.QuantityValue)" />
         public static ElectricConductivity SiemensPerInch<T>(this T value) =>
-             ElectricConductivity.FromSiemensPerInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SiemensPerMeter
+            ElectricConductivity.FromSiemensPerInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricConductivity.FromSiemensPerMeter(UnitsNet.QuantityValue)" />
         public static ElectricConductivity SiemensPerMeter<T>(this T value) =>
-             ElectricConductivity.FromSiemensPerMeter(Convert.ToDouble(value));
-
-        #endregion
+            ElectricConductivity.FromSiemensPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
similarity index 79%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentDensityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
index 2ffd2d2a44..90ffccfd5c 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricCurrentDensity
+namespace UnitsNet.NumberExtensions.NumberToElectricCurrentDensity
 {
     /// <summary>
     /// A number to ElectricCurrentDensity Extensions
     /// </summary>
     public static class NumberToElectricCurrentDensityExtensions
     {
-
-        #region AmperePerSquareFoot
-
         /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareFoot(UnitsNet.QuantityValue)" />
         public static ElectricCurrentDensity AmperesPerSquareFoot<T>(this T value) =>
-             ElectricCurrentDensity.FromAmperesPerSquareFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region AmperePerSquareInch
+            ElectricCurrentDensity.FromAmperesPerSquareFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareInch(UnitsNet.QuantityValue)" />
         public static ElectricCurrentDensity AmperesPerSquareInch<T>(this T value) =>
-             ElectricCurrentDensity.FromAmperesPerSquareInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region AmperePerSquareMeter
+            ElectricCurrentDensity.FromAmperesPerSquareInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareMeter(UnitsNet.QuantityValue)" />
         public static ElectricCurrentDensity AmperesPerSquareMeter<T>(this T value) =>
-             ElectricCurrentDensity.FromAmperesPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
+            ElectricCurrentDensity.FromAmperesPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
similarity index 71%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
index 4675b5c4a8..454205755f 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
@@ -19,77 +19,44 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricCurrent
+namespace UnitsNet.NumberExtensions.NumberToElectricCurrent
 {
     /// <summary>
     /// A number to ElectricCurrent Extensions
     /// </summary>
     public static class NumberToElectricCurrentExtensions
     {
-
-        #region Ampere
-
         /// <inheritdoc cref="ElectricCurrent.FromAmperes(UnitsNet.QuantityValue)" />
         public static ElectricCurrent Amperes<T>(this T value) =>
-             ElectricCurrent.FromAmperes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Centiampere
+            ElectricCurrent.FromAmperes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCurrent.FromCentiamperes(UnitsNet.QuantityValue)" />
         public static ElectricCurrent Centiamperes<T>(this T value) =>
-             ElectricCurrent.FromCentiamperes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kiloampere
+            ElectricCurrent.FromCentiamperes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCurrent.FromKiloamperes(UnitsNet.QuantityValue)" />
         public static ElectricCurrent Kiloamperes<T>(this T value) =>
-             ElectricCurrent.FromKiloamperes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megaampere
+            ElectricCurrent.FromKiloamperes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCurrent.FromMegaamperes(UnitsNet.QuantityValue)" />
         public static ElectricCurrent Megaamperes<T>(this T value) =>
-             ElectricCurrent.FromMegaamperes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microampere
+            ElectricCurrent.FromMegaamperes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCurrent.FromMicroamperes(UnitsNet.QuantityValue)" />
         public static ElectricCurrent Microamperes<T>(this T value) =>
-             ElectricCurrent.FromMicroamperes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Milliampere
+            ElectricCurrent.FromMicroamperes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCurrent.FromMilliamperes(UnitsNet.QuantityValue)" />
         public static ElectricCurrent Milliamperes<T>(this T value) =>
-             ElectricCurrent.FromMilliamperes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanoampere
+            ElectricCurrent.FromMilliamperes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCurrent.FromNanoamperes(UnitsNet.QuantityValue)" />
         public static ElectricCurrent Nanoamperes<T>(this T value) =>
-             ElectricCurrent.FromNanoamperes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Picoampere
+            ElectricCurrent.FromNanoamperes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricCurrent.FromPicoamperes(UnitsNet.QuantityValue)" />
         public static ElectricCurrent Picoamperes<T>(this T value) =>
-             ElectricCurrent.FromPicoamperes(Convert.ToDouble(value));
-
-        #endregion
+            ElectricCurrent.FromPicoamperes(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentGradientExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
similarity index 87%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentGradientExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
index 5084cab8e9..4dda499911 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricCurrentGradientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricCurrentGradient
+namespace UnitsNet.NumberExtensions.NumberToElectricCurrentGradient
 {
     /// <summary>
     /// A number to ElectricCurrentGradient Extensions
     /// </summary>
     public static class NumberToElectricCurrentGradientExtensions
     {
-
-        #region AmperePerSecond
-
         /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerSecond(UnitsNet.QuantityValue)" />
         public static ElectricCurrentGradient AmperesPerSecond<T>(this T value) =>
-             ElectricCurrentGradient.FromAmperesPerSecond(Convert.ToDouble(value));
-
-        #endregion
+            ElectricCurrentGradient.FromAmperesPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricFieldExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
similarity index 88%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricFieldExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
index eab7e90467..18f1886c1f 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricFieldExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricField
+namespace UnitsNet.NumberExtensions.NumberToElectricField
 {
     /// <summary>
     /// A number to ElectricField Extensions
     /// </summary>
     public static class NumberToElectricFieldExtensions
     {
-
-        #region VoltPerMeter
-
         /// <inheritdoc cref="ElectricField.FromVoltsPerMeter(UnitsNet.QuantityValue)" />
         public static ElectricField VoltsPerMeter<T>(this T value) =>
-             ElectricField.FromVoltsPerMeter(Convert.ToDouble(value));
-
-        #endregion
+            ElectricField.FromVoltsPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricInductanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
similarity index 77%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricInductanceExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
index bea7cb7575..3355ab03df 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricInductanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
@@ -19,45 +19,28 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricInductance
+namespace UnitsNet.NumberExtensions.NumberToElectricInductance
 {
     /// <summary>
     /// A number to ElectricInductance Extensions
     /// </summary>
     public static class NumberToElectricInductanceExtensions
     {
-
-        #region Henry
-
         /// <inheritdoc cref="ElectricInductance.FromHenries(UnitsNet.QuantityValue)" />
         public static ElectricInductance Henries<T>(this T value) =>
-             ElectricInductance.FromHenries(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microhenry
+            ElectricInductance.FromHenries(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricInductance.FromMicrohenries(UnitsNet.QuantityValue)" />
         public static ElectricInductance Microhenries<T>(this T value) =>
-             ElectricInductance.FromMicrohenries(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millihenry
+            ElectricInductance.FromMicrohenries(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricInductance.FromMillihenries(UnitsNet.QuantityValue)" />
         public static ElectricInductance Millihenries<T>(this T value) =>
-             ElectricInductance.FromMillihenries(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanohenry
+            ElectricInductance.FromMillihenries(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricInductance.FromNanohenries(UnitsNet.QuantityValue)" />
         public static ElectricInductance Nanohenries<T>(this T value) =>
-             ElectricInductance.FromNanohenries(Convert.ToDouble(value));
-
-        #endregion
+            ElectricInductance.FromNanohenries(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialAcExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialAcExtensions.g.cs
similarity index 75%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialAcExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialAcExtensions.g.cs
index ac7055f9c8..c607255528 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialAcExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialAcExtensions.g.cs
@@ -19,53 +19,32 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricPotentialAc
+namespace UnitsNet.NumberExtensions.NumberToElectricPotentialAc
 {
     /// <summary>
     /// A number to ElectricPotentialAc Extensions
     /// </summary>
     public static class NumberToElectricPotentialAcExtensions
     {
-
-        #region KilovoltAc
-
         /// <inheritdoc cref="ElectricPotentialAc.FromKilovoltsAc(UnitsNet.QuantityValue)" />
         public static ElectricPotentialAc KilovoltsAc<T>(this T value) =>
-             ElectricPotentialAc.FromKilovoltsAc(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegavoltAc
+            ElectricPotentialAc.FromKilovoltsAc(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotentialAc.FromMegavoltsAc(UnitsNet.QuantityValue)" />
         public static ElectricPotentialAc MegavoltsAc<T>(this T value) =>
-             ElectricPotentialAc.FromMegavoltsAc(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrovoltAc
+            ElectricPotentialAc.FromMegavoltsAc(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotentialAc.FromMicrovoltsAc(UnitsNet.QuantityValue)" />
         public static ElectricPotentialAc MicrovoltsAc<T>(this T value) =>
-             ElectricPotentialAc.FromMicrovoltsAc(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillivoltAc
+            ElectricPotentialAc.FromMicrovoltsAc(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotentialAc.FromMillivoltsAc(UnitsNet.QuantityValue)" />
         public static ElectricPotentialAc MillivoltsAc<T>(this T value) =>
-             ElectricPotentialAc.FromMillivoltsAc(Convert.ToDouble(value));
-
-        #endregion
-
-        #region VoltAc
+            ElectricPotentialAc.FromMillivoltsAc(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotentialAc.FromVoltsAc(UnitsNet.QuantityValue)" />
         public static ElectricPotentialAc VoltsAc<T>(this T value) =>
-             ElectricPotentialAc.FromVoltsAc(Convert.ToDouble(value));
-
-        #endregion
+            ElectricPotentialAc.FromVoltsAc(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialDcExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialDcExtensions.g.cs
similarity index 75%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialDcExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialDcExtensions.g.cs
index f8264354bd..3fcc9a9d12 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialDcExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialDcExtensions.g.cs
@@ -19,53 +19,32 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricPotentialDc
+namespace UnitsNet.NumberExtensions.NumberToElectricPotentialDc
 {
     /// <summary>
     /// A number to ElectricPotentialDc Extensions
     /// </summary>
     public static class NumberToElectricPotentialDcExtensions
     {
-
-        #region KilovoltDc
-
         /// <inheritdoc cref="ElectricPotentialDc.FromKilovoltsDc(UnitsNet.QuantityValue)" />
         public static ElectricPotentialDc KilovoltsDc<T>(this T value) =>
-             ElectricPotentialDc.FromKilovoltsDc(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegavoltDc
+            ElectricPotentialDc.FromKilovoltsDc(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotentialDc.FromMegavoltsDc(UnitsNet.QuantityValue)" />
         public static ElectricPotentialDc MegavoltsDc<T>(this T value) =>
-             ElectricPotentialDc.FromMegavoltsDc(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrovoltDc
+            ElectricPotentialDc.FromMegavoltsDc(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotentialDc.FromMicrovoltsDc(UnitsNet.QuantityValue)" />
         public static ElectricPotentialDc MicrovoltsDc<T>(this T value) =>
-             ElectricPotentialDc.FromMicrovoltsDc(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillivoltDc
+            ElectricPotentialDc.FromMicrovoltsDc(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotentialDc.FromMillivoltsDc(UnitsNet.QuantityValue)" />
         public static ElectricPotentialDc MillivoltsDc<T>(this T value) =>
-             ElectricPotentialDc.FromMillivoltsDc(Convert.ToDouble(value));
-
-        #endregion
-
-        #region VoltDc
+            ElectricPotentialDc.FromMillivoltsDc(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotentialDc.FromVoltsDc(UnitsNet.QuantityValue)" />
         public static ElectricPotentialDc VoltsDc<T>(this T value) =>
-             ElectricPotentialDc.FromVoltsDc(Convert.ToDouble(value));
-
-        #endregion
+            ElectricPotentialDc.FromVoltsDc(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
similarity index 76%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
index f4de2b9fe5..09106632e8 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricPotentialExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
@@ -19,53 +19,32 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricPotential
+namespace UnitsNet.NumberExtensions.NumberToElectricPotential
 {
     /// <summary>
     /// A number to ElectricPotential Extensions
     /// </summary>
     public static class NumberToElectricPotentialExtensions
     {
-
-        #region Kilovolt
-
         /// <inheritdoc cref="ElectricPotential.FromKilovolts(UnitsNet.QuantityValue)" />
         public static ElectricPotential Kilovolts<T>(this T value) =>
-             ElectricPotential.FromKilovolts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megavolt
+            ElectricPotential.FromKilovolts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotential.FromMegavolts(UnitsNet.QuantityValue)" />
         public static ElectricPotential Megavolts<T>(this T value) =>
-             ElectricPotential.FromMegavolts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microvolt
+            ElectricPotential.FromMegavolts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotential.FromMicrovolts(UnitsNet.QuantityValue)" />
         public static ElectricPotential Microvolts<T>(this T value) =>
-             ElectricPotential.FromMicrovolts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millivolt
+            ElectricPotential.FromMicrovolts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotential.FromMillivolts(UnitsNet.QuantityValue)" />
         public static ElectricPotential Millivolts<T>(this T value) =>
-             ElectricPotential.FromMillivolts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Volt
+            ElectricPotential.FromMillivolts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricPotential.FromVolts(UnitsNet.QuantityValue)" />
         public static ElectricPotential Volts<T>(this T value) =>
-             ElectricPotential.FromVolts(Convert.ToDouble(value));
-
-        #endregion
+            ElectricPotential.FromVolts(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricResistanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
similarity index 76%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricResistanceExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
index d984b628a5..0e480816d1 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
@@ -19,53 +19,32 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricResistance
+namespace UnitsNet.NumberExtensions.NumberToElectricResistance
 {
     /// <summary>
     /// A number to ElectricResistance Extensions
     /// </summary>
     public static class NumberToElectricResistanceExtensions
     {
-
-        #region Gigaohm
-
         /// <inheritdoc cref="ElectricResistance.FromGigaohms(UnitsNet.QuantityValue)" />
         public static ElectricResistance Gigaohms<T>(this T value) =>
-             ElectricResistance.FromGigaohms(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kiloohm
+            ElectricResistance.FromGigaohms(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistance.FromKiloohms(UnitsNet.QuantityValue)" />
         public static ElectricResistance Kiloohms<T>(this T value) =>
-             ElectricResistance.FromKiloohms(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megaohm
+            ElectricResistance.FromKiloohms(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistance.FromMegaohms(UnitsNet.QuantityValue)" />
         public static ElectricResistance Megaohms<T>(this T value) =>
-             ElectricResistance.FromMegaohms(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Milliohm
+            ElectricResistance.FromMegaohms(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistance.FromMilliohms(UnitsNet.QuantityValue)" />
         public static ElectricResistance Milliohms<T>(this T value) =>
-             ElectricResistance.FromMilliohms(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Ohm
+            ElectricResistance.FromMilliohms(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistance.FromOhms(UnitsNet.QuantityValue)" />
         public static ElectricResistance Ohms<T>(this T value) =>
-             ElectricResistance.FromOhms(Convert.ToDouble(value));
-
-        #endregion
+            ElectricResistance.FromOhms(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricResistivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
similarity index 67%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricResistivityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
index 2621f0981e..65420c4ae6 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricResistivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
@@ -19,125 +19,68 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricResistivity
+namespace UnitsNet.NumberExtensions.NumberToElectricResistivity
 {
     /// <summary>
     /// A number to ElectricResistivity Extensions
     /// </summary>
     public static class NumberToElectricResistivityExtensions
     {
-
-        #region KiloohmCentimeter
-
         /// <inheritdoc cref="ElectricResistivity.FromKiloohmsCentimeter(UnitsNet.QuantityValue)" />
         public static ElectricResistivity KiloohmsCentimeter<T>(this T value) =>
-             ElectricResistivity.FromKiloohmsCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KiloohmMeter
+            ElectricResistivity.FromKiloohmsCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromKiloohmMeters(UnitsNet.QuantityValue)" />
         public static ElectricResistivity KiloohmMeters<T>(this T value) =>
-             ElectricResistivity.FromKiloohmMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegaohmCentimeter
+            ElectricResistivity.FromKiloohmMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromMegaohmsCentimeter(UnitsNet.QuantityValue)" />
         public static ElectricResistivity MegaohmsCentimeter<T>(this T value) =>
-             ElectricResistivity.FromMegaohmsCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegaohmMeter
+            ElectricResistivity.FromMegaohmsCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromMegaohmMeters(UnitsNet.QuantityValue)" />
         public static ElectricResistivity MegaohmMeters<T>(this T value) =>
-             ElectricResistivity.FromMegaohmMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicroohmCentimeter
+            ElectricResistivity.FromMegaohmMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromMicroohmsCentimeter(UnitsNet.QuantityValue)" />
         public static ElectricResistivity MicroohmsCentimeter<T>(this T value) =>
-             ElectricResistivity.FromMicroohmsCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicroohmMeter
+            ElectricResistivity.FromMicroohmsCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromMicroohmMeters(UnitsNet.QuantityValue)" />
         public static ElectricResistivity MicroohmMeters<T>(this T value) =>
-             ElectricResistivity.FromMicroohmMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliohmCentimeter
+            ElectricResistivity.FromMicroohmMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromMilliohmsCentimeter(UnitsNet.QuantityValue)" />
         public static ElectricResistivity MilliohmsCentimeter<T>(this T value) =>
-             ElectricResistivity.FromMilliohmsCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliohmMeter
+            ElectricResistivity.FromMilliohmsCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromMilliohmMeters(UnitsNet.QuantityValue)" />
         public static ElectricResistivity MilliohmMeters<T>(this T value) =>
-             ElectricResistivity.FromMilliohmMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanoohmCentimeter
+            ElectricResistivity.FromMilliohmMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromNanoohmsCentimeter(UnitsNet.QuantityValue)" />
         public static ElectricResistivity NanoohmsCentimeter<T>(this T value) =>
-             ElectricResistivity.FromNanoohmsCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanoohmMeter
+            ElectricResistivity.FromNanoohmsCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromNanoohmMeters(UnitsNet.QuantityValue)" />
         public static ElectricResistivity NanoohmMeters<T>(this T value) =>
-             ElectricResistivity.FromNanoohmMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region OhmCentimeter
+            ElectricResistivity.FromNanoohmMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromOhmsCentimeter(UnitsNet.QuantityValue)" />
         public static ElectricResistivity OhmsCentimeter<T>(this T value) =>
-             ElectricResistivity.FromOhmsCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region OhmMeter
+            ElectricResistivity.FromOhmsCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromOhmMeters(UnitsNet.QuantityValue)" />
         public static ElectricResistivity OhmMeters<T>(this T value) =>
-             ElectricResistivity.FromOhmMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicoohmCentimeter
+            ElectricResistivity.FromOhmMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromPicoohmsCentimeter(UnitsNet.QuantityValue)" />
         public static ElectricResistivity PicoohmsCentimeter<T>(this T value) =>
-             ElectricResistivity.FromPicoohmsCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicoohmMeter
+            ElectricResistivity.FromPicoohmsCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricResistivity.FromPicoohmMeters(UnitsNet.QuantityValue)" />
         public static ElectricResistivity PicoohmMeters<T>(this T value) =>
-             ElectricResistivity.FromPicoohmMeters(Convert.ToDouble(value));
-
-        #endregion
+            ElectricResistivity.FromPicoohmMeters(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricSurfaceChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
similarity index 77%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricSurfaceChargeDensityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
index fbfd812c3c..8f4fce9e09 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToElectricSurfaceChargeDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToElectricSurfaceChargeDensity
+namespace UnitsNet.NumberExtensions.NumberToElectricSurfaceChargeDensity
 {
     /// <summary>
     /// A number to ElectricSurfaceChargeDensity Extensions
     /// </summary>
     public static class NumberToElectricSurfaceChargeDensityExtensions
     {
-
-        #region CoulombPerSquareCentimeter
-
         /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static ElectricSurfaceChargeDensity CoulombsPerSquareCentimeter<T>(this T value) =>
-             ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CoulombPerSquareInch
+            ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(UnitsNet.QuantityValue)" />
         public static ElectricSurfaceChargeDensity CoulombsPerSquareInch<T>(this T value) =>
-             ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CoulombPerSquareMeter
+            ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static ElectricSurfaceChargeDensity CoulombsPerSquareMeter<T>(this T value) =>
-             ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
+            ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
similarity index 62%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToEnergyExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
index 497bf3b2fa..6f5b2bcb86 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
@@ -19,221 +19,116 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToEnergy
+namespace UnitsNet.NumberExtensions.NumberToEnergy
 {
     /// <summary>
     /// A number to Energy Extensions
     /// </summary>
     public static class NumberToEnergyExtensions
     {
-
-        #region BritishThermalUnit
-
         /// <inheritdoc cref="Energy.FromBritishThermalUnits(UnitsNet.QuantityValue)" />
         public static Energy BritishThermalUnits<T>(this T value) =>
-             Energy.FromBritishThermalUnits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Calorie
+            Energy.FromBritishThermalUnits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromCalories(UnitsNet.QuantityValue)" />
         public static Energy Calories<T>(this T value) =>
-             Energy.FromCalories(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecathermEc
+            Energy.FromCalories(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromDecathermsEc(UnitsNet.QuantityValue)" />
         public static Energy DecathermsEc<T>(this T value) =>
-             Energy.FromDecathermsEc(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecathermImperial
+            Energy.FromDecathermsEc(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromDecathermsImperial(UnitsNet.QuantityValue)" />
         public static Energy DecathermsImperial<T>(this T value) =>
-             Energy.FromDecathermsImperial(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecathermUs
+            Energy.FromDecathermsImperial(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromDecathermsUs(UnitsNet.QuantityValue)" />
         public static Energy DecathermsUs<T>(this T value) =>
-             Energy.FromDecathermsUs(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ElectronVolt
+            Energy.FromDecathermsUs(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromElectronVolts(UnitsNet.QuantityValue)" />
         public static Energy ElectronVolts<T>(this T value) =>
-             Energy.FromElectronVolts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Erg
+            Energy.FromElectronVolts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromErgs(UnitsNet.QuantityValue)" />
         public static Energy Ergs<T>(this T value) =>
-             Energy.FromErgs(Convert.ToDouble(value));
-
-        #endregion
-
-        #region FootPound
+            Energy.FromErgs(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromFootPounds(UnitsNet.QuantityValue)" />
         public static Energy FootPounds<T>(this T value) =>
-             Energy.FromFootPounds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GigabritishThermalUnit
+            Energy.FromFootPounds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromGigabritishThermalUnits(UnitsNet.QuantityValue)" />
         public static Energy GigabritishThermalUnits<T>(this T value) =>
-             Energy.FromGigabritishThermalUnits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Gigajoule
+            Energy.FromGigabritishThermalUnits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromGigajoules(UnitsNet.QuantityValue)" />
         public static Energy Gigajoules<T>(this T value) =>
-             Energy.FromGigajoules(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GigawattHour
+            Energy.FromGigajoules(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromGigawattHours(UnitsNet.QuantityValue)" />
         public static Energy GigawattHours<T>(this T value) =>
-             Energy.FromGigawattHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Joule
+            Energy.FromGigawattHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromJoules(UnitsNet.QuantityValue)" />
         public static Energy Joules<T>(this T value) =>
-             Energy.FromJoules(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilobritishThermalUnit
+            Energy.FromJoules(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromKilobritishThermalUnits(UnitsNet.QuantityValue)" />
         public static Energy KilobritishThermalUnits<T>(this T value) =>
-             Energy.FromKilobritishThermalUnits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilocalorie
+            Energy.FromKilobritishThermalUnits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromKilocalories(UnitsNet.QuantityValue)" />
         public static Energy Kilocalories<T>(this T value) =>
-             Energy.FromKilocalories(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilojoule
+            Energy.FromKilocalories(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromKilojoules(UnitsNet.QuantityValue)" />
         public static Energy Kilojoules<T>(this T value) =>
-             Energy.FromKilojoules(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilowattHour
+            Energy.FromKilojoules(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromKilowattHours(UnitsNet.QuantityValue)" />
         public static Energy KilowattHours<T>(this T value) =>
-             Energy.FromKilowattHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegabritishThermalUnit
+            Energy.FromKilowattHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromMegabritishThermalUnits(UnitsNet.QuantityValue)" />
         public static Energy MegabritishThermalUnits<T>(this T value) =>
-             Energy.FromMegabritishThermalUnits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megacalorie
+            Energy.FromMegabritishThermalUnits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromMegacalories(UnitsNet.QuantityValue)" />
         public static Energy Megacalories<T>(this T value) =>
-             Energy.FromMegacalories(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megajoule
+            Energy.FromMegacalories(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromMegajoules(UnitsNet.QuantityValue)" />
         public static Energy Megajoules<T>(this T value) =>
-             Energy.FromMegajoules(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegawattHour
+            Energy.FromMegajoules(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromMegawattHours(UnitsNet.QuantityValue)" />
         public static Energy MegawattHours<T>(this T value) =>
-             Energy.FromMegawattHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millijoule
+            Energy.FromMegawattHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromMillijoules(UnitsNet.QuantityValue)" />
         public static Energy Millijoules<T>(this T value) =>
-             Energy.FromMillijoules(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TerawattHour
+            Energy.FromMillijoules(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromTerawattHours(UnitsNet.QuantityValue)" />
         public static Energy TerawattHours<T>(this T value) =>
-             Energy.FromTerawattHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ThermEc
+            Energy.FromTerawattHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromThermsEc(UnitsNet.QuantityValue)" />
         public static Energy ThermsEc<T>(this T value) =>
-             Energy.FromThermsEc(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ThermImperial
+            Energy.FromThermsEc(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromThermsImperial(UnitsNet.QuantityValue)" />
         public static Energy ThermsImperial<T>(this T value) =>
-             Energy.FromThermsImperial(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ThermUs
+            Energy.FromThermsImperial(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromThermsUs(UnitsNet.QuantityValue)" />
         public static Energy ThermsUs<T>(this T value) =>
-             Energy.FromThermsUs(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattHour
+            Energy.FromThermsUs(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Energy.FromWattHours(UnitsNet.QuantityValue)" />
         public static Energy WattHours<T>(this T value) =>
-             Energy.FromWattHours(Convert.ToDouble(value));
-
-        #endregion
+            Energy.FromWattHours(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
similarity index 71%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToEntropyExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
index 870ece646e..9c773ebe23 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
@@ -19,69 +19,40 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToEntropy
+namespace UnitsNet.NumberExtensions.NumberToEntropy
 {
     /// <summary>
     /// A number to Entropy Extensions
     /// </summary>
     public static class NumberToEntropyExtensions
     {
-
-        #region CaloriePerKelvin
-
         /// <inheritdoc cref="Entropy.FromCaloriesPerKelvin(UnitsNet.QuantityValue)" />
         public static Entropy CaloriesPerKelvin<T>(this T value) =>
-             Entropy.FromCaloriesPerKelvin(Convert.ToDouble(value));
-
-        #endregion
-
-        #region JoulePerDegreeCelsius
+            Entropy.FromCaloriesPerKelvin(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Entropy.FromJoulesPerDegreeCelsius(UnitsNet.QuantityValue)" />
         public static Entropy JoulesPerDegreeCelsius<T>(this T value) =>
-             Entropy.FromJoulesPerDegreeCelsius(Convert.ToDouble(value));
-
-        #endregion
-
-        #region JoulePerKelvin
+            Entropy.FromJoulesPerDegreeCelsius(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Entropy.FromJoulesPerKelvin(UnitsNet.QuantityValue)" />
         public static Entropy JoulesPerKelvin<T>(this T value) =>
-             Entropy.FromJoulesPerKelvin(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilocaloriePerKelvin
+            Entropy.FromJoulesPerKelvin(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Entropy.FromKilocaloriesPerKelvin(UnitsNet.QuantityValue)" />
         public static Entropy KilocaloriesPerKelvin<T>(this T value) =>
-             Entropy.FromKilocaloriesPerKelvin(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilojoulePerDegreeCelsius
+            Entropy.FromKilocaloriesPerKelvin(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Entropy.FromKilojoulesPerDegreeCelsius(UnitsNet.QuantityValue)" />
         public static Entropy KilojoulesPerDegreeCelsius<T>(this T value) =>
-             Entropy.FromKilojoulesPerDegreeCelsius(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilojoulePerKelvin
+            Entropy.FromKilojoulesPerDegreeCelsius(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Entropy.FromKilojoulesPerKelvin(UnitsNet.QuantityValue)" />
         public static Entropy KilojoulesPerKelvin<T>(this T value) =>
-             Entropy.FromKilojoulesPerKelvin(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegajoulePerKelvin
+            Entropy.FromKilojoulesPerKelvin(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Entropy.FromMegajoulesPerKelvin(UnitsNet.QuantityValue)" />
         public static Entropy MegajoulesPerKelvin<T>(this T value) =>
-             Entropy.FromMegajoulesPerKelvin(Convert.ToDouble(value));
-
-        #endregion
+            Entropy.FromMegajoulesPerKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForceChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
similarity index 67%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForceChangeRateExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
index fd752acf59..43a4cdfb0d 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForceChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
@@ -19,101 +19,56 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToForceChangeRate
+namespace UnitsNet.NumberExtensions.NumberToForceChangeRate
 {
     /// <summary>
     /// A number to ForceChangeRate Extensions
     /// </summary>
     public static class NumberToForceChangeRateExtensions
     {
-
-        #region CentinewtonPerSecond
-
         /// <inheritdoc cref="ForceChangeRate.FromCentinewtonsPerSecond(UnitsNet.QuantityValue)" />
         public static ForceChangeRate CentinewtonsPerSecond<T>(this T value) =>
-             ForceChangeRate.FromCentinewtonsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecanewtonPerMinute
+            ForceChangeRate.FromCentinewtonsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerMinute(UnitsNet.QuantityValue)" />
         public static ForceChangeRate DecanewtonsPerMinute<T>(this T value) =>
-             ForceChangeRate.FromDecanewtonsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecanewtonPerSecond
+            ForceChangeRate.FromDecanewtonsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerSecond(UnitsNet.QuantityValue)" />
         public static ForceChangeRate DecanewtonsPerSecond<T>(this T value) =>
-             ForceChangeRate.FromDecanewtonsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecinewtonPerSecond
+            ForceChangeRate.FromDecanewtonsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForceChangeRate.FromDecinewtonsPerSecond(UnitsNet.QuantityValue)" />
         public static ForceChangeRate DecinewtonsPerSecond<T>(this T value) =>
-             ForceChangeRate.FromDecinewtonsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonPerMinute
+            ForceChangeRate.FromDecinewtonsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerMinute(UnitsNet.QuantityValue)" />
         public static ForceChangeRate KilonewtonsPerMinute<T>(this T value) =>
-             ForceChangeRate.FromKilonewtonsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonPerSecond
+            ForceChangeRate.FromKilonewtonsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerSecond(UnitsNet.QuantityValue)" />
         public static ForceChangeRate KilonewtonsPerSecond<T>(this T value) =>
-             ForceChangeRate.FromKilonewtonsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicronewtonPerSecond
+            ForceChangeRate.FromKilonewtonsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForceChangeRate.FromMicronewtonsPerSecond(UnitsNet.QuantityValue)" />
         public static ForceChangeRate MicronewtonsPerSecond<T>(this T value) =>
-             ForceChangeRate.FromMicronewtonsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillinewtonPerSecond
+            ForceChangeRate.FromMicronewtonsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForceChangeRate.FromMillinewtonsPerSecond(UnitsNet.QuantityValue)" />
         public static ForceChangeRate MillinewtonsPerSecond<T>(this T value) =>
-             ForceChangeRate.FromMillinewtonsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanonewtonPerSecond
+            ForceChangeRate.FromMillinewtonsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForceChangeRate.FromNanonewtonsPerSecond(UnitsNet.QuantityValue)" />
         public static ForceChangeRate NanonewtonsPerSecond<T>(this T value) =>
-             ForceChangeRate.FromNanonewtonsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonPerMinute
+            ForceChangeRate.FromNanonewtonsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerMinute(UnitsNet.QuantityValue)" />
         public static ForceChangeRate NewtonsPerMinute<T>(this T value) =>
-             ForceChangeRate.FromNewtonsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonPerSecond
+            ForceChangeRate.FromNewtonsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerSecond(UnitsNet.QuantityValue)" />
         public static ForceChangeRate NewtonsPerSecond<T>(this T value) =>
-             ForceChangeRate.FromNewtonsPerSecond(Convert.ToDouble(value));
-
-        #endregion
+            ForceChangeRate.FromNewtonsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
similarity index 67%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForceExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
index c731af802d..b8c7f6d45b 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
@@ -19,117 +19,64 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToForce
+namespace UnitsNet.NumberExtensions.NumberToForce
 {
     /// <summary>
     /// A number to Force Extensions
     /// </summary>
     public static class NumberToForceExtensions
     {
-
-        #region Decanewton
-
         /// <inheritdoc cref="Force.FromDecanewtons(UnitsNet.QuantityValue)" />
         public static Force Decanewtons<T>(this T value) =>
-             Force.FromDecanewtons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Dyn
+            Force.FromDecanewtons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromDyne(UnitsNet.QuantityValue)" />
         public static Force Dyne<T>(this T value) =>
-             Force.FromDyne(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramForce
+            Force.FromDyne(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromKilogramsForce(UnitsNet.QuantityValue)" />
         public static Force KilogramsForce<T>(this T value) =>
-             Force.FromKilogramsForce(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilonewton
+            Force.FromKilogramsForce(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromKilonewtons(UnitsNet.QuantityValue)" />
         public static Force Kilonewtons<T>(this T value) =>
-             Force.FromKilonewtons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KiloPond
+            Force.FromKilonewtons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromKiloPonds(UnitsNet.QuantityValue)" />
         public static Force KiloPonds<T>(this T value) =>
-             Force.FromKiloPonds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Meganewton
+            Force.FromKiloPonds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromMeganewtons(UnitsNet.QuantityValue)" />
         public static Force Meganewtons<T>(this T value) =>
-             Force.FromMeganewtons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Micronewton
+            Force.FromMeganewtons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromMicronewtons(UnitsNet.QuantityValue)" />
         public static Force Micronewtons<T>(this T value) =>
-             Force.FromMicronewtons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millinewton
+            Force.FromMicronewtons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromMillinewtons(UnitsNet.QuantityValue)" />
         public static Force Millinewtons<T>(this T value) =>
-             Force.FromMillinewtons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Newton
+            Force.FromMillinewtons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromNewtons(UnitsNet.QuantityValue)" />
         public static Force Newtons<T>(this T value) =>
-             Force.FromNewtons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region OunceForce
+            Force.FromNewtons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromOunceForce(UnitsNet.QuantityValue)" />
         public static Force OunceForce<T>(this T value) =>
-             Force.FromOunceForce(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Poundal
+            Force.FromOunceForce(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromPoundals(UnitsNet.QuantityValue)" />
         public static Force Poundals<T>(this T value) =>
-             Force.FromPoundals(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForce
+            Force.FromPoundals(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromPoundsForce(UnitsNet.QuantityValue)" />
         public static Force PoundsForce<T>(this T value) =>
-             Force.FromPoundsForce(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForce
+            Force.FromPoundsForce(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Force.FromTonnesForce(UnitsNet.QuantityValue)" />
         public static Force TonnesForce<T>(this T value) =>
-             Force.FromTonnesForce(Convert.ToDouble(value));
-
-        #endregion
+            Force.FromTonnesForce(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForcePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
similarity index 67%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForcePerLengthExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
index 89753bf110..a9a048e11c 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToForcePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
@@ -19,109 +19,60 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToForcePerLength
+namespace UnitsNet.NumberExtensions.NumberToForcePerLength
 {
     /// <summary>
     /// A number to ForcePerLength Extensions
     /// </summary>
     public static class NumberToForcePerLengthExtensions
     {
-
-        #region CentinewtonPerMeter
-
         /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMeter(UnitsNet.QuantityValue)" />
         public static ForcePerLength CentinewtonsPerMeter<T>(this T value) =>
-             ForcePerLength.FromCentinewtonsPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecinewtonPerMeter
+            ForcePerLength.FromCentinewtonsPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMeter(UnitsNet.QuantityValue)" />
         public static ForcePerLength DecinewtonsPerMeter<T>(this T value) =>
-             ForcePerLength.FromDecinewtonsPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramForcePerMeter
+            ForcePerLength.FromDecinewtonsPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMeter(UnitsNet.QuantityValue)" />
         public static ForcePerLength KilogramsForcePerMeter<T>(this T value) =>
-             ForcePerLength.FromKilogramsForcePerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonPerMeter
+            ForcePerLength.FromKilogramsForcePerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMeter(UnitsNet.QuantityValue)" />
         public static ForcePerLength KilonewtonsPerMeter<T>(this T value) =>
-             ForcePerLength.FromKilonewtonsPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeganewtonPerMeter
+            ForcePerLength.FromKilonewtonsPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMeter(UnitsNet.QuantityValue)" />
         public static ForcePerLength MeganewtonsPerMeter<T>(this T value) =>
-             ForcePerLength.FromMeganewtonsPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicronewtonPerMeter
+            ForcePerLength.FromMeganewtonsPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMeter(UnitsNet.QuantityValue)" />
         public static ForcePerLength MicronewtonsPerMeter<T>(this T value) =>
-             ForcePerLength.FromMicronewtonsPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillinewtonPerMeter
+            ForcePerLength.FromMicronewtonsPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMeter(UnitsNet.QuantityValue)" />
         public static ForcePerLength MillinewtonsPerMeter<T>(this T value) =>
-             ForcePerLength.FromMillinewtonsPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanonewtonPerMeter
+            ForcePerLength.FromMillinewtonsPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMeter(UnitsNet.QuantityValue)" />
         public static ForcePerLength NanonewtonsPerMeter<T>(this T value) =>
-             ForcePerLength.FromNanonewtonsPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonPerMeter
+            ForcePerLength.FromNanonewtonsPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMeter(UnitsNet.QuantityValue)" />
         public static ForcePerLength NewtonsPerMeter<T>(this T value) =>
-             ForcePerLength.FromNewtonsPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForcePerFoot
+            ForcePerLength.FromNewtonsPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerFoot(UnitsNet.QuantityValue)" />
         public static ForcePerLength PoundsForcePerFoot<T>(this T value) =>
-             ForcePerLength.FromPoundsForcePerFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForcePerInch
+            ForcePerLength.FromPoundsForcePerFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerInch(UnitsNet.QuantityValue)" />
         public static ForcePerLength PoundsForcePerInch<T>(this T value) =>
-             ForcePerLength.FromPoundsForcePerInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForcePerYard
+            ForcePerLength.FromPoundsForcePerInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerYard(UnitsNet.QuantityValue)" />
         public static ForcePerLength PoundsForcePerYard<T>(this T value) =>
-             ForcePerLength.FromPoundsForcePerYard(Convert.ToDouble(value));
-
-        #endregion
+            ForcePerLength.FromPoundsForcePerYard(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToFrequencyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
similarity index 70%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToFrequencyExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
index 3f12c1bc39..9ee226c0e3 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToFrequencyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
@@ -19,85 +19,48 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToFrequency
+namespace UnitsNet.NumberExtensions.NumberToFrequency
 {
     /// <summary>
     /// A number to Frequency Extensions
     /// </summary>
     public static class NumberToFrequencyExtensions
     {
-
-        #region BeatPerMinute
-
         /// <inheritdoc cref="Frequency.FromBeatsPerMinute(UnitsNet.QuantityValue)" />
         public static Frequency BeatsPerMinute<T>(this T value) =>
-             Frequency.FromBeatsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CyclePerHour
+            Frequency.FromBeatsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Frequency.FromCyclesPerHour(UnitsNet.QuantityValue)" />
         public static Frequency CyclesPerHour<T>(this T value) =>
-             Frequency.FromCyclesPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CyclePerMinute
+            Frequency.FromCyclesPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Frequency.FromCyclesPerMinute(UnitsNet.QuantityValue)" />
         public static Frequency CyclesPerMinute<T>(this T value) =>
-             Frequency.FromCyclesPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Gigahertz
+            Frequency.FromCyclesPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Frequency.FromGigahertz(UnitsNet.QuantityValue)" />
         public static Frequency Gigahertz<T>(this T value) =>
-             Frequency.FromGigahertz(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Hertz
+            Frequency.FromGigahertz(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Frequency.FromHertz(UnitsNet.QuantityValue)" />
         public static Frequency Hertz<T>(this T value) =>
-             Frequency.FromHertz(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilohertz
+            Frequency.FromHertz(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Frequency.FromKilohertz(UnitsNet.QuantityValue)" />
         public static Frequency Kilohertz<T>(this T value) =>
-             Frequency.FromKilohertz(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megahertz
+            Frequency.FromKilohertz(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Frequency.FromMegahertz(UnitsNet.QuantityValue)" />
         public static Frequency Megahertz<T>(this T value) =>
-             Frequency.FromMegahertz(Convert.ToDouble(value));
-
-        #endregion
-
-        #region RadianPerSecond
+            Frequency.FromMegahertz(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Frequency.FromRadiansPerSecond(UnitsNet.QuantityValue)" />
         public static Frequency RadiansPerSecond<T>(this T value) =>
-             Frequency.FromRadiansPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Terahertz
+            Frequency.FromRadiansPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Frequency.FromTerahertz(UnitsNet.QuantityValue)" />
         public static Frequency Terahertz<T>(this T value) =>
-             Frequency.FromTerahertz(Convert.ToDouble(value));
-
-        #endregion
+            Frequency.FromTerahertz(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToFuelEfficiencyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
similarity index 76%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToFuelEfficiencyExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
index b8b420f3e0..826c85005b 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToFuelEfficiencyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
@@ -19,45 +19,28 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToFuelEfficiency
+namespace UnitsNet.NumberExtensions.NumberToFuelEfficiency
 {
     /// <summary>
     /// A number to FuelEfficiency Extensions
     /// </summary>
     public static class NumberToFuelEfficiencyExtensions
     {
-
-        #region KilometerPerLiter
-
         /// <inheritdoc cref="FuelEfficiency.FromKilometersPerLiters(UnitsNet.QuantityValue)" />
         public static FuelEfficiency KilometersPerLiters<T>(this T value) =>
-             FuelEfficiency.FromKilometersPerLiters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region LiterPer100Kilometers
+            FuelEfficiency.FromKilometersPerLiters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="FuelEfficiency.FromLitersPer100Kilometers(UnitsNet.QuantityValue)" />
         public static FuelEfficiency LitersPer100Kilometers<T>(this T value) =>
-             FuelEfficiency.FromLitersPer100Kilometers(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilePerUkGallon
+            FuelEfficiency.FromLitersPer100Kilometers(Convert.ToDouble(value));
 
         /// <inheritdoc cref="FuelEfficiency.FromMilesPerUkGallon(UnitsNet.QuantityValue)" />
         public static FuelEfficiency MilesPerUkGallon<T>(this T value) =>
-             FuelEfficiency.FromMilesPerUkGallon(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilePerUsGallon
+            FuelEfficiency.FromMilesPerUkGallon(Convert.ToDouble(value));
 
         /// <inheritdoc cref="FuelEfficiency.FromMilesPerUsGallon(UnitsNet.QuantityValue)" />
         public static FuelEfficiency MilesPerUsGallon<T>(this T value) =>
-             FuelEfficiency.FromMilesPerUsGallon(Convert.ToDouble(value));
-
-        #endregion
+            FuelEfficiency.FromMilesPerUsGallon(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToHeatFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
similarity index 63%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToHeatFluxExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
index c413d84c08..0c0878bd21 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToHeatFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
@@ -19,157 +19,84 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToHeatFlux
+namespace UnitsNet.NumberExtensions.NumberToHeatFlux
 {
     /// <summary>
     /// A number to HeatFlux Extensions
     /// </summary>
     public static class NumberToHeatFluxExtensions
     {
-
-        #region BtuPerHourSquareFoot
-
         /// <inheritdoc cref="HeatFlux.FromBtusPerHourSquareFoot(UnitsNet.QuantityValue)" />
         public static HeatFlux BtusPerHourSquareFoot<T>(this T value) =>
-             HeatFlux.FromBtusPerHourSquareFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region BtuPerMinuteSquareFoot
+            HeatFlux.FromBtusPerHourSquareFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromBtusPerMinuteSquareFoot(UnitsNet.QuantityValue)" />
         public static HeatFlux BtusPerMinuteSquareFoot<T>(this T value) =>
-             HeatFlux.FromBtusPerMinuteSquareFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region BtuPerSecondSquareFoot
+            HeatFlux.FromBtusPerMinuteSquareFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareFoot(UnitsNet.QuantityValue)" />
         public static HeatFlux BtusPerSecondSquareFoot<T>(this T value) =>
-             HeatFlux.FromBtusPerSecondSquareFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region BtuPerSecondSquareInch
+            HeatFlux.FromBtusPerSecondSquareFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareInch(UnitsNet.QuantityValue)" />
         public static HeatFlux BtusPerSecondSquareInch<T>(this T value) =>
-             HeatFlux.FromBtusPerSecondSquareInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CaloriePerSecondSquareCentimeter
+            HeatFlux.FromBtusPerSecondSquareInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromCaloriesPerSecondSquareCentimeter(UnitsNet.QuantityValue)" />
         public static HeatFlux CaloriesPerSecondSquareCentimeter<T>(this T value) =>
-             HeatFlux.FromCaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentiwattPerSquareMeter
+            HeatFlux.FromCaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromCentiwattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static HeatFlux CentiwattsPerSquareMeter<T>(this T value) =>
-             HeatFlux.FromCentiwattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DeciwattPerSquareMeter
+            HeatFlux.FromCentiwattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromDeciwattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static HeatFlux DeciwattsPerSquareMeter<T>(this T value) =>
-             HeatFlux.FromDeciwattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilocaloriePerHourSquareMeter
+            HeatFlux.FromDeciwattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerHourSquareMeter(UnitsNet.QuantityValue)" />
         public static HeatFlux KilocaloriesPerHourSquareMeter<T>(this T value) =>
-             HeatFlux.FromKilocaloriesPerHourSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilocaloriePerSecondSquareCentimeter
+            HeatFlux.FromKilocaloriesPerHourSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(UnitsNet.QuantityValue)" />
         public static HeatFlux KilocaloriesPerSecondSquareCentimeter<T>(this T value) =>
-             HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilowattPerSquareMeter
+            HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromKilowattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static HeatFlux KilowattsPerSquareMeter<T>(this T value) =>
-             HeatFlux.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrowattPerSquareMeter
+            HeatFlux.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromMicrowattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static HeatFlux MicrowattsPerSquareMeter<T>(this T value) =>
-             HeatFlux.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliwattPerSquareMeter
+            HeatFlux.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromMilliwattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static HeatFlux MilliwattsPerSquareMeter<T>(this T value) =>
-             HeatFlux.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanowattPerSquareMeter
+            HeatFlux.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromNanowattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static HeatFlux NanowattsPerSquareMeter<T>(this T value) =>
-             HeatFlux.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForcePerFootSecond
+            HeatFlux.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromPoundsForcePerFootSecond(UnitsNet.QuantityValue)" />
         public static HeatFlux PoundsForcePerFootSecond<T>(this T value) =>
-             HeatFlux.FromPoundsForcePerFootSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerSecondCubed
+            HeatFlux.FromPoundsForcePerFootSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromPoundsPerSecondCubed(UnitsNet.QuantityValue)" />
         public static HeatFlux PoundsPerSecondCubed<T>(this T value) =>
-             HeatFlux.FromPoundsPerSecondCubed(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerSquareFoot
+            HeatFlux.FromPoundsPerSecondCubed(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromWattsPerSquareFoot(UnitsNet.QuantityValue)" />
         public static HeatFlux WattsPerSquareFoot<T>(this T value) =>
-             HeatFlux.FromWattsPerSquareFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerSquareInch
+            HeatFlux.FromWattsPerSquareFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromWattsPerSquareInch(UnitsNet.QuantityValue)" />
         public static HeatFlux WattsPerSquareInch<T>(this T value) =>
-             HeatFlux.FromWattsPerSquareInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerSquareMeter
+            HeatFlux.FromWattsPerSquareInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatFlux.FromWattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static HeatFlux WattsPerSquareMeter<T>(this T value) =>
-             HeatFlux.FromWattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
+            HeatFlux.FromWattsPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToHeatTransferCoefficientExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
similarity index 76%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToHeatTransferCoefficientExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
index a8112c9d6b..2df7eccc31 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToHeatTransferCoefficientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToHeatTransferCoefficient
+namespace UnitsNet.NumberExtensions.NumberToHeatTransferCoefficient
 {
     /// <summary>
     /// A number to HeatTransferCoefficient Extensions
     /// </summary>
     public static class NumberToHeatTransferCoefficientExtensions
     {
-
-        #region BtuPerSquareFootDegreeFahrenheit
-
         /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(UnitsNet.QuantityValue)" />
         public static HeatTransferCoefficient BtusPerSquareFootDegreeFahrenheit<T>(this T value) =>
-             HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerSquareMeterCelsius
+            HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(UnitsNet.QuantityValue)" />
         public static HeatTransferCoefficient WattsPerSquareMeterCelsius<T>(this T value) =>
-             HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerSquareMeterKelvin
+            HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(Convert.ToDouble(value));
 
         /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(UnitsNet.QuantityValue)" />
         public static HeatTransferCoefficient WattsPerSquareMeterKelvin<T>(this T value) =>
-             HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(Convert.ToDouble(value));
-
-        #endregion
+            HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIlluminanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
similarity index 78%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIlluminanceExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
index 8ea3a42f1b..86679976a3 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIlluminanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
@@ -19,45 +19,28 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToIlluminance
+namespace UnitsNet.NumberExtensions.NumberToIlluminance
 {
     /// <summary>
     /// A number to Illuminance Extensions
     /// </summary>
     public static class NumberToIlluminanceExtensions
     {
-
-        #region Kilolux
-
         /// <inheritdoc cref="Illuminance.FromKilolux(UnitsNet.QuantityValue)" />
         public static Illuminance Kilolux<T>(this T value) =>
-             Illuminance.FromKilolux(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Lux
+            Illuminance.FromKilolux(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Illuminance.FromLux(UnitsNet.QuantityValue)" />
         public static Illuminance Lux<T>(this T value) =>
-             Illuminance.FromLux(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megalux
+            Illuminance.FromLux(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Illuminance.FromMegalux(UnitsNet.QuantityValue)" />
         public static Illuminance Megalux<T>(this T value) =>
-             Illuminance.FromMegalux(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millilux
+            Illuminance.FromMegalux(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Illuminance.FromMillilux(UnitsNet.QuantityValue)" />
         public static Illuminance Millilux<T>(this T value) =>
-             Illuminance.FromMillilux(Convert.ToDouble(value));
-
-        #endregion
+            Illuminance.FromMillilux(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToInformationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
similarity index 63%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToInformationExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
index 9841e7761f..3971d52354 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToInformationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
@@ -19,221 +19,116 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToInformation
+namespace UnitsNet.NumberExtensions.NumberToInformation
 {
     /// <summary>
     /// A number to Information Extensions
     /// </summary>
     public static class NumberToInformationExtensions
     {
-
-        #region Bit
-
         /// <inheritdoc cref="Information.FromBits(UnitsNet.QuantityValue)" />
         public static Information Bits<T>(this T value) =>
-             Information.FromBits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Byte
+            Information.FromBits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromBytes(UnitsNet.QuantityValue)" />
         public static Information Bytes<T>(this T value) =>
-             Information.FromBytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Exabit
+            Information.FromBytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromExabits(UnitsNet.QuantityValue)" />
         public static Information Exabits<T>(this T value) =>
-             Information.FromExabits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Exabyte
+            Information.FromExabits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromExabytes(UnitsNet.QuantityValue)" />
         public static Information Exabytes<T>(this T value) =>
-             Information.FromExabytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Exbibit
+            Information.FromExabytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromExbibits(UnitsNet.QuantityValue)" />
         public static Information Exbibits<T>(this T value) =>
-             Information.FromExbibits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Exbibyte
+            Information.FromExbibits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromExbibytes(UnitsNet.QuantityValue)" />
         public static Information Exbibytes<T>(this T value) =>
-             Information.FromExbibytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Gibibit
+            Information.FromExbibytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromGibibits(UnitsNet.QuantityValue)" />
         public static Information Gibibits<T>(this T value) =>
-             Information.FromGibibits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Gibibyte
+            Information.FromGibibits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromGibibytes(UnitsNet.QuantityValue)" />
         public static Information Gibibytes<T>(this T value) =>
-             Information.FromGibibytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Gigabit
+            Information.FromGibibytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromGigabits(UnitsNet.QuantityValue)" />
         public static Information Gigabits<T>(this T value) =>
-             Information.FromGigabits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Gigabyte
+            Information.FromGigabits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromGigabytes(UnitsNet.QuantityValue)" />
         public static Information Gigabytes<T>(this T value) =>
-             Information.FromGigabytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kibibit
+            Information.FromGigabytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromKibibits(UnitsNet.QuantityValue)" />
         public static Information Kibibits<T>(this T value) =>
-             Information.FromKibibits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kibibyte
+            Information.FromKibibits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromKibibytes(UnitsNet.QuantityValue)" />
         public static Information Kibibytes<T>(this T value) =>
-             Information.FromKibibytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilobit
+            Information.FromKibibytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromKilobits(UnitsNet.QuantityValue)" />
         public static Information Kilobits<T>(this T value) =>
-             Information.FromKilobits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilobyte
+            Information.FromKilobits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromKilobytes(UnitsNet.QuantityValue)" />
         public static Information Kilobytes<T>(this T value) =>
-             Information.FromKilobytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Mebibit
+            Information.FromKilobytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromMebibits(UnitsNet.QuantityValue)" />
         public static Information Mebibits<T>(this T value) =>
-             Information.FromMebibits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Mebibyte
+            Information.FromMebibits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromMebibytes(UnitsNet.QuantityValue)" />
         public static Information Mebibytes<T>(this T value) =>
-             Information.FromMebibytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megabit
+            Information.FromMebibytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromMegabits(UnitsNet.QuantityValue)" />
         public static Information Megabits<T>(this T value) =>
-             Information.FromMegabits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megabyte
+            Information.FromMegabits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromMegabytes(UnitsNet.QuantityValue)" />
         public static Information Megabytes<T>(this T value) =>
-             Information.FromMegabytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Pebibit
+            Information.FromMegabytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromPebibits(UnitsNet.QuantityValue)" />
         public static Information Pebibits<T>(this T value) =>
-             Information.FromPebibits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Pebibyte
+            Information.FromPebibits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromPebibytes(UnitsNet.QuantityValue)" />
         public static Information Pebibytes<T>(this T value) =>
-             Information.FromPebibytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Petabit
+            Information.FromPebibytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromPetabits(UnitsNet.QuantityValue)" />
         public static Information Petabits<T>(this T value) =>
-             Information.FromPetabits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Petabyte
+            Information.FromPetabits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromPetabytes(UnitsNet.QuantityValue)" />
         public static Information Petabytes<T>(this T value) =>
-             Information.FromPetabytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Tebibit
+            Information.FromPetabytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromTebibits(UnitsNet.QuantityValue)" />
         public static Information Tebibits<T>(this T value) =>
-             Information.FromTebibits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Tebibyte
+            Information.FromTebibits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromTebibytes(UnitsNet.QuantityValue)" />
         public static Information Tebibytes<T>(this T value) =>
-             Information.FromTebibytes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Terabit
+            Information.FromTebibytes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromTerabits(UnitsNet.QuantityValue)" />
         public static Information Terabits<T>(this T value) =>
-             Information.FromTerabits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Terabyte
+            Information.FromTerabits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Information.FromTerabytes(UnitsNet.QuantityValue)" />
         public static Information Terabytes<T>(this T value) =>
-             Information.FromTerabytes(Convert.ToDouble(value));
-
-        #endregion
+            Information.FromTerabytes(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIrradianceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
similarity index 65%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIrradianceExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
index cb374c4c13..7b4e14d16c 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIrradianceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
@@ -19,125 +19,68 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToIrradiance
+namespace UnitsNet.NumberExtensions.NumberToIrradiance
 {
     /// <summary>
     /// A number to Irradiance Extensions
     /// </summary>
     public static class NumberToIrradianceExtensions
     {
-
-        #region KilowattPerSquareCentimeter
-
         /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Irradiance KilowattsPerSquareCentimeter<T>(this T value) =>
-             Irradiance.FromKilowattsPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilowattPerSquareMeter
+            Irradiance.FromKilowattsPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Irradiance KilowattsPerSquareMeter<T>(this T value) =>
-             Irradiance.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegawattPerSquareCentimeter
+            Irradiance.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Irradiance MegawattsPerSquareCentimeter<T>(this T value) =>
-             Irradiance.FromMegawattsPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegawattPerSquareMeter
+            Irradiance.FromMegawattsPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Irradiance MegawattsPerSquareMeter<T>(this T value) =>
-             Irradiance.FromMegawattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrowattPerSquareCentimeter
+            Irradiance.FromMegawattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Irradiance MicrowattsPerSquareCentimeter<T>(this T value) =>
-             Irradiance.FromMicrowattsPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrowattPerSquareMeter
+            Irradiance.FromMicrowattsPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Irradiance MicrowattsPerSquareMeter<T>(this T value) =>
-             Irradiance.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliwattPerSquareCentimeter
+            Irradiance.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Irradiance MilliwattsPerSquareCentimeter<T>(this T value) =>
-             Irradiance.FromMilliwattsPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliwattPerSquareMeter
+            Irradiance.FromMilliwattsPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Irradiance MilliwattsPerSquareMeter<T>(this T value) =>
-             Irradiance.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanowattPerSquareCentimeter
+            Irradiance.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Irradiance NanowattsPerSquareCentimeter<T>(this T value) =>
-             Irradiance.FromNanowattsPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanowattPerSquareMeter
+            Irradiance.FromNanowattsPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Irradiance NanowattsPerSquareMeter<T>(this T value) =>
-             Irradiance.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicowattPerSquareCentimeter
+            Irradiance.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Irradiance PicowattsPerSquareCentimeter<T>(this T value) =>
-             Irradiance.FromPicowattsPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicowattPerSquareMeter
+            Irradiance.FromPicowattsPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Irradiance PicowattsPerSquareMeter<T>(this T value) =>
-             Irradiance.FromPicowattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerSquareCentimeter
+            Irradiance.FromPicowattsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromWattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Irradiance WattsPerSquareCentimeter<T>(this T value) =>
-             Irradiance.FromWattsPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerSquareMeter
+            Irradiance.FromWattsPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiance.FromWattsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Irradiance WattsPerSquareMeter<T>(this T value) =>
-             Irradiance.FromWattsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
+            Irradiance.FromWattsPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIrradiationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
similarity index 70%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIrradiationExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
index a8ccc6d840..34c592ec8a 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToIrradiationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
@@ -19,69 +19,40 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToIrradiation
+namespace UnitsNet.NumberExtensions.NumberToIrradiation
 {
     /// <summary>
     /// A number to Irradiation Extensions
     /// </summary>
     public static class NumberToIrradiationExtensions
     {
-
-        #region JoulePerSquareCentimeter
-
         /// <inheritdoc cref="Irradiation.FromJoulesPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Irradiation JoulesPerSquareCentimeter<T>(this T value) =>
-             Irradiation.FromJoulesPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region JoulePerSquareMeter
+            Irradiation.FromJoulesPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Irradiation JoulesPerSquareMeter<T>(this T value) =>
-             Irradiation.FromJoulesPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region JoulePerSquareMillimeter
+            Irradiation.FromJoulesPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMillimeter(UnitsNet.QuantityValue)" />
         public static Irradiation JoulesPerSquareMillimeter<T>(this T value) =>
-             Irradiation.FromJoulesPerSquareMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilojoulePerSquareMeter
+            Irradiation.FromJoulesPerSquareMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiation.FromKilojoulesPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Irradiation KilojoulesPerSquareMeter<T>(this T value) =>
-             Irradiation.FromKilojoulesPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilowattHourPerSquareMeter
+            Irradiation.FromKilojoulesPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiation.FromKilowattHoursPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Irradiation KilowattHoursPerSquareMeter<T>(this T value) =>
-             Irradiation.FromKilowattHoursPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillijoulePerSquareCentimeter
+            Irradiation.FromKilowattHoursPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiation.FromMillijoulesPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Irradiation MillijoulesPerSquareCentimeter<T>(this T value) =>
-             Irradiation.FromMillijoulesPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattHourPerSquareMeter
+            Irradiation.FromMillijoulesPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Irradiation.FromWattHoursPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Irradiation WattHoursPerSquareMeter<T>(this T value) =>
-             Irradiation.FromWattHoursPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
+            Irradiation.FromWattHoursPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToKinematicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
similarity index 71%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToKinematicViscosityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
index 212bd8fd45..455ebd841d 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToKinematicViscosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
@@ -19,77 +19,44 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToKinematicViscosity
+namespace UnitsNet.NumberExtensions.NumberToKinematicViscosity
 {
     /// <summary>
     /// A number to KinematicViscosity Extensions
     /// </summary>
     public static class NumberToKinematicViscosityExtensions
     {
-
-        #region Centistokes
-
         /// <inheritdoc cref="KinematicViscosity.FromCentistokes(UnitsNet.QuantityValue)" />
         public static KinematicViscosity Centistokes<T>(this T value) =>
-             KinematicViscosity.FromCentistokes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Decistokes
+            KinematicViscosity.FromCentistokes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="KinematicViscosity.FromDecistokes(UnitsNet.QuantityValue)" />
         public static KinematicViscosity Decistokes<T>(this T value) =>
-             KinematicViscosity.FromDecistokes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilostokes
+            KinematicViscosity.FromDecistokes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="KinematicViscosity.FromKilostokes(UnitsNet.QuantityValue)" />
         public static KinematicViscosity Kilostokes<T>(this T value) =>
-             KinematicViscosity.FromKilostokes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microstokes
+            KinematicViscosity.FromKilostokes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="KinematicViscosity.FromMicrostokes(UnitsNet.QuantityValue)" />
         public static KinematicViscosity Microstokes<T>(this T value) =>
-             KinematicViscosity.FromMicrostokes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millistokes
+            KinematicViscosity.FromMicrostokes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="KinematicViscosity.FromMillistokes(UnitsNet.QuantityValue)" />
         public static KinematicViscosity Millistokes<T>(this T value) =>
-             KinematicViscosity.FromMillistokes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanostokes
+            KinematicViscosity.FromMillistokes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="KinematicViscosity.FromNanostokes(UnitsNet.QuantityValue)" />
         public static KinematicViscosity Nanostokes<T>(this T value) =>
-             KinematicViscosity.FromNanostokes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareMeterPerSecond
+            KinematicViscosity.FromNanostokes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(UnitsNet.QuantityValue)" />
         public static KinematicViscosity SquareMetersPerSecond<T>(this T value) =>
-             KinematicViscosity.FromSquareMetersPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Stokes
+            KinematicViscosity.FromSquareMetersPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="KinematicViscosity.FromStokes(UnitsNet.QuantityValue)" />
         public static KinematicViscosity Stokes<T>(this T value) =>
-             KinematicViscosity.FromStokes(Convert.ToDouble(value));
-
-        #endregion
+            KinematicViscosity.FromStokes(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLapseRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLapseRateExtensions.g.cs
similarity index 87%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLapseRateExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToLapseRateExtensions.g.cs
index e3309ca74f..a4e5f319ab 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLapseRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLapseRateExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToLapseRate
+namespace UnitsNet.NumberExtensions.NumberToLapseRate
 {
     /// <summary>
     /// A number to LapseRate Extensions
     /// </summary>
     public static class NumberToLapseRateExtensions
     {
-
-        #region DegreeCelsiusPerKilometer
-
         /// <inheritdoc cref="LapseRate.FromDegreesCelciusPerKilometer(UnitsNet.QuantityValue)" />
         public static LapseRate DegreesCelciusPerKilometer<T>(this T value) =>
-             LapseRate.FromDegreesCelciusPerKilometer(Convert.ToDouble(value));
-
-        #endregion
+            LapseRate.FromDegreesCelciusPerKilometer(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
similarity index 61%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLengthExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
index 5f6bcb5787..f9a95a740a 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
@@ -19,269 +19,140 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToLength
+namespace UnitsNet.NumberExtensions.NumberToLength
 {
     /// <summary>
     /// A number to Length Extensions
     /// </summary>
     public static class NumberToLengthExtensions
     {
-
-        #region AstronomicalUnit
-
         /// <inheritdoc cref="Length.FromAstronomicalUnits(UnitsNet.QuantityValue)" />
         public static Length AstronomicalUnits<T>(this T value) =>
-             Length.FromAstronomicalUnits(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Centimeter
+            Length.FromAstronomicalUnits(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromCentimeters(UnitsNet.QuantityValue)" />
         public static Length Centimeters<T>(this T value) =>
-             Length.FromCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Decimeter
+            Length.FromCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromDecimeters(UnitsNet.QuantityValue)" />
         public static Length Decimeters<T>(this T value) =>
-             Length.FromDecimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DtpPica
+            Length.FromDecimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromDtpPicas(UnitsNet.QuantityValue)" />
         public static Length DtpPicas<T>(this T value) =>
-             Length.FromDtpPicas(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DtpPoint
+            Length.FromDtpPicas(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromDtpPoints(UnitsNet.QuantityValue)" />
         public static Length DtpPoints<T>(this T value) =>
-             Length.FromDtpPoints(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Fathom
+            Length.FromDtpPoints(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromFathoms(UnitsNet.QuantityValue)" />
         public static Length Fathoms<T>(this T value) =>
-             Length.FromFathoms(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Foot
+            Length.FromFathoms(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromFeet(UnitsNet.QuantityValue)" />
         public static Length Feet<T>(this T value) =>
-             Length.FromFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Hand
+            Length.FromFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromHands(UnitsNet.QuantityValue)" />
         public static Length Hands<T>(this T value) =>
-             Length.FromHands(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Hectometer
+            Length.FromHands(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromHectometers(UnitsNet.QuantityValue)" />
         public static Length Hectometers<T>(this T value) =>
-             Length.FromHectometers(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Inch
+            Length.FromHectometers(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromInches(UnitsNet.QuantityValue)" />
         public static Length Inches<T>(this T value) =>
-             Length.FromInches(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilolightYear
+            Length.FromInches(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromKilolightYears(UnitsNet.QuantityValue)" />
         public static Length KilolightYears<T>(this T value) =>
-             Length.FromKilolightYears(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilometer
+            Length.FromKilolightYears(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromKilometers(UnitsNet.QuantityValue)" />
         public static Length Kilometers<T>(this T value) =>
-             Length.FromKilometers(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kiloparsec
+            Length.FromKilometers(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromKiloparsecs(UnitsNet.QuantityValue)" />
         public static Length Kiloparsecs<T>(this T value) =>
-             Length.FromKiloparsecs(Convert.ToDouble(value));
-
-        #endregion
-
-        #region LightYear
+            Length.FromKiloparsecs(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromLightYears(UnitsNet.QuantityValue)" />
         public static Length LightYears<T>(this T value) =>
-             Length.FromLightYears(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegalightYear
+            Length.FromLightYears(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromMegalightYears(UnitsNet.QuantityValue)" />
         public static Length MegalightYears<T>(this T value) =>
-             Length.FromMegalightYears(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megaparsec
+            Length.FromMegalightYears(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromMegaparsecs(UnitsNet.QuantityValue)" />
         public static Length Megaparsecs<T>(this T value) =>
-             Length.FromMegaparsecs(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Meter
+            Length.FromMegaparsecs(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromMeters(UnitsNet.QuantityValue)" />
         public static Length Meters<T>(this T value) =>
-             Length.FromMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microinch
+            Length.FromMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromMicroinches(UnitsNet.QuantityValue)" />
         public static Length Microinches<T>(this T value) =>
-             Length.FromMicroinches(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Micrometer
+            Length.FromMicroinches(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromMicrometers(UnitsNet.QuantityValue)" />
         public static Length Micrometers<T>(this T value) =>
-             Length.FromMicrometers(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Mil
+            Length.FromMicrometers(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromMils(UnitsNet.QuantityValue)" />
         public static Length Mils<T>(this T value) =>
-             Length.FromMils(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Mile
+            Length.FromMils(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromMiles(UnitsNet.QuantityValue)" />
         public static Length Miles<T>(this T value) =>
-             Length.FromMiles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millimeter
+            Length.FromMiles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromMillimeters(UnitsNet.QuantityValue)" />
         public static Length Millimeters<T>(this T value) =>
-             Length.FromMillimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanometer
+            Length.FromMillimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromNanometers(UnitsNet.QuantityValue)" />
         public static Length Nanometers<T>(this T value) =>
-             Length.FromNanometers(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NauticalMile
+            Length.FromNanometers(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromNauticalMiles(UnitsNet.QuantityValue)" />
         public static Length NauticalMiles<T>(this T value) =>
-             Length.FromNauticalMiles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Parsec
+            Length.FromNauticalMiles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromParsecs(UnitsNet.QuantityValue)" />
         public static Length Parsecs<T>(this T value) =>
-             Length.FromParsecs(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PrinterPica
+            Length.FromParsecs(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromPrinterPicas(UnitsNet.QuantityValue)" />
         public static Length PrinterPicas<T>(this T value) =>
-             Length.FromPrinterPicas(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PrinterPoint
+            Length.FromPrinterPicas(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromPrinterPoints(UnitsNet.QuantityValue)" />
         public static Length PrinterPoints<T>(this T value) =>
-             Length.FromPrinterPoints(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Shackle
+            Length.FromPrinterPoints(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromShackles(UnitsNet.QuantityValue)" />
         public static Length Shackles<T>(this T value) =>
-             Length.FromShackles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SolarRadius
+            Length.FromShackles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromSolarRadiuses(UnitsNet.QuantityValue)" />
         public static Length SolarRadiuses<T>(this T value) =>
-             Length.FromSolarRadiuses(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Twip
+            Length.FromSolarRadiuses(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromTwips(UnitsNet.QuantityValue)" />
         public static Length Twips<T>(this T value) =>
-             Length.FromTwips(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsSurveyFoot
+            Length.FromTwips(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromUsSurveyFeet(UnitsNet.QuantityValue)" />
         public static Length UsSurveyFeet<T>(this T value) =>
-             Length.FromUsSurveyFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Yard
+            Length.FromUsSurveyFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Length.FromYards(UnitsNet.QuantityValue)" />
         public static Length Yards<T>(this T value) =>
-             Length.FromYards(Convert.ToDouble(value));
-
-        #endregion
+            Length.FromYards(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLevelExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
similarity index 85%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLevelExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
index 1420e13a87..6bb437a285 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLevelExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
@@ -19,29 +19,20 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToLevel
+namespace UnitsNet.NumberExtensions.NumberToLevel
 {
     /// <summary>
     /// A number to Level Extensions
     /// </summary>
     public static class NumberToLevelExtensions
     {
-
-        #region Decibel
-
         /// <inheritdoc cref="Level.FromDecibels(UnitsNet.QuantityValue)" />
         public static Level Decibels<T>(this T value) =>
-             Level.FromDecibels(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Neper
+            Level.FromDecibels(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Level.FromNepers(UnitsNet.QuantityValue)" />
         public static Level Nepers<T>(this T value) =>
-             Level.FromNepers(Convert.ToDouble(value));
-
-        #endregion
+            Level.FromNepers(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLinearDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
similarity index 79%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLinearDensityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
index 3984925a0a..dbf0eb6378 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLinearDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToLinearDensity
+namespace UnitsNet.NumberExtensions.NumberToLinearDensity
 {
     /// <summary>
     /// A number to LinearDensity Extensions
     /// </summary>
     public static class NumberToLinearDensityExtensions
     {
-
-        #region GramPerMeter
-
         /// <inheritdoc cref="LinearDensity.FromGramsPerMeter(UnitsNet.QuantityValue)" />
         public static LinearDensity GramsPerMeter<T>(this T value) =>
-             LinearDensity.FromGramsPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerMeter
+            LinearDensity.FromGramsPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="LinearDensity.FromKilogramsPerMeter(UnitsNet.QuantityValue)" />
         public static LinearDensity KilogramsPerMeter<T>(this T value) =>
-             LinearDensity.FromKilogramsPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerFoot
+            LinearDensity.FromKilogramsPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="LinearDensity.FromPoundsPerFoot(UnitsNet.QuantityValue)" />
         public static LinearDensity PoundsPerFoot<T>(this T value) =>
-             LinearDensity.FromPoundsPerFoot(Convert.ToDouble(value));
-
-        #endregion
+            LinearDensity.FromPoundsPerFoot(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
similarity index 66%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminosityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
index 75a5195d72..8a76059267 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
@@ -19,125 +19,68 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToLuminosity
+namespace UnitsNet.NumberExtensions.NumberToLuminosity
 {
     /// <summary>
     /// A number to Luminosity Extensions
     /// </summary>
     public static class NumberToLuminosityExtensions
     {
-
-        #region Decawatt
-
         /// <inheritdoc cref="Luminosity.FromDecawatts(UnitsNet.QuantityValue)" />
         public static Luminosity Decawatts<T>(this T value) =>
-             Luminosity.FromDecawatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Deciwatt
+            Luminosity.FromDecawatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromDeciwatts(UnitsNet.QuantityValue)" />
         public static Luminosity Deciwatts<T>(this T value) =>
-             Luminosity.FromDeciwatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Femtowatt
+            Luminosity.FromDeciwatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromFemtowatts(UnitsNet.QuantityValue)" />
         public static Luminosity Femtowatts<T>(this T value) =>
-             Luminosity.FromFemtowatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Gigawatt
+            Luminosity.FromFemtowatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromGigawatts(UnitsNet.QuantityValue)" />
         public static Luminosity Gigawatts<T>(this T value) =>
-             Luminosity.FromGigawatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilowatt
+            Luminosity.FromGigawatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromKilowatts(UnitsNet.QuantityValue)" />
         public static Luminosity Kilowatts<T>(this T value) =>
-             Luminosity.FromKilowatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megawatt
+            Luminosity.FromKilowatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromMegawatts(UnitsNet.QuantityValue)" />
         public static Luminosity Megawatts<T>(this T value) =>
-             Luminosity.FromMegawatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microwatt
+            Luminosity.FromMegawatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromMicrowatts(UnitsNet.QuantityValue)" />
         public static Luminosity Microwatts<T>(this T value) =>
-             Luminosity.FromMicrowatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Milliwatt
+            Luminosity.FromMicrowatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromMilliwatts(UnitsNet.QuantityValue)" />
         public static Luminosity Milliwatts<T>(this T value) =>
-             Luminosity.FromMilliwatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanowatt
+            Luminosity.FromMilliwatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromNanowatts(UnitsNet.QuantityValue)" />
         public static Luminosity Nanowatts<T>(this T value) =>
-             Luminosity.FromNanowatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Petawatt
+            Luminosity.FromNanowatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromPetawatts(UnitsNet.QuantityValue)" />
         public static Luminosity Petawatts<T>(this T value) =>
-             Luminosity.FromPetawatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Picowatt
+            Luminosity.FromPetawatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromPicowatts(UnitsNet.QuantityValue)" />
         public static Luminosity Picowatts<T>(this T value) =>
-             Luminosity.FromPicowatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SolarLuminosity
+            Luminosity.FromPicowatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromSolarLuminosities(UnitsNet.QuantityValue)" />
         public static Luminosity SolarLuminosities<T>(this T value) =>
-             Luminosity.FromSolarLuminosities(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Terawatt
+            Luminosity.FromSolarLuminosities(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromTerawatts(UnitsNet.QuantityValue)" />
         public static Luminosity Terawatts<T>(this T value) =>
-             Luminosity.FromTerawatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Watt
+            Luminosity.FromTerawatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Luminosity.FromWatts(UnitsNet.QuantityValue)" />
         public static Luminosity Watts<T>(this T value) =>
-             Luminosity.FromWatts(Convert.ToDouble(value));
-
-        #endregion
+            Luminosity.FromWatts(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminousFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
similarity index 89%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminousFluxExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
index d451ee9b3a..492459e101 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminousFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToLuminousFlux
+namespace UnitsNet.NumberExtensions.NumberToLuminousFlux
 {
     /// <summary>
     /// A number to LuminousFlux Extensions
     /// </summary>
     public static class NumberToLuminousFluxExtensions
     {
-
-        #region Lumen
-
         /// <inheritdoc cref="LuminousFlux.FromLumens(UnitsNet.QuantityValue)" />
         public static LuminousFlux Lumens<T>(this T value) =>
-             LuminousFlux.FromLumens(Convert.ToDouble(value));
-
-        #endregion
+            LuminousFlux.FromLumens(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminousIntensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
similarity index 88%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminousIntensityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
index 5b649ed116..3c6acb4c8d 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToLuminousIntensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToLuminousIntensity
+namespace UnitsNet.NumberExtensions.NumberToLuminousIntensity
 {
     /// <summary>
     /// A number to LuminousIntensity Extensions
     /// </summary>
     public static class NumberToLuminousIntensityExtensions
     {
-
-        #region Candela
-
         /// <inheritdoc cref="LuminousIntensity.FromCandela(UnitsNet.QuantityValue)" />
         public static LuminousIntensity Candela<T>(this T value) =>
-             LuminousIntensity.FromCandela(Convert.ToDouble(value));
-
-        #endregion
+            LuminousIntensity.FromCandela(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagneticFieldExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
similarity index 78%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagneticFieldExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
index 329ccaff0e..768878ff7f 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagneticFieldExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
@@ -19,45 +19,28 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMagneticField
+namespace UnitsNet.NumberExtensions.NumberToMagneticField
 {
     /// <summary>
     /// A number to MagneticField Extensions
     /// </summary>
     public static class NumberToMagneticFieldExtensions
     {
-
-        #region Microtesla
-
         /// <inheritdoc cref="MagneticField.FromMicroteslas(UnitsNet.QuantityValue)" />
         public static MagneticField Microteslas<T>(this T value) =>
-             MagneticField.FromMicroteslas(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millitesla
+            MagneticField.FromMicroteslas(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MagneticField.FromMilliteslas(UnitsNet.QuantityValue)" />
         public static MagneticField Milliteslas<T>(this T value) =>
-             MagneticField.FromMilliteslas(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanotesla
+            MagneticField.FromMilliteslas(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MagneticField.FromNanoteslas(UnitsNet.QuantityValue)" />
         public static MagneticField Nanoteslas<T>(this T value) =>
-             MagneticField.FromNanoteslas(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Tesla
+            MagneticField.FromNanoteslas(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MagneticField.FromTeslas(UnitsNet.QuantityValue)" />
         public static MagneticField Teslas<T>(this T value) =>
-             MagneticField.FromTeslas(Convert.ToDouble(value));
-
-        #endregion
+            MagneticField.FromTeslas(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagneticFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
similarity index 89%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagneticFluxExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
index d6a410fa55..a3bfd6c69b 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagneticFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMagneticFlux
+namespace UnitsNet.NumberExtensions.NumberToMagneticFlux
 {
     /// <summary>
     /// A number to MagneticFlux Extensions
     /// </summary>
     public static class NumberToMagneticFluxExtensions
     {
-
-        #region Weber
-
         /// <inheritdoc cref="MagneticFlux.FromWebers(UnitsNet.QuantityValue)" />
         public static MagneticFlux Webers<T>(this T value) =>
-             MagneticFlux.FromWebers(Convert.ToDouble(value));
-
-        #endregion
+            MagneticFlux.FromWebers(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagnetizationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
similarity index 88%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagnetizationExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
index 7bff2646f5..cb51c5cf1f 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMagnetizationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMagnetization
+namespace UnitsNet.NumberExtensions.NumberToMagnetization
 {
     /// <summary>
     /// A number to Magnetization Extensions
     /// </summary>
     public static class NumberToMagnetizationExtensions
     {
-
-        #region AmperePerMeter
-
         /// <inheritdoc cref="Magnetization.FromAmperesPerMeter(UnitsNet.QuantityValue)" />
         public static Magnetization AmperesPerMeter<T>(this T value) =>
-             Magnetization.FromAmperesPerMeter(Convert.ToDouble(value));
-
-        #endregion
+            Magnetization.FromAmperesPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
similarity index 62%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassConcentrationExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
index 1904a1b535..920379b405 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassConcentrationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
@@ -19,333 +19,172 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMassConcentration
+namespace UnitsNet.NumberExtensions.NumberToMassConcentration
 {
     /// <summary>
     /// A number to MassConcentration Extensions
     /// </summary>
     public static class NumberToMassConcentrationExtensions
     {
-
-        #region CentigramPerDeciliter
-
         /// <inheritdoc cref="MassConcentration.FromCentigramsPerDeciliter(UnitsNet.QuantityValue)" />
         public static MassConcentration CentigramsPerDeciliter<T>(this T value) =>
-             MassConcentration.FromCentigramsPerDeciliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentigramPerLiter
+            MassConcentration.FromCentigramsPerDeciliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromCentigramsPerLiter(UnitsNet.QuantityValue)" />
         public static MassConcentration CentigramsPerLiter<T>(this T value) =>
-             MassConcentration.FromCentigramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentigramPerMilliliter
+            MassConcentration.FromCentigramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromCentigramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static MassConcentration CentigramsPerMilliliter<T>(this T value) =>
-             MassConcentration.FromCentigramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecigramPerDeciliter
+            MassConcentration.FromCentigramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromDecigramsPerDeciliter(UnitsNet.QuantityValue)" />
         public static MassConcentration DecigramsPerDeciliter<T>(this T value) =>
-             MassConcentration.FromDecigramsPerDeciliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecigramPerLiter
+            MassConcentration.FromDecigramsPerDeciliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromDecigramsPerLiter(UnitsNet.QuantityValue)" />
         public static MassConcentration DecigramsPerLiter<T>(this T value) =>
-             MassConcentration.FromDecigramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecigramPerMilliliter
+            MassConcentration.FromDecigramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromDecigramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static MassConcentration DecigramsPerMilliliter<T>(this T value) =>
-             MassConcentration.FromDecigramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerCubicCentimeter
+            MassConcentration.FromDecigramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromGramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
         public static MassConcentration GramsPerCubicCentimeter<T>(this T value) =>
-             MassConcentration.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerCubicMeter
+            MassConcentration.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static MassConcentration GramsPerCubicMeter<T>(this T value) =>
-             MassConcentration.FromGramsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerCubicMillimeter
+            MassConcentration.FromGramsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
         public static MassConcentration GramsPerCubicMillimeter<T>(this T value) =>
-             MassConcentration.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerDeciliter
+            MassConcentration.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromGramsPerDeciliter(UnitsNet.QuantityValue)" />
         public static MassConcentration GramsPerDeciliter<T>(this T value) =>
-             MassConcentration.FromGramsPerDeciliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerLiter
+            MassConcentration.FromGramsPerDeciliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromGramsPerLiter(UnitsNet.QuantityValue)" />
         public static MassConcentration GramsPerLiter<T>(this T value) =>
-             MassConcentration.FromGramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerMilliliter
+            MassConcentration.FromGramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromGramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static MassConcentration GramsPerMilliliter<T>(this T value) =>
-             MassConcentration.FromGramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerCubicCentimeter
+            MassConcentration.FromGramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
         public static MassConcentration KilogramsPerCubicCentimeter<T>(this T value) =>
-             MassConcentration.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerCubicMeter
+            MassConcentration.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static MassConcentration KilogramsPerCubicMeter<T>(this T value) =>
-             MassConcentration.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerCubicMillimeter
+            MassConcentration.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
         public static MassConcentration KilogramsPerCubicMillimeter<T>(this T value) =>
-             MassConcentration.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerLiter
+            MassConcentration.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromKilogramsPerLiter(UnitsNet.QuantityValue)" />
         public static MassConcentration KilogramsPerLiter<T>(this T value) =>
-             MassConcentration.FromKilogramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundPerCubicFoot
+            MassConcentration.FromKilogramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static MassConcentration KilopoundsPerCubicFoot<T>(this T value) =>
-             MassConcentration.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundPerCubicInch
+            MassConcentration.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicInch(UnitsNet.QuantityValue)" />
         public static MassConcentration KilopoundsPerCubicInch<T>(this T value) =>
-             MassConcentration.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerCubicMeter
+            MassConcentration.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromMicrogramsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static MassConcentration MicrogramsPerCubicMeter<T>(this T value) =>
-             MassConcentration.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerDeciliter
+            MassConcentration.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromMicrogramsPerDeciliter(UnitsNet.QuantityValue)" />
         public static MassConcentration MicrogramsPerDeciliter<T>(this T value) =>
-             MassConcentration.FromMicrogramsPerDeciliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerLiter
+            MassConcentration.FromMicrogramsPerDeciliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromMicrogramsPerLiter(UnitsNet.QuantityValue)" />
         public static MassConcentration MicrogramsPerLiter<T>(this T value) =>
-             MassConcentration.FromMicrogramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerMilliliter
+            MassConcentration.FromMicrogramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static MassConcentration MicrogramsPerMilliliter<T>(this T value) =>
-             MassConcentration.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerCubicMeter
+            MassConcentration.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromMilligramsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static MassConcentration MilligramsPerCubicMeter<T>(this T value) =>
-             MassConcentration.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerDeciliter
+            MassConcentration.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromMilligramsPerDeciliter(UnitsNet.QuantityValue)" />
         public static MassConcentration MilligramsPerDeciliter<T>(this T value) =>
-             MassConcentration.FromMilligramsPerDeciliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerLiter
+            MassConcentration.FromMilligramsPerDeciliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromMilligramsPerLiter(UnitsNet.QuantityValue)" />
         public static MassConcentration MilligramsPerLiter<T>(this T value) =>
-             MassConcentration.FromMilligramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerMilliliter
+            MassConcentration.FromMilligramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromMilligramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static MassConcentration MilligramsPerMilliliter<T>(this T value) =>
-             MassConcentration.FromMilligramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanogramPerDeciliter
+            MassConcentration.FromMilligramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromNanogramsPerDeciliter(UnitsNet.QuantityValue)" />
         public static MassConcentration NanogramsPerDeciliter<T>(this T value) =>
-             MassConcentration.FromNanogramsPerDeciliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanogramPerLiter
+            MassConcentration.FromNanogramsPerDeciliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromNanogramsPerLiter(UnitsNet.QuantityValue)" />
         public static MassConcentration NanogramsPerLiter<T>(this T value) =>
-             MassConcentration.FromNanogramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanogramPerMilliliter
+            MassConcentration.FromNanogramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromNanogramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static MassConcentration NanogramsPerMilliliter<T>(this T value) =>
-             MassConcentration.FromNanogramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicogramPerDeciliter
+            MassConcentration.FromNanogramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromPicogramsPerDeciliter(UnitsNet.QuantityValue)" />
         public static MassConcentration PicogramsPerDeciliter<T>(this T value) =>
-             MassConcentration.FromPicogramsPerDeciliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicogramPerLiter
+            MassConcentration.FromPicogramsPerDeciliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromPicogramsPerLiter(UnitsNet.QuantityValue)" />
         public static MassConcentration PicogramsPerLiter<T>(this T value) =>
-             MassConcentration.FromPicogramsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicogramPerMilliliter
+            MassConcentration.FromPicogramsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromPicogramsPerMilliliter(UnitsNet.QuantityValue)" />
         public static MassConcentration PicogramsPerMilliliter<T>(this T value) =>
-             MassConcentration.FromPicogramsPerMilliliter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerCubicFoot
+            MassConcentration.FromPicogramsPerMilliliter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static MassConcentration PoundsPerCubicFoot<T>(this T value) =>
-             MassConcentration.FromPoundsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerCubicInch
+            MassConcentration.FromPoundsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicInch(UnitsNet.QuantityValue)" />
         public static MassConcentration PoundsPerCubicInch<T>(this T value) =>
-             MassConcentration.FromPoundsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerImperialGallon
+            MassConcentration.FromPoundsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromPoundsPerImperialGallon(UnitsNet.QuantityValue)" />
         public static MassConcentration PoundsPerImperialGallon<T>(this T value) =>
-             MassConcentration.FromPoundsPerImperialGallon(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerUSGallon
+            MassConcentration.FromPoundsPerImperialGallon(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromPoundsPerUSGallon(UnitsNet.QuantityValue)" />
         public static MassConcentration PoundsPerUSGallon<T>(this T value) =>
-             MassConcentration.FromPoundsPerUSGallon(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SlugPerCubicFoot
+            MassConcentration.FromPoundsPerUSGallon(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromSlugsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static MassConcentration SlugsPerCubicFoot<T>(this T value) =>
-             MassConcentration.FromSlugsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonnePerCubicCentimeter
+            MassConcentration.FromSlugsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicCentimeter(UnitsNet.QuantityValue)" />
         public static MassConcentration TonnesPerCubicCentimeter<T>(this T value) =>
-             MassConcentration.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonnePerCubicMeter
+            MassConcentration.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMeter(UnitsNet.QuantityValue)" />
         public static MassConcentration TonnesPerCubicMeter<T>(this T value) =>
-             MassConcentration.FromTonnesPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonnePerCubicMillimeter
+            MassConcentration.FromTonnesPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMillimeter(UnitsNet.QuantityValue)" />
         public static MassConcentration TonnesPerCubicMillimeter<T>(this T value) =>
-             MassConcentration.FromTonnesPerCubicMillimeter(Convert.ToDouble(value));
-
-        #endregion
+            MassConcentration.FromTonnesPerCubicMillimeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
similarity index 63%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
index 4fe792ca1f..680a6d7ff6 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
@@ -19,213 +19,112 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMass
+namespace UnitsNet.NumberExtensions.NumberToMass
 {
     /// <summary>
     /// A number to Mass Extensions
     /// </summary>
     public static class NumberToMassExtensions
     {
-
-        #region Centigram
-
         /// <inheritdoc cref="Mass.FromCentigrams(UnitsNet.QuantityValue)" />
         public static Mass Centigrams<T>(this T value) =>
-             Mass.FromCentigrams(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Decagram
+            Mass.FromCentigrams(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromDecagrams(UnitsNet.QuantityValue)" />
         public static Mass Decagrams<T>(this T value) =>
-             Mass.FromDecagrams(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Decigram
+            Mass.FromDecagrams(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromDecigrams(UnitsNet.QuantityValue)" />
         public static Mass Decigrams<T>(this T value) =>
-             Mass.FromDecigrams(Convert.ToDouble(value));
-
-        #endregion
-
-        #region EarthMass
+            Mass.FromDecigrams(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromEarthMasses(UnitsNet.QuantityValue)" />
         public static Mass EarthMasses<T>(this T value) =>
-             Mass.FromEarthMasses(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Grain
+            Mass.FromEarthMasses(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromGrains(UnitsNet.QuantityValue)" />
         public static Mass Grains<T>(this T value) =>
-             Mass.FromGrains(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Gram
+            Mass.FromGrains(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromGrams(UnitsNet.QuantityValue)" />
         public static Mass Grams<T>(this T value) =>
-             Mass.FromGrams(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Hectogram
+            Mass.FromGrams(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromHectograms(UnitsNet.QuantityValue)" />
         public static Mass Hectograms<T>(this T value) =>
-             Mass.FromHectograms(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilogram
+            Mass.FromHectograms(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromKilograms(UnitsNet.QuantityValue)" />
         public static Mass Kilograms<T>(this T value) =>
-             Mass.FromKilograms(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilopound
+            Mass.FromKilograms(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromKilopounds(UnitsNet.QuantityValue)" />
         public static Mass Kilopounds<T>(this T value) =>
-             Mass.FromKilopounds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilotonne
+            Mass.FromKilopounds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromKilotonnes(UnitsNet.QuantityValue)" />
         public static Mass Kilotonnes<T>(this T value) =>
-             Mass.FromKilotonnes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region LongHundredweight
+            Mass.FromKilotonnes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromLongHundredweight(UnitsNet.QuantityValue)" />
         public static Mass LongHundredweight<T>(this T value) =>
-             Mass.FromLongHundredweight(Convert.ToDouble(value));
-
-        #endregion
-
-        #region LongTon
+            Mass.FromLongHundredweight(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromLongTons(UnitsNet.QuantityValue)" />
         public static Mass LongTons<T>(this T value) =>
-             Mass.FromLongTons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megapound
+            Mass.FromLongTons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromMegapounds(UnitsNet.QuantityValue)" />
         public static Mass Megapounds<T>(this T value) =>
-             Mass.FromMegapounds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megatonne
+            Mass.FromMegapounds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromMegatonnes(UnitsNet.QuantityValue)" />
         public static Mass Megatonnes<T>(this T value) =>
-             Mass.FromMegatonnes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microgram
+            Mass.FromMegatonnes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromMicrograms(UnitsNet.QuantityValue)" />
         public static Mass Micrograms<T>(this T value) =>
-             Mass.FromMicrograms(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Milligram
+            Mass.FromMicrograms(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromMilligrams(UnitsNet.QuantityValue)" />
         public static Mass Milligrams<T>(this T value) =>
-             Mass.FromMilligrams(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanogram
+            Mass.FromMilligrams(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromNanograms(UnitsNet.QuantityValue)" />
         public static Mass Nanograms<T>(this T value) =>
-             Mass.FromNanograms(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Ounce
+            Mass.FromNanograms(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromOunces(UnitsNet.QuantityValue)" />
         public static Mass Ounces<T>(this T value) =>
-             Mass.FromOunces(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Pound
+            Mass.FromOunces(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromPounds(UnitsNet.QuantityValue)" />
         public static Mass Pounds<T>(this T value) =>
-             Mass.FromPounds(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ShortHundredweight
+            Mass.FromPounds(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromShortHundredweight(UnitsNet.QuantityValue)" />
         public static Mass ShortHundredweight<T>(this T value) =>
-             Mass.FromShortHundredweight(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ShortTon
+            Mass.FromShortHundredweight(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromShortTons(UnitsNet.QuantityValue)" />
         public static Mass ShortTons<T>(this T value) =>
-             Mass.FromShortTons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Slug
+            Mass.FromShortTons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromSlugs(UnitsNet.QuantityValue)" />
         public static Mass Slugs<T>(this T value) =>
-             Mass.FromSlugs(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SolarMass
+            Mass.FromSlugs(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromSolarMasses(UnitsNet.QuantityValue)" />
         public static Mass SolarMasses<T>(this T value) =>
-             Mass.FromSolarMasses(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Stone
+            Mass.FromSolarMasses(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromStone(UnitsNet.QuantityValue)" />
         public static Mass Stone<T>(this T value) =>
-             Mass.FromStone(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Tonne
+            Mass.FromStone(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Mass.FromTonnes(UnitsNet.QuantityValue)" />
         public static Mass Tonnes<T>(this T value) =>
-             Mass.FromTonnes(Convert.ToDouble(value));
-
-        #endregion
+            Mass.FromTonnes(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
similarity index 61%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFlowExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
index a3fe413a95..61b1857656 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
@@ -19,277 +19,144 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMassFlow
+namespace UnitsNet.NumberExtensions.NumberToMassFlow
 {
     /// <summary>
     /// A number to MassFlow Extensions
     /// </summary>
     public static class NumberToMassFlowExtensions
     {
-
-        #region CentigramPerDay
-
         /// <inheritdoc cref="MassFlow.FromCentigramsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow CentigramsPerDay<T>(this T value) =>
-             MassFlow.FromCentigramsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentigramPerSecond
+            MassFlow.FromCentigramsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromCentigramsPerSecond(UnitsNet.QuantityValue)" />
         public static MassFlow CentigramsPerSecond<T>(this T value) =>
-             MassFlow.FromCentigramsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecagramPerDay
+            MassFlow.FromCentigramsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromDecagramsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow DecagramsPerDay<T>(this T value) =>
-             MassFlow.FromDecagramsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecagramPerSecond
+            MassFlow.FromDecagramsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromDecagramsPerSecond(UnitsNet.QuantityValue)" />
         public static MassFlow DecagramsPerSecond<T>(this T value) =>
-             MassFlow.FromDecagramsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecigramPerDay
+            MassFlow.FromDecagramsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromDecigramsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow DecigramsPerDay<T>(this T value) =>
-             MassFlow.FromDecigramsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecigramPerSecond
+            MassFlow.FromDecigramsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromDecigramsPerSecond(UnitsNet.QuantityValue)" />
         public static MassFlow DecigramsPerSecond<T>(this T value) =>
-             MassFlow.FromDecigramsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerDay
+            MassFlow.FromDecigramsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromGramsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow GramsPerDay<T>(this T value) =>
-             MassFlow.FromGramsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerHour
+            MassFlow.FromGramsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromGramsPerHour(UnitsNet.QuantityValue)" />
         public static MassFlow GramsPerHour<T>(this T value) =>
-             MassFlow.FromGramsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerSecond
+            MassFlow.FromGramsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromGramsPerSecond(UnitsNet.QuantityValue)" />
         public static MassFlow GramsPerSecond<T>(this T value) =>
-             MassFlow.FromGramsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region HectogramPerDay
+            MassFlow.FromGramsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromHectogramsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow HectogramsPerDay<T>(this T value) =>
-             MassFlow.FromHectogramsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region HectogramPerSecond
+            MassFlow.FromHectogramsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromHectogramsPerSecond(UnitsNet.QuantityValue)" />
         public static MassFlow HectogramsPerSecond<T>(this T value) =>
-             MassFlow.FromHectogramsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerDay
+            MassFlow.FromHectogramsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromKilogramsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow KilogramsPerDay<T>(this T value) =>
-             MassFlow.FromKilogramsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerHour
+            MassFlow.FromKilogramsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromKilogramsPerHour(UnitsNet.QuantityValue)" />
         public static MassFlow KilogramsPerHour<T>(this T value) =>
-             MassFlow.FromKilogramsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerMinute
+            MassFlow.FromKilogramsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromKilogramsPerMinute(UnitsNet.QuantityValue)" />
         public static MassFlow KilogramsPerMinute<T>(this T value) =>
-             MassFlow.FromKilogramsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerSecond
+            MassFlow.FromKilogramsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromKilogramsPerSecond(UnitsNet.QuantityValue)" />
         public static MassFlow KilogramsPerSecond<T>(this T value) =>
-             MassFlow.FromKilogramsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegagramPerDay
+            MassFlow.FromKilogramsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromMegagramsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow MegagramsPerDay<T>(this T value) =>
-             MassFlow.FromMegagramsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegapoundPerDay
+            MassFlow.FromMegagramsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromMegapoundsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow MegapoundsPerDay<T>(this T value) =>
-             MassFlow.FromMegapoundsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegapoundPerHour
+            MassFlow.FromMegapoundsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromMegapoundsPerHour(UnitsNet.QuantityValue)" />
         public static MassFlow MegapoundsPerHour<T>(this T value) =>
-             MassFlow.FromMegapoundsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegapoundPerMinute
+            MassFlow.FromMegapoundsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromMegapoundsPerMinute(UnitsNet.QuantityValue)" />
         public static MassFlow MegapoundsPerMinute<T>(this T value) =>
-             MassFlow.FromMegapoundsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegapoundPerSecond
+            MassFlow.FromMegapoundsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromMegapoundsPerSecond(UnitsNet.QuantityValue)" />
         public static MassFlow MegapoundsPerSecond<T>(this T value) =>
-             MassFlow.FromMegapoundsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerDay
+            MassFlow.FromMegapoundsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromMicrogramsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow MicrogramsPerDay<T>(this T value) =>
-             MassFlow.FromMicrogramsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerSecond
+            MassFlow.FromMicrogramsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromMicrogramsPerSecond(UnitsNet.QuantityValue)" />
         public static MassFlow MicrogramsPerSecond<T>(this T value) =>
-             MassFlow.FromMicrogramsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerDay
+            MassFlow.FromMicrogramsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromMilligramsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow MilligramsPerDay<T>(this T value) =>
-             MassFlow.FromMilligramsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerSecond
+            MassFlow.FromMilligramsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromMilligramsPerSecond(UnitsNet.QuantityValue)" />
         public static MassFlow MilligramsPerSecond<T>(this T value) =>
-             MassFlow.FromMilligramsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanogramPerDay
+            MassFlow.FromMilligramsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromNanogramsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow NanogramsPerDay<T>(this T value) =>
-             MassFlow.FromNanogramsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanogramPerSecond
+            MassFlow.FromNanogramsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromNanogramsPerSecond(UnitsNet.QuantityValue)" />
         public static MassFlow NanogramsPerSecond<T>(this T value) =>
-             MassFlow.FromNanogramsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerDay
+            MassFlow.FromNanogramsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromPoundsPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow PoundsPerDay<T>(this T value) =>
-             MassFlow.FromPoundsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerHour
+            MassFlow.FromPoundsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromPoundsPerHour(UnitsNet.QuantityValue)" />
         public static MassFlow PoundsPerHour<T>(this T value) =>
-             MassFlow.FromPoundsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerMinute
+            MassFlow.FromPoundsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromPoundsPerMinute(UnitsNet.QuantityValue)" />
         public static MassFlow PoundsPerMinute<T>(this T value) =>
-             MassFlow.FromPoundsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerSecond
+            MassFlow.FromPoundsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromPoundsPerSecond(UnitsNet.QuantityValue)" />
         public static MassFlow PoundsPerSecond<T>(this T value) =>
-             MassFlow.FromPoundsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ShortTonPerHour
+            MassFlow.FromPoundsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromShortTonsPerHour(UnitsNet.QuantityValue)" />
         public static MassFlow ShortTonsPerHour<T>(this T value) =>
-             MassFlow.FromShortTonsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonnePerDay
+            MassFlow.FromShortTonsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromTonnesPerDay(UnitsNet.QuantityValue)" />
         public static MassFlow TonnesPerDay<T>(this T value) =>
-             MassFlow.FromTonnesPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonnePerHour
+            MassFlow.FromTonnesPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlow.FromTonnesPerHour(UnitsNet.QuantityValue)" />
         public static MassFlow TonnesPerHour<T>(this T value) =>
-             MassFlow.FromTonnesPerHour(Convert.ToDouble(value));
-
-        #endregion
+            MassFlow.FromTonnesPerHour(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
similarity index 81%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFluxExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
index 96a1713ab6..73d36eb37b 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
@@ -19,29 +19,20 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMassFlux
+namespace UnitsNet.NumberExtensions.NumberToMassFlux
 {
     /// <summary>
     /// A number to MassFlux Extensions
     /// </summary>
     public static class NumberToMassFluxExtensions
     {
-
-        #region GramPerSecondPerSquareMeter
-
         /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMeter(UnitsNet.QuantityValue)" />
         public static MassFlux GramsPerSecondPerSquareMeter<T>(this T value) =>
-             MassFlux.FromGramsPerSecondPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerSecondPerSquareMeter
+            MassFlux.FromGramsPerSecondPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMeter(UnitsNet.QuantityValue)" />
         public static MassFlux KilogramsPerSecondPerSquareMeter<T>(this T value) =>
-             MassFlux.FromKilogramsPerSecondPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
+            MassFlux.FromKilogramsPerSecondPerSquareMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFractionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
similarity index 63%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFractionExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
index 1d84b87eac..fb89ba9059 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassFractionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
@@ -19,205 +19,108 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMassFraction
+namespace UnitsNet.NumberExtensions.NumberToMassFraction
 {
     /// <summary>
     /// A number to MassFraction Extensions
     /// </summary>
     public static class NumberToMassFractionExtensions
     {
-
-        #region CentigramPerGram
-
         /// <inheritdoc cref="MassFraction.FromCentigramsPerGram(UnitsNet.QuantityValue)" />
         public static MassFraction CentigramsPerGram<T>(this T value) =>
-             MassFraction.FromCentigramsPerGram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentigramPerKilogram
+            MassFraction.FromCentigramsPerGram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromCentigramsPerKilogram(UnitsNet.QuantityValue)" />
         public static MassFraction CentigramsPerKilogram<T>(this T value) =>
-             MassFraction.FromCentigramsPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecagramPerGram
+            MassFraction.FromCentigramsPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromDecagramsPerGram(UnitsNet.QuantityValue)" />
         public static MassFraction DecagramsPerGram<T>(this T value) =>
-             MassFraction.FromDecagramsPerGram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecagramPerKilogram
+            MassFraction.FromDecagramsPerGram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromDecagramsPerKilogram(UnitsNet.QuantityValue)" />
         public static MassFraction DecagramsPerKilogram<T>(this T value) =>
-             MassFraction.FromDecagramsPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecigramPerGram
+            MassFraction.FromDecagramsPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromDecigramsPerGram(UnitsNet.QuantityValue)" />
         public static MassFraction DecigramsPerGram<T>(this T value) =>
-             MassFraction.FromDecigramsPerGram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecigramPerKilogram
+            MassFraction.FromDecigramsPerGram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromDecigramsPerKilogram(UnitsNet.QuantityValue)" />
         public static MassFraction DecigramsPerKilogram<T>(this T value) =>
-             MassFraction.FromDecigramsPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecimalFraction
+            MassFraction.FromDecigramsPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromDecimalFractions(UnitsNet.QuantityValue)" />
         public static MassFraction DecimalFractions<T>(this T value) =>
-             MassFraction.FromDecimalFractions(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerGram
+            MassFraction.FromDecimalFractions(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromGramsPerGram(UnitsNet.QuantityValue)" />
         public static MassFraction GramsPerGram<T>(this T value) =>
-             MassFraction.FromGramsPerGram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerKilogram
+            MassFraction.FromGramsPerGram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromGramsPerKilogram(UnitsNet.QuantityValue)" />
         public static MassFraction GramsPerKilogram<T>(this T value) =>
-             MassFraction.FromGramsPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region HectogramPerGram
+            MassFraction.FromGramsPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromHectogramsPerGram(UnitsNet.QuantityValue)" />
         public static MassFraction HectogramsPerGram<T>(this T value) =>
-             MassFraction.FromHectogramsPerGram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region HectogramPerKilogram
+            MassFraction.FromHectogramsPerGram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromHectogramsPerKilogram(UnitsNet.QuantityValue)" />
         public static MassFraction HectogramsPerKilogram<T>(this T value) =>
-             MassFraction.FromHectogramsPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerGram
+            MassFraction.FromHectogramsPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromKilogramsPerGram(UnitsNet.QuantityValue)" />
         public static MassFraction KilogramsPerGram<T>(this T value) =>
-             MassFraction.FromKilogramsPerGram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerKilogram
+            MassFraction.FromKilogramsPerGram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromKilogramsPerKilogram(UnitsNet.QuantityValue)" />
         public static MassFraction KilogramsPerKilogram<T>(this T value) =>
-             MassFraction.FromKilogramsPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerGram
+            MassFraction.FromKilogramsPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromMicrogramsPerGram(UnitsNet.QuantityValue)" />
         public static MassFraction MicrogramsPerGram<T>(this T value) =>
-             MassFraction.FromMicrogramsPerGram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerKilogram
+            MassFraction.FromMicrogramsPerGram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromMicrogramsPerKilogram(UnitsNet.QuantityValue)" />
         public static MassFraction MicrogramsPerKilogram<T>(this T value) =>
-             MassFraction.FromMicrogramsPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerGram
+            MassFraction.FromMicrogramsPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromMilligramsPerGram(UnitsNet.QuantityValue)" />
         public static MassFraction MilligramsPerGram<T>(this T value) =>
-             MassFraction.FromMilligramsPerGram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerKilogram
+            MassFraction.FromMilligramsPerGram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromMilligramsPerKilogram(UnitsNet.QuantityValue)" />
         public static MassFraction MilligramsPerKilogram<T>(this T value) =>
-             MassFraction.FromMilligramsPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanogramPerGram
+            MassFraction.FromMilligramsPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromNanogramsPerGram(UnitsNet.QuantityValue)" />
         public static MassFraction NanogramsPerGram<T>(this T value) =>
-             MassFraction.FromNanogramsPerGram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanogramPerKilogram
+            MassFraction.FromNanogramsPerGram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromNanogramsPerKilogram(UnitsNet.QuantityValue)" />
         public static MassFraction NanogramsPerKilogram<T>(this T value) =>
-             MassFraction.FromNanogramsPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerBillion
+            MassFraction.FromNanogramsPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromPartsPerBillion(UnitsNet.QuantityValue)" />
         public static MassFraction PartsPerBillion<T>(this T value) =>
-             MassFraction.FromPartsPerBillion(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerMillion
+            MassFraction.FromPartsPerBillion(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromPartsPerMillion(UnitsNet.QuantityValue)" />
         public static MassFraction PartsPerMillion<T>(this T value) =>
-             MassFraction.FromPartsPerMillion(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerThousand
+            MassFraction.FromPartsPerMillion(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromPartsPerThousand(UnitsNet.QuantityValue)" />
         public static MassFraction PartsPerThousand<T>(this T value) =>
-             MassFraction.FromPartsPerThousand(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerTrillion
+            MassFraction.FromPartsPerThousand(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
         public static MassFraction PartsPerTrillion<T>(this T value) =>
-             MassFraction.FromPartsPerTrillion(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Percent
+            MassFraction.FromPartsPerTrillion(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassFraction.FromPercent(UnitsNet.QuantityValue)" />
         public static MassFraction Percent<T>(this T value) =>
-             MassFraction.FromPercent(Convert.ToDouble(value));
-
-        #endregion
+            MassFraction.FromPercent(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
similarity index 63%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassMomentOfInertiaExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
index 9f1d8a614c..2dd0759b0b 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMassMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
@@ -19,237 +19,124 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMassMomentOfInertia
+namespace UnitsNet.NumberExtensions.NumberToMassMomentOfInertia
 {
     /// <summary>
     /// A number to MassMomentOfInertia Extensions
     /// </summary>
     public static class NumberToMassMomentOfInertiaExtensions
     {
-
-        #region GramSquareCentimeter
-
         /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareCentimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia GramSquareCentimeters<T>(this T value) =>
-             MassMomentOfInertia.FromGramSquareCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramSquareDecimeter
+            MassMomentOfInertia.FromGramSquareCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareDecimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia GramSquareDecimeters<T>(this T value) =>
-             MassMomentOfInertia.FromGramSquareDecimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramSquareMeter
+            MassMomentOfInertia.FromGramSquareDecimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia GramSquareMeters<T>(this T value) =>
-             MassMomentOfInertia.FromGramSquareMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramSquareMillimeter
+            MassMomentOfInertia.FromGramSquareMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMillimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia GramSquareMillimeters<T>(this T value) =>
-             MassMomentOfInertia.FromGramSquareMillimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramSquareCentimeter
+            MassMomentOfInertia.FromGramSquareMillimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareCentimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia KilogramSquareCentimeters<T>(this T value) =>
-             MassMomentOfInertia.FromKilogramSquareCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramSquareDecimeter
+            MassMomentOfInertia.FromKilogramSquareCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareDecimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia KilogramSquareDecimeters<T>(this T value) =>
-             MassMomentOfInertia.FromKilogramSquareDecimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramSquareMeter
+            MassMomentOfInertia.FromKilogramSquareDecimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia KilogramSquareMeters<T>(this T value) =>
-             MassMomentOfInertia.FromKilogramSquareMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramSquareMillimeter
+            MassMomentOfInertia.FromKilogramSquareMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMillimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia KilogramSquareMillimeters<T>(this T value) =>
-             MassMomentOfInertia.FromKilogramSquareMillimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilotonneSquareCentimeter
+            MassMomentOfInertia.FromKilogramSquareMillimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareCentimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia KilotonneSquareCentimeters<T>(this T value) =>
-             MassMomentOfInertia.FromKilotonneSquareCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilotonneSquareDecimeter
+            MassMomentOfInertia.FromKilotonneSquareCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareDecimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia KilotonneSquareDecimeters<T>(this T value) =>
-             MassMomentOfInertia.FromKilotonneSquareDecimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilotonneSquareMeter
+            MassMomentOfInertia.FromKilotonneSquareDecimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia KilotonneSquareMeters<T>(this T value) =>
-             MassMomentOfInertia.FromKilotonneSquareMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilotonneSquareMilimeter
+            MassMomentOfInertia.FromKilotonneSquareMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMilimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia KilotonneSquareMilimeters<T>(this T value) =>
-             MassMomentOfInertia.FromKilotonneSquareMilimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegatonneSquareCentimeter
+            MassMomentOfInertia.FromKilotonneSquareMilimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareCentimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia MegatonneSquareCentimeters<T>(this T value) =>
-             MassMomentOfInertia.FromMegatonneSquareCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegatonneSquareDecimeter
+            MassMomentOfInertia.FromMegatonneSquareCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareDecimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia MegatonneSquareDecimeters<T>(this T value) =>
-             MassMomentOfInertia.FromMegatonneSquareDecimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegatonneSquareMeter
+            MassMomentOfInertia.FromMegatonneSquareDecimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia MegatonneSquareMeters<T>(this T value) =>
-             MassMomentOfInertia.FromMegatonneSquareMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegatonneSquareMilimeter
+            MassMomentOfInertia.FromMegatonneSquareMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMilimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia MegatonneSquareMilimeters<T>(this T value) =>
-             MassMomentOfInertia.FromMegatonneSquareMilimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramSquareCentimeter
+            MassMomentOfInertia.FromMegatonneSquareMilimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareCentimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia MilligramSquareCentimeters<T>(this T value) =>
-             MassMomentOfInertia.FromMilligramSquareCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramSquareDecimeter
+            MassMomentOfInertia.FromMilligramSquareCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareDecimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia MilligramSquareDecimeters<T>(this T value) =>
-             MassMomentOfInertia.FromMilligramSquareDecimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramSquareMeter
+            MassMomentOfInertia.FromMilligramSquareDecimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia MilligramSquareMeters<T>(this T value) =>
-             MassMomentOfInertia.FromMilligramSquareMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramSquareMillimeter
+            MassMomentOfInertia.FromMilligramSquareMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMillimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia MilligramSquareMillimeters<T>(this T value) =>
-             MassMomentOfInertia.FromMilligramSquareMillimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundSquareFoot
+            MassMomentOfInertia.FromMilligramSquareMillimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareFeet(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia PoundSquareFeet<T>(this T value) =>
-             MassMomentOfInertia.FromPoundSquareFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundSquareInch
+            MassMomentOfInertia.FromPoundSquareFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareInches(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia PoundSquareInches<T>(this T value) =>
-             MassMomentOfInertia.FromPoundSquareInches(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SlugSquareFoot
+            MassMomentOfInertia.FromPoundSquareInches(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareFeet(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia SlugSquareFeet<T>(this T value) =>
-             MassMomentOfInertia.FromSlugSquareFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SlugSquareInch
+            MassMomentOfInertia.FromSlugSquareFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareInches(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia SlugSquareInches<T>(this T value) =>
-             MassMomentOfInertia.FromSlugSquareInches(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneSquareCentimeter
+            MassMomentOfInertia.FromSlugSquareInches(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareCentimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia TonneSquareCentimeters<T>(this T value) =>
-             MassMomentOfInertia.FromTonneSquareCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneSquareDecimeter
+            MassMomentOfInertia.FromTonneSquareCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareDecimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia TonneSquareDecimeters<T>(this T value) =>
-             MassMomentOfInertia.FromTonneSquareDecimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneSquareMeter
+            MassMomentOfInertia.FromTonneSquareDecimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia TonneSquareMeters<T>(this T value) =>
-             MassMomentOfInertia.FromTonneSquareMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneSquareMilimeter
+            MassMomentOfInertia.FromTonneSquareMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMilimeters(UnitsNet.QuantityValue)" />
         public static MassMomentOfInertia TonneSquareMilimeters<T>(this T value) =>
-             MassMomentOfInertia.FromTonneSquareMilimeters(Convert.ToDouble(value));
-
-        #endregion
+            MassMomentOfInertia.FromTonneSquareMilimeters(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
similarity index 79%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarEnergyExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
index 5b23d135ce..669725a242 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMolarEnergy
+namespace UnitsNet.NumberExtensions.NumberToMolarEnergy
 {
     /// <summary>
     /// A number to MolarEnergy Extensions
     /// </summary>
     public static class NumberToMolarEnergyExtensions
     {
-
-        #region JoulePerMole
-
         /// <inheritdoc cref="MolarEnergy.FromJoulesPerMole(UnitsNet.QuantityValue)" />
         public static MolarEnergy JoulesPerMole<T>(this T value) =>
-             MolarEnergy.FromJoulesPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilojoulePerMole
+            MolarEnergy.FromJoulesPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarEnergy.FromKilojoulesPerMole(UnitsNet.QuantityValue)" />
         public static MolarEnergy KilojoulesPerMole<T>(this T value) =>
-             MolarEnergy.FromKilojoulesPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegajoulePerMole
+            MolarEnergy.FromKilojoulesPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarEnergy.FromMegajoulesPerMole(UnitsNet.QuantityValue)" />
         public static MolarEnergy MegajoulesPerMole<T>(this T value) =>
-             MolarEnergy.FromMegajoulesPerMole(Convert.ToDouble(value));
-
-        #endregion
+            MolarEnergy.FromMegajoulesPerMole(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
similarity index 78%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarEntropyExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
index 2af90d96ee..35809d8b5c 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMolarEntropy
+namespace UnitsNet.NumberExtensions.NumberToMolarEntropy
 {
     /// <summary>
     /// A number to MolarEntropy Extensions
     /// </summary>
     public static class NumberToMolarEntropyExtensions
     {
-
-        #region JoulePerMoleKelvin
-
         /// <inheritdoc cref="MolarEntropy.FromJoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
         public static MolarEntropy JoulesPerMoleKelvin<T>(this T value) =>
-             MolarEntropy.FromJoulesPerMoleKelvin(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilojoulePerMoleKelvin
+            MolarEntropy.FromJoulesPerMoleKelvin(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarEntropy.FromKilojoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
         public static MolarEntropy KilojoulesPerMoleKelvin<T>(this T value) =>
-             MolarEntropy.FromKilojoulesPerMoleKelvin(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegajoulePerMoleKelvin
+            MolarEntropy.FromKilojoulesPerMoleKelvin(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarEntropy.FromMegajoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
         public static MolarEntropy MegajoulesPerMoleKelvin<T>(this T value) =>
-             MolarEntropy.FromMegajoulesPerMoleKelvin(Convert.ToDouble(value));
-
-        #endregion
+            MolarEntropy.FromMegajoulesPerMoleKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarMassExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
similarity index 67%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarMassExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
index 0ff8fa5865..9ddf9cd59d 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarMassExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
@@ -19,109 +19,60 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMolarMass
+namespace UnitsNet.NumberExtensions.NumberToMolarMass
 {
     /// <summary>
     /// A number to MolarMass Extensions
     /// </summary>
     public static class NumberToMolarMassExtensions
     {
-
-        #region CentigramPerMole
-
         /// <inheritdoc cref="MolarMass.FromCentigramsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass CentigramsPerMole<T>(this T value) =>
-             MolarMass.FromCentigramsPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecagramPerMole
+            MolarMass.FromCentigramsPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarMass.FromDecagramsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass DecagramsPerMole<T>(this T value) =>
-             MolarMass.FromDecagramsPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecigramPerMole
+            MolarMass.FromDecagramsPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarMass.FromDecigramsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass DecigramsPerMole<T>(this T value) =>
-             MolarMass.FromDecigramsPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GramPerMole
+            MolarMass.FromDecigramsPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarMass.FromGramsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass GramsPerMole<T>(this T value) =>
-             MolarMass.FromGramsPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region HectogramPerMole
+            MolarMass.FromGramsPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarMass.FromHectogramsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass HectogramsPerMole<T>(this T value) =>
-             MolarMass.FromHectogramsPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramPerMole
+            MolarMass.FromHectogramsPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarMass.FromKilogramsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass KilogramsPerMole<T>(this T value) =>
-             MolarMass.FromKilogramsPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundPerMole
+            MolarMass.FromKilogramsPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarMass.FromKilopoundsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass KilopoundsPerMole<T>(this T value) =>
-             MolarMass.FromKilopoundsPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegapoundPerMole
+            MolarMass.FromKilopoundsPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarMass.FromMegapoundsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass MegapoundsPerMole<T>(this T value) =>
-             MolarMass.FromMegapoundsPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrogramPerMole
+            MolarMass.FromMegapoundsPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarMass.FromMicrogramsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass MicrogramsPerMole<T>(this T value) =>
-             MolarMass.FromMicrogramsPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilligramPerMole
+            MolarMass.FromMicrogramsPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarMass.FromMilligramsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass MilligramsPerMole<T>(this T value) =>
-             MolarMass.FromMilligramsPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanogramPerMole
+            MolarMass.FromMilligramsPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarMass.FromNanogramsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass NanogramsPerMole<T>(this T value) =>
-             MolarMass.FromNanogramsPerMole(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerMole
+            MolarMass.FromNanogramsPerMole(Convert.ToDouble(value));
 
         /// <inheritdoc cref="MolarMass.FromPoundsPerMole(UnitsNet.QuantityValue)" />
         public static MolarMass PoundsPerMole<T>(this T value) =>
-             MolarMass.FromPoundsPerMole(Convert.ToDouble(value));
-
-        #endregion
+            MolarMass.FromPoundsPerMole(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
similarity index 70%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
index 7a6355feb9..ac5504f985 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToMolarityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
@@ -19,77 +19,44 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToMolarity
+namespace UnitsNet.NumberExtensions.NumberToMolarity
 {
     /// <summary>
     /// A number to Molarity Extensions
     /// </summary>
     public static class NumberToMolarityExtensions
     {
-
-        #region CentimolesPerLiter
-
         /// <inheritdoc cref="Molarity.FromCentimolesPerLiter(UnitsNet.QuantityValue)" />
         public static Molarity CentimolesPerLiter<T>(this T value) =>
-             Molarity.FromCentimolesPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecimolesPerLiter
+            Molarity.FromCentimolesPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Molarity.FromDecimolesPerLiter(UnitsNet.QuantityValue)" />
         public static Molarity DecimolesPerLiter<T>(this T value) =>
-             Molarity.FromDecimolesPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicromolesPerLiter
+            Molarity.FromDecimolesPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Molarity.FromMicromolesPerLiter(UnitsNet.QuantityValue)" />
         public static Molarity MicromolesPerLiter<T>(this T value) =>
-             Molarity.FromMicromolesPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillimolesPerLiter
+            Molarity.FromMicromolesPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Molarity.FromMillimolesPerLiter(UnitsNet.QuantityValue)" />
         public static Molarity MillimolesPerLiter<T>(this T value) =>
-             Molarity.FromMillimolesPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MolesPerCubicMeter
+            Molarity.FromMillimolesPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Molarity.FromMolesPerCubicMeter(UnitsNet.QuantityValue)" />
         public static Molarity MolesPerCubicMeter<T>(this T value) =>
-             Molarity.FromMolesPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MolesPerLiter
+            Molarity.FromMolesPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Molarity.FromMolesPerLiter(UnitsNet.QuantityValue)" />
         public static Molarity MolesPerLiter<T>(this T value) =>
-             Molarity.FromMolesPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanomolesPerLiter
+            Molarity.FromMolesPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Molarity.FromNanomolesPerLiter(UnitsNet.QuantityValue)" />
         public static Molarity NanomolesPerLiter<T>(this T value) =>
-             Molarity.FromNanomolesPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicomolesPerLiter
+            Molarity.FromNanomolesPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Molarity.FromPicomolesPerLiter(UnitsNet.QuantityValue)" />
         public static Molarity PicomolesPerLiter<T>(this T value) =>
-             Molarity.FromPicomolesPerLiter(Convert.ToDouble(value));
-
-        #endregion
+            Molarity.FromPicomolesPerLiter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPermeabilityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
similarity index 88%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPermeabilityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
index 70a3216973..228df4a39f 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPermeabilityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToPermeability
+namespace UnitsNet.NumberExtensions.NumberToPermeability
 {
     /// <summary>
     /// A number to Permeability Extensions
     /// </summary>
     public static class NumberToPermeabilityExtensions
     {
-
-        #region HenryPerMeter
-
         /// <inheritdoc cref="Permeability.FromHenriesPerMeter(UnitsNet.QuantityValue)" />
         public static Permeability HenriesPerMeter<T>(this T value) =>
-             Permeability.FromHenriesPerMeter(Convert.ToDouble(value));
-
-        #endregion
+            Permeability.FromHenriesPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPermittivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
similarity index 88%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPermittivityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
index 2ef7046f62..25a4ed611a 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPermittivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToPermittivity
+namespace UnitsNet.NumberExtensions.NumberToPermittivity
 {
     /// <summary>
     /// A number to Permittivity Extensions
     /// </summary>
     public static class NumberToPermittivityExtensions
     {
-
-        #region FaradPerMeter
-
         /// <inheritdoc cref="Permittivity.FromFaradsPerMeter(UnitsNet.QuantityValue)" />
         public static Permittivity FaradsPerMeter<T>(this T value) =>
-             Permittivity.FromFaradsPerMeter(Convert.ToDouble(value));
-
-        #endregion
+            Permittivity.FromFaradsPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
similarity index 61%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerDensityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
index 0f6fdaa417..fb47dfc751 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
@@ -19,365 +19,188 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToPowerDensity
+namespace UnitsNet.NumberExtensions.NumberToPowerDensity
 {
     /// <summary>
     /// A number to PowerDensity Extensions
     /// </summary>
     public static class NumberToPowerDensityExtensions
     {
-
-        #region DecawattPerCubicFoot
-
         /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static PowerDensity DecawattsPerCubicFoot<T>(this T value) =>
-             PowerDensity.FromDecawattsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecawattPerCubicInch
+            PowerDensity.FromDecawattsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicInch(UnitsNet.QuantityValue)" />
         public static PowerDensity DecawattsPerCubicInch<T>(this T value) =>
-             PowerDensity.FromDecawattsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecawattPerCubicMeter
+            PowerDensity.FromDecawattsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static PowerDensity DecawattsPerCubicMeter<T>(this T value) =>
-             PowerDensity.FromDecawattsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecawattPerLiter
+            PowerDensity.FromDecawattsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromDecawattsPerLiter(UnitsNet.QuantityValue)" />
         public static PowerDensity DecawattsPerLiter<T>(this T value) =>
-             PowerDensity.FromDecawattsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DeciwattPerCubicFoot
+            PowerDensity.FromDecawattsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static PowerDensity DeciwattsPerCubicFoot<T>(this T value) =>
-             PowerDensity.FromDeciwattsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DeciwattPerCubicInch
+            PowerDensity.FromDeciwattsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicInch(UnitsNet.QuantityValue)" />
         public static PowerDensity DeciwattsPerCubicInch<T>(this T value) =>
-             PowerDensity.FromDeciwattsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DeciwattPerCubicMeter
+            PowerDensity.FromDeciwattsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static PowerDensity DeciwattsPerCubicMeter<T>(this T value) =>
-             PowerDensity.FromDeciwattsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DeciwattPerLiter
+            PowerDensity.FromDeciwattsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromDeciwattsPerLiter(UnitsNet.QuantityValue)" />
         public static PowerDensity DeciwattsPerLiter<T>(this T value) =>
-             PowerDensity.FromDeciwattsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GigawattPerCubicFoot
+            PowerDensity.FromDeciwattsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static PowerDensity GigawattsPerCubicFoot<T>(this T value) =>
-             PowerDensity.FromGigawattsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GigawattPerCubicInch
+            PowerDensity.FromGigawattsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicInch(UnitsNet.QuantityValue)" />
         public static PowerDensity GigawattsPerCubicInch<T>(this T value) =>
-             PowerDensity.FromGigawattsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GigawattPerCubicMeter
+            PowerDensity.FromGigawattsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static PowerDensity GigawattsPerCubicMeter<T>(this T value) =>
-             PowerDensity.FromGigawattsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GigawattPerLiter
+            PowerDensity.FromGigawattsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromGigawattsPerLiter(UnitsNet.QuantityValue)" />
         public static PowerDensity GigawattsPerLiter<T>(this T value) =>
-             PowerDensity.FromGigawattsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilowattPerCubicFoot
+            PowerDensity.FromGigawattsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static PowerDensity KilowattsPerCubicFoot<T>(this T value) =>
-             PowerDensity.FromKilowattsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilowattPerCubicInch
+            PowerDensity.FromKilowattsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicInch(UnitsNet.QuantityValue)" />
         public static PowerDensity KilowattsPerCubicInch<T>(this T value) =>
-             PowerDensity.FromKilowattsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilowattPerCubicMeter
+            PowerDensity.FromKilowattsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static PowerDensity KilowattsPerCubicMeter<T>(this T value) =>
-             PowerDensity.FromKilowattsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilowattPerLiter
+            PowerDensity.FromKilowattsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromKilowattsPerLiter(UnitsNet.QuantityValue)" />
         public static PowerDensity KilowattsPerLiter<T>(this T value) =>
-             PowerDensity.FromKilowattsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegawattPerCubicFoot
+            PowerDensity.FromKilowattsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static PowerDensity MegawattsPerCubicFoot<T>(this T value) =>
-             PowerDensity.FromMegawattsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegawattPerCubicInch
+            PowerDensity.FromMegawattsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicInch(UnitsNet.QuantityValue)" />
         public static PowerDensity MegawattsPerCubicInch<T>(this T value) =>
-             PowerDensity.FromMegawattsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegawattPerCubicMeter
+            PowerDensity.FromMegawattsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static PowerDensity MegawattsPerCubicMeter<T>(this T value) =>
-             PowerDensity.FromMegawattsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegawattPerLiter
+            PowerDensity.FromMegawattsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMegawattsPerLiter(UnitsNet.QuantityValue)" />
         public static PowerDensity MegawattsPerLiter<T>(this T value) =>
-             PowerDensity.FromMegawattsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrowattPerCubicFoot
+            PowerDensity.FromMegawattsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static PowerDensity MicrowattsPerCubicFoot<T>(this T value) =>
-             PowerDensity.FromMicrowattsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrowattPerCubicInch
+            PowerDensity.FromMicrowattsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicInch(UnitsNet.QuantityValue)" />
         public static PowerDensity MicrowattsPerCubicInch<T>(this T value) =>
-             PowerDensity.FromMicrowattsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrowattPerCubicMeter
+            PowerDensity.FromMicrowattsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static PowerDensity MicrowattsPerCubicMeter<T>(this T value) =>
-             PowerDensity.FromMicrowattsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrowattPerLiter
+            PowerDensity.FromMicrowattsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMicrowattsPerLiter(UnitsNet.QuantityValue)" />
         public static PowerDensity MicrowattsPerLiter<T>(this T value) =>
-             PowerDensity.FromMicrowattsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliwattPerCubicFoot
+            PowerDensity.FromMicrowattsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static PowerDensity MilliwattsPerCubicFoot<T>(this T value) =>
-             PowerDensity.FromMilliwattsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliwattPerCubicInch
+            PowerDensity.FromMilliwattsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicInch(UnitsNet.QuantityValue)" />
         public static PowerDensity MilliwattsPerCubicInch<T>(this T value) =>
-             PowerDensity.FromMilliwattsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliwattPerCubicMeter
+            PowerDensity.FromMilliwattsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static PowerDensity MilliwattsPerCubicMeter<T>(this T value) =>
-             PowerDensity.FromMilliwattsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliwattPerLiter
+            PowerDensity.FromMilliwattsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromMilliwattsPerLiter(UnitsNet.QuantityValue)" />
         public static PowerDensity MilliwattsPerLiter<T>(this T value) =>
-             PowerDensity.FromMilliwattsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanowattPerCubicFoot
+            PowerDensity.FromMilliwattsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static PowerDensity NanowattsPerCubicFoot<T>(this T value) =>
-             PowerDensity.FromNanowattsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanowattPerCubicInch
+            PowerDensity.FromNanowattsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicInch(UnitsNet.QuantityValue)" />
         public static PowerDensity NanowattsPerCubicInch<T>(this T value) =>
-             PowerDensity.FromNanowattsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanowattPerCubicMeter
+            PowerDensity.FromNanowattsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static PowerDensity NanowattsPerCubicMeter<T>(this T value) =>
-             PowerDensity.FromNanowattsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanowattPerLiter
+            PowerDensity.FromNanowattsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromNanowattsPerLiter(UnitsNet.QuantityValue)" />
         public static PowerDensity NanowattsPerLiter<T>(this T value) =>
-             PowerDensity.FromNanowattsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicowattPerCubicFoot
+            PowerDensity.FromNanowattsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static PowerDensity PicowattsPerCubicFoot<T>(this T value) =>
-             PowerDensity.FromPicowattsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicowattPerCubicInch
+            PowerDensity.FromPicowattsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicInch(UnitsNet.QuantityValue)" />
         public static PowerDensity PicowattsPerCubicInch<T>(this T value) =>
-             PowerDensity.FromPicowattsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicowattPerCubicMeter
+            PowerDensity.FromPicowattsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static PowerDensity PicowattsPerCubicMeter<T>(this T value) =>
-             PowerDensity.FromPicowattsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicowattPerLiter
+            PowerDensity.FromPicowattsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromPicowattsPerLiter(UnitsNet.QuantityValue)" />
         public static PowerDensity PicowattsPerLiter<T>(this T value) =>
-             PowerDensity.FromPicowattsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TerawattPerCubicFoot
+            PowerDensity.FromPicowattsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static PowerDensity TerawattsPerCubicFoot<T>(this T value) =>
-             PowerDensity.FromTerawattsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TerawattPerCubicInch
+            PowerDensity.FromTerawattsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicInch(UnitsNet.QuantityValue)" />
         public static PowerDensity TerawattsPerCubicInch<T>(this T value) =>
-             PowerDensity.FromTerawattsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TerawattPerCubicMeter
+            PowerDensity.FromTerawattsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static PowerDensity TerawattsPerCubicMeter<T>(this T value) =>
-             PowerDensity.FromTerawattsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TerawattPerLiter
+            PowerDensity.FromTerawattsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromTerawattsPerLiter(UnitsNet.QuantityValue)" />
         public static PowerDensity TerawattsPerLiter<T>(this T value) =>
-             PowerDensity.FromTerawattsPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerCubicFoot
+            PowerDensity.FromTerawattsPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromWattsPerCubicFoot(UnitsNet.QuantityValue)" />
         public static PowerDensity WattsPerCubicFoot<T>(this T value) =>
-             PowerDensity.FromWattsPerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerCubicInch
+            PowerDensity.FromWattsPerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromWattsPerCubicInch(UnitsNet.QuantityValue)" />
         public static PowerDensity WattsPerCubicInch<T>(this T value) =>
-             PowerDensity.FromWattsPerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerCubicMeter
+            PowerDensity.FromWattsPerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromWattsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static PowerDensity WattsPerCubicMeter<T>(this T value) =>
-             PowerDensity.FromWattsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerLiter
+            PowerDensity.FromWattsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerDensity.FromWattsPerLiter(UnitsNet.QuantityValue)" />
         public static PowerDensity WattsPerLiter<T>(this T value) =>
-             PowerDensity.FromWattsPerLiter(Convert.ToDouble(value));
-
-        #endregion
+            PowerDensity.FromWattsPerLiter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
similarity index 62%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
index 73742b726d..250934d1d3 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
@@ -19,213 +19,112 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToPower
+namespace UnitsNet.NumberExtensions.NumberToPower
 {
     /// <summary>
     /// A number to Power Extensions
     /// </summary>
     public static class NumberToPowerExtensions
     {
-
-        #region BoilerHorsepower
-
         /// <inheritdoc cref="Power.FromBoilerHorsepower(UnitsNet.QuantityValue)" />
         public static Power BoilerHorsepower<T>(this T value) =>
-             Power.FromBoilerHorsepower(Convert.ToDouble(value));
-
-        #endregion
-
-        #region BritishThermalUnitPerHour
+            Power.FromBoilerHorsepower(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromBritishThermalUnitsPerHour(UnitsNet.QuantityValue)" />
         public static Power BritishThermalUnitsPerHour<T>(this T value) =>
-             Power.FromBritishThermalUnitsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Decawatt
+            Power.FromBritishThermalUnitsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromDecawatts(UnitsNet.QuantityValue)" />
         public static Power Decawatts<T>(this T value) =>
-             Power.FromDecawatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Deciwatt
+            Power.FromDecawatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromDeciwatts(UnitsNet.QuantityValue)" />
         public static Power Deciwatts<T>(this T value) =>
-             Power.FromDeciwatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ElectricalHorsepower
+            Power.FromDeciwatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromElectricalHorsepower(UnitsNet.QuantityValue)" />
         public static Power ElectricalHorsepower<T>(this T value) =>
-             Power.FromElectricalHorsepower(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Femtowatt
+            Power.FromElectricalHorsepower(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromFemtowatts(UnitsNet.QuantityValue)" />
         public static Power Femtowatts<T>(this T value) =>
-             Power.FromFemtowatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region GigajoulePerHour
+            Power.FromFemtowatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromGigajoulesPerHour(UnitsNet.QuantityValue)" />
         public static Power GigajoulesPerHour<T>(this T value) =>
-             Power.FromGigajoulesPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Gigawatt
+            Power.FromGigajoulesPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromGigawatts(UnitsNet.QuantityValue)" />
         public static Power Gigawatts<T>(this T value) =>
-             Power.FromGigawatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region HydraulicHorsepower
+            Power.FromGigawatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromHydraulicHorsepower(UnitsNet.QuantityValue)" />
         public static Power HydraulicHorsepower<T>(this T value) =>
-             Power.FromHydraulicHorsepower(Convert.ToDouble(value));
-
-        #endregion
-
-        #region JoulePerHour
+            Power.FromHydraulicHorsepower(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromJoulesPerHour(UnitsNet.QuantityValue)" />
         public static Power JoulesPerHour<T>(this T value) =>
-             Power.FromJoulesPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilobritishThermalUnitPerHour
+            Power.FromJoulesPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromKilobritishThermalUnitsPerHour(UnitsNet.QuantityValue)" />
         public static Power KilobritishThermalUnitsPerHour<T>(this T value) =>
-             Power.FromKilobritishThermalUnitsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilojoulePerHour
+            Power.FromKilobritishThermalUnitsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromKilojoulesPerHour(UnitsNet.QuantityValue)" />
         public static Power KilojoulesPerHour<T>(this T value) =>
-             Power.FromKilojoulesPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilowatt
+            Power.FromKilojoulesPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromKilowatts(UnitsNet.QuantityValue)" />
         public static Power Kilowatts<T>(this T value) =>
-             Power.FromKilowatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MechanicalHorsepower
+            Power.FromKilowatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromMechanicalHorsepower(UnitsNet.QuantityValue)" />
         public static Power MechanicalHorsepower<T>(this T value) =>
-             Power.FromMechanicalHorsepower(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegajoulePerHour
+            Power.FromMechanicalHorsepower(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromMegajoulesPerHour(UnitsNet.QuantityValue)" />
         public static Power MegajoulesPerHour<T>(this T value) =>
-             Power.FromMegajoulesPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megawatt
+            Power.FromMegajoulesPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromMegawatts(UnitsNet.QuantityValue)" />
         public static Power Megawatts<T>(this T value) =>
-             Power.FromMegawatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MetricHorsepower
+            Power.FromMegawatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromMetricHorsepower(UnitsNet.QuantityValue)" />
         public static Power MetricHorsepower<T>(this T value) =>
-             Power.FromMetricHorsepower(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microwatt
+            Power.FromMetricHorsepower(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromMicrowatts(UnitsNet.QuantityValue)" />
         public static Power Microwatts<T>(this T value) =>
-             Power.FromMicrowatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillijoulePerHour
+            Power.FromMicrowatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromMillijoulesPerHour(UnitsNet.QuantityValue)" />
         public static Power MillijoulesPerHour<T>(this T value) =>
-             Power.FromMillijoulesPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Milliwatt
+            Power.FromMillijoulesPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromMilliwatts(UnitsNet.QuantityValue)" />
         public static Power Milliwatts<T>(this T value) =>
-             Power.FromMilliwatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Nanowatt
+            Power.FromMilliwatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromNanowatts(UnitsNet.QuantityValue)" />
         public static Power Nanowatts<T>(this T value) =>
-             Power.FromNanowatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Petawatt
+            Power.FromNanowatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromPetawatts(UnitsNet.QuantityValue)" />
         public static Power Petawatts<T>(this T value) =>
-             Power.FromPetawatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Picowatt
+            Power.FromPetawatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromPicowatts(UnitsNet.QuantityValue)" />
         public static Power Picowatts<T>(this T value) =>
-             Power.FromPicowatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Terawatt
+            Power.FromPicowatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromTerawatts(UnitsNet.QuantityValue)" />
         public static Power Terawatts<T>(this T value) =>
-             Power.FromTerawatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Watt
+            Power.FromTerawatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Power.FromWatts(UnitsNet.QuantityValue)" />
         public static Power Watts<T>(this T value) =>
-             Power.FromWatts(Convert.ToDouble(value));
-
-        #endregion
+            Power.FromWatts(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
similarity index 83%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerRatioExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
index 5c3be00223..3d29465227 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPowerRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
@@ -19,29 +19,20 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToPowerRatio
+namespace UnitsNet.NumberExtensions.NumberToPowerRatio
 {
     /// <summary>
     /// A number to PowerRatio Extensions
     /// </summary>
     public static class NumberToPowerRatioExtensions
     {
-
-        #region DecibelMilliwatt
-
         /// <inheritdoc cref="PowerRatio.FromDecibelMilliwatts(UnitsNet.QuantityValue)" />
         public static PowerRatio DecibelMilliwatts<T>(this T value) =>
-             PowerRatio.FromDecibelMilliwatts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecibelWatt
+            PowerRatio.FromDecibelMilliwatts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PowerRatio.FromDecibelWatts(UnitsNet.QuantityValue)" />
         public static PowerRatio DecibelWatts<T>(this T value) =>
-             PowerRatio.FromDecibelWatts(Convert.ToDouble(value));
-
-        #endregion
+            PowerRatio.FromDecibelWatts(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPressureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
similarity index 70%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPressureChangeRateExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
index 08a6c59f2d..56c8aed9c3 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPressureChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
@@ -19,69 +19,40 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToPressureChangeRate
+namespace UnitsNet.NumberExtensions.NumberToPressureChangeRate
 {
     /// <summary>
     /// A number to PressureChangeRate Extensions
     /// </summary>
     public static class NumberToPressureChangeRateExtensions
     {
-
-        #region AtmospherePerSecond
-
         /// <inheritdoc cref="PressureChangeRate.FromAtmospheresPerSecond(UnitsNet.QuantityValue)" />
         public static PressureChangeRate AtmospheresPerSecond<T>(this T value) =>
-             PressureChangeRate.FromAtmospheresPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopascalPerMinute
+            PressureChangeRate.FromAtmospheresPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerMinute(UnitsNet.QuantityValue)" />
         public static PressureChangeRate KilopascalsPerMinute<T>(this T value) =>
-             PressureChangeRate.FromKilopascalsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopascalPerSecond
+            PressureChangeRate.FromKilopascalsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerSecond(UnitsNet.QuantityValue)" />
         public static PressureChangeRate KilopascalsPerSecond<T>(this T value) =>
-             PressureChangeRate.FromKilopascalsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegapascalPerMinute
+            PressureChangeRate.FromKilopascalsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerMinute(UnitsNet.QuantityValue)" />
         public static PressureChangeRate MegapascalsPerMinute<T>(this T value) =>
-             PressureChangeRate.FromMegapascalsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegapascalPerSecond
+            PressureChangeRate.FromMegapascalsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerSecond(UnitsNet.QuantityValue)" />
         public static PressureChangeRate MegapascalsPerSecond<T>(this T value) =>
-             PressureChangeRate.FromMegapascalsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PascalPerMinute
+            PressureChangeRate.FromMegapascalsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PressureChangeRate.FromPascalsPerMinute(UnitsNet.QuantityValue)" />
         public static PressureChangeRate PascalsPerMinute<T>(this T value) =>
-             PressureChangeRate.FromPascalsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PascalPerSecond
+            PressureChangeRate.FromPascalsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="PressureChangeRate.FromPascalsPerSecond(UnitsNet.QuantityValue)" />
         public static PressureChangeRate PascalsPerSecond<T>(this T value) =>
-             PressureChangeRate.FromPascalsPerSecond(Convert.ToDouble(value));
-
-        #endregion
+            PressureChangeRate.FromPascalsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPressureExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
similarity index 60%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPressureExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
index 27bb301e3c..cfa7658058 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToPressureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
@@ -19,349 +19,180 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToPressure
+namespace UnitsNet.NumberExtensions.NumberToPressure
 {
     /// <summary>
     /// A number to Pressure Extensions
     /// </summary>
     public static class NumberToPressureExtensions
     {
-
-        #region Atmosphere
-
         /// <inheritdoc cref="Pressure.FromAtmospheres(UnitsNet.QuantityValue)" />
         public static Pressure Atmospheres<T>(this T value) =>
-             Pressure.FromAtmospheres(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Bar
+            Pressure.FromAtmospheres(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromBars(UnitsNet.QuantityValue)" />
         public static Pressure Bars<T>(this T value) =>
-             Pressure.FromBars(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Centibar
+            Pressure.FromBars(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromCentibars(UnitsNet.QuantityValue)" />
         public static Pressure Centibars<T>(this T value) =>
-             Pressure.FromCentibars(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Decapascal
+            Pressure.FromCentibars(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromDecapascals(UnitsNet.QuantityValue)" />
         public static Pressure Decapascals<T>(this T value) =>
-             Pressure.FromDecapascals(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Decibar
+            Pressure.FromDecapascals(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromDecibars(UnitsNet.QuantityValue)" />
         public static Pressure Decibars<T>(this T value) =>
-             Pressure.FromDecibars(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DynePerSquareCentimeter
+            Pressure.FromDecibars(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromDynesPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Pressure DynesPerSquareCentimeter<T>(this T value) =>
-             Pressure.FromDynesPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region FootOfHead
+            Pressure.FromDynesPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromFeetOfHead(UnitsNet.QuantityValue)" />
         public static Pressure FeetOfHead<T>(this T value) =>
-             Pressure.FromFeetOfHead(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Gigapascal
+            Pressure.FromFeetOfHead(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromGigapascals(UnitsNet.QuantityValue)" />
         public static Pressure Gigapascals<T>(this T value) =>
-             Pressure.FromGigapascals(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Hectopascal
+            Pressure.FromGigapascals(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromHectopascals(UnitsNet.QuantityValue)" />
         public static Pressure Hectopascals<T>(this T value) =>
-             Pressure.FromHectopascals(Convert.ToDouble(value));
-
-        #endregion
-
-        #region InchOfMercury
+            Pressure.FromHectopascals(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromInchesOfMercury(UnitsNet.QuantityValue)" />
         public static Pressure InchesOfMercury<T>(this T value) =>
-             Pressure.FromInchesOfMercury(Convert.ToDouble(value));
-
-        #endregion
-
-        #region InchOfWaterColumn
+            Pressure.FromInchesOfMercury(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromInchesOfWaterColumn(UnitsNet.QuantityValue)" />
         public static Pressure InchesOfWaterColumn<T>(this T value) =>
-             Pressure.FromInchesOfWaterColumn(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilobar
+            Pressure.FromInchesOfWaterColumn(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromKilobars(UnitsNet.QuantityValue)" />
         public static Pressure Kilobars<T>(this T value) =>
-             Pressure.FromKilobars(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramForcePerSquareCentimeter
+            Pressure.FromKilobars(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Pressure KilogramsForcePerSquareCentimeter<T>(this T value) =>
-             Pressure.FromKilogramsForcePerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramForcePerSquareMeter
+            Pressure.FromKilogramsForcePerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMeter(UnitsNet.QuantityValue)" />
         public static Pressure KilogramsForcePerSquareMeter<T>(this T value) =>
-             Pressure.FromKilogramsForcePerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramForcePerSquareMillimeter
+            Pressure.FromKilogramsForcePerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMillimeter(UnitsNet.QuantityValue)" />
         public static Pressure KilogramsForcePerSquareMillimeter<T>(this T value) =>
-             Pressure.FromKilogramsForcePerSquareMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonPerSquareCentimeter
+            Pressure.FromKilogramsForcePerSquareMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Pressure KilonewtonsPerSquareCentimeter<T>(this T value) =>
-             Pressure.FromKilonewtonsPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonPerSquareMeter
+            Pressure.FromKilonewtonsPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Pressure KilonewtonsPerSquareMeter<T>(this T value) =>
-             Pressure.FromKilonewtonsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonPerSquareMillimeter
+            Pressure.FromKilonewtonsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMillimeter(UnitsNet.QuantityValue)" />
         public static Pressure KilonewtonsPerSquareMillimeter<T>(this T value) =>
-             Pressure.FromKilonewtonsPerSquareMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kilopascal
+            Pressure.FromKilonewtonsPerSquareMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromKilopascals(UnitsNet.QuantityValue)" />
         public static Pressure Kilopascals<T>(this T value) =>
-             Pressure.FromKilopascals(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundForcePerSquareFoot
+            Pressure.FromKilopascals(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareFoot(UnitsNet.QuantityValue)" />
         public static Pressure KilopoundsForcePerSquareFoot<T>(this T value) =>
-             Pressure.FromKilopoundsForcePerSquareFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundForcePerSquareInch
+            Pressure.FromKilopoundsForcePerSquareFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareInch(UnitsNet.QuantityValue)" />
         public static Pressure KilopoundsForcePerSquareInch<T>(this T value) =>
-             Pressure.FromKilopoundsForcePerSquareInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megabar
+            Pressure.FromKilopoundsForcePerSquareInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromMegabars(UnitsNet.QuantityValue)" />
         public static Pressure Megabars<T>(this T value) =>
-             Pressure.FromMegabars(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeganewtonPerSquareMeter
+            Pressure.FromMegabars(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromMeganewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Pressure MeganewtonsPerSquareMeter<T>(this T value) =>
-             Pressure.FromMeganewtonsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megapascal
+            Pressure.FromMeganewtonsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromMegapascals(UnitsNet.QuantityValue)" />
         public static Pressure Megapascals<T>(this T value) =>
-             Pressure.FromMegapascals(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeterOfHead
+            Pressure.FromMegapascals(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromMetersOfHead(UnitsNet.QuantityValue)" />
         public static Pressure MetersOfHead<T>(this T value) =>
-             Pressure.FromMetersOfHead(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microbar
+            Pressure.FromMetersOfHead(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromMicrobars(UnitsNet.QuantityValue)" />
         public static Pressure Microbars<T>(this T value) =>
-             Pressure.FromMicrobars(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Micropascal
+            Pressure.FromMicrobars(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromMicropascals(UnitsNet.QuantityValue)" />
         public static Pressure Micropascals<T>(this T value) =>
-             Pressure.FromMicropascals(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millibar
+            Pressure.FromMicropascals(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromMillibars(UnitsNet.QuantityValue)" />
         public static Pressure Millibars<T>(this T value) =>
-             Pressure.FromMillibars(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillimeterOfMercury
+            Pressure.FromMillibars(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromMillimetersOfMercury(UnitsNet.QuantityValue)" />
         public static Pressure MillimetersOfMercury<T>(this T value) =>
-             Pressure.FromMillimetersOfMercury(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Millipascal
+            Pressure.FromMillimetersOfMercury(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromMillipascals(UnitsNet.QuantityValue)" />
         public static Pressure Millipascals<T>(this T value) =>
-             Pressure.FromMillipascals(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonPerSquareCentimeter
+            Pressure.FromMillipascals(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromNewtonsPerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Pressure NewtonsPerSquareCentimeter<T>(this T value) =>
-             Pressure.FromNewtonsPerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonPerSquareMeter
+            Pressure.FromNewtonsPerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
         public static Pressure NewtonsPerSquareMeter<T>(this T value) =>
-             Pressure.FromNewtonsPerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonPerSquareMillimeter
+            Pressure.FromNewtonsPerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMillimeter(UnitsNet.QuantityValue)" />
         public static Pressure NewtonsPerSquareMillimeter<T>(this T value) =>
-             Pressure.FromNewtonsPerSquareMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Pascal
+            Pressure.FromNewtonsPerSquareMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromPascals(UnitsNet.QuantityValue)" />
         public static Pressure Pascals<T>(this T value) =>
-             Pressure.FromPascals(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForcePerSquareFoot
+            Pressure.FromPascals(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareFoot(UnitsNet.QuantityValue)" />
         public static Pressure PoundsForcePerSquareFoot<T>(this T value) =>
-             Pressure.FromPoundsForcePerSquareFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForcePerSquareInch
+            Pressure.FromPoundsForcePerSquareFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareInch(UnitsNet.QuantityValue)" />
         public static Pressure PoundsForcePerSquareInch<T>(this T value) =>
-             Pressure.FromPoundsForcePerSquareInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundPerInchSecondSquared
+            Pressure.FromPoundsForcePerSquareInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromPoundsPerInchSecondSquared(UnitsNet.QuantityValue)" />
         public static Pressure PoundsPerInchSecondSquared<T>(this T value) =>
-             Pressure.FromPoundsPerInchSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TechnicalAtmosphere
+            Pressure.FromPoundsPerInchSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromTechnicalAtmospheres(UnitsNet.QuantityValue)" />
         public static Pressure TechnicalAtmospheres<T>(this T value) =>
-             Pressure.FromTechnicalAtmospheres(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForcePerSquareCentimeter
+            Pressure.FromTechnicalAtmospheres(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareCentimeter(UnitsNet.QuantityValue)" />
         public static Pressure TonnesForcePerSquareCentimeter<T>(this T value) =>
-             Pressure.FromTonnesForcePerSquareCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForcePerSquareMeter
+            Pressure.FromTonnesForcePerSquareCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMeter(UnitsNet.QuantityValue)" />
         public static Pressure TonnesForcePerSquareMeter<T>(this T value) =>
-             Pressure.FromTonnesForcePerSquareMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForcePerSquareMillimeter
+            Pressure.FromTonnesForcePerSquareMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMillimeter(UnitsNet.QuantityValue)" />
         public static Pressure TonnesForcePerSquareMillimeter<T>(this T value) =>
-             Pressure.FromTonnesForcePerSquareMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Torr
+            Pressure.FromTonnesForcePerSquareMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Pressure.FromTorrs(UnitsNet.QuantityValue)" />
         public static Pressure Torrs<T>(this T value) =>
-             Pressure.FromTorrs(Convert.ToDouble(value));
-
-        #endregion
+            Pressure.FromTorrs(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRatioChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
similarity index 82%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRatioChangeRateExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
index 8d955f80f2..340ddfb601 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRatioChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
@@ -19,29 +19,20 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToRatioChangeRate
+namespace UnitsNet.NumberExtensions.NumberToRatioChangeRate
 {
     /// <summary>
     /// A number to RatioChangeRate Extensions
     /// </summary>
     public static class NumberToRatioChangeRateExtensions
     {
-
-        #region DecimalFractionPerSecond
-
         /// <inheritdoc cref="RatioChangeRate.FromDecimalFractionsPerSecond(UnitsNet.QuantityValue)" />
         public static RatioChangeRate DecimalFractionsPerSecond<T>(this T value) =>
-             RatioChangeRate.FromDecimalFractionsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PercentPerSecond
+            RatioChangeRate.FromDecimalFractionsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RatioChangeRate.FromPercentsPerSecond(UnitsNet.QuantityValue)" />
         public static RatioChangeRate PercentsPerSecond<T>(this T value) =>
-             RatioChangeRate.FromPercentsPerSecond(Convert.ToDouble(value));
-
-        #endregion
+            RatioChangeRate.FromPercentsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
similarity index 73%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRatioExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
index ad2fc1be4b..c9039a80e4 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
@@ -19,61 +19,36 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToRatio
+namespace UnitsNet.NumberExtensions.NumberToRatio
 {
     /// <summary>
     /// A number to Ratio Extensions
     /// </summary>
     public static class NumberToRatioExtensions
     {
-
-        #region DecimalFraction
-
         /// <inheritdoc cref="Ratio.FromDecimalFractions(UnitsNet.QuantityValue)" />
         public static Ratio DecimalFractions<T>(this T value) =>
-             Ratio.FromDecimalFractions(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerBillion
+            Ratio.FromDecimalFractions(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Ratio.FromPartsPerBillion(UnitsNet.QuantityValue)" />
         public static Ratio PartsPerBillion<T>(this T value) =>
-             Ratio.FromPartsPerBillion(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerMillion
+            Ratio.FromPartsPerBillion(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Ratio.FromPartsPerMillion(UnitsNet.QuantityValue)" />
         public static Ratio PartsPerMillion<T>(this T value) =>
-             Ratio.FromPartsPerMillion(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerThousand
+            Ratio.FromPartsPerMillion(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Ratio.FromPartsPerThousand(UnitsNet.QuantityValue)" />
         public static Ratio PartsPerThousand<T>(this T value) =>
-             Ratio.FromPartsPerThousand(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerTrillion
+            Ratio.FromPartsPerThousand(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Ratio.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
         public static Ratio PartsPerTrillion<T>(this T value) =>
-             Ratio.FromPartsPerTrillion(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Percent
+            Ratio.FromPartsPerTrillion(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Ratio.FromPercent(UnitsNet.QuantityValue)" />
         public static Ratio Percent<T>(this T value) =>
-             Ratio.FromPercent(Convert.ToDouble(value));
-
-        #endregion
+            Ratio.FromPercent(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToReactiveEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactiveEnergyExtensions.g.cs
similarity index 77%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToReactiveEnergyExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToReactiveEnergyExtensions.g.cs
index 1829b11da0..edc046a8a3 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToReactiveEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactiveEnergyExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToReactiveEnergy
+namespace UnitsNet.NumberExtensions.NumberToReactiveEnergy
 {
     /// <summary>
     /// A number to ReactiveEnergy Extensions
     /// </summary>
     public static class NumberToReactiveEnergyExtensions
     {
-
-        #region KilovoltampereReactiveHour
-
         /// <inheritdoc cref="ReactiveEnergy.FromKilovoltampereReactiveHours(UnitsNet.QuantityValue)" />
         public static ReactiveEnergy KilovoltampereReactiveHours<T>(this T value) =>
-             ReactiveEnergy.FromKilovoltampereReactiveHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegavoltampereReactiveHour
+            ReactiveEnergy.FromKilovoltampereReactiveHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ReactiveEnergy.FromMegavoltampereReactiveHours(UnitsNet.QuantityValue)" />
         public static ReactiveEnergy MegavoltampereReactiveHours<T>(this T value) =>
-             ReactiveEnergy.FromMegavoltampereReactiveHours(Convert.ToDouble(value));
-
-        #endregion
-
-        #region VoltampereReactiveHour
+            ReactiveEnergy.FromMegavoltampereReactiveHours(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ReactiveEnergy.FromVoltampereReactiveHours(UnitsNet.QuantityValue)" />
         public static ReactiveEnergy VoltampereReactiveHours<T>(this T value) =>
-             ReactiveEnergy.FromVoltampereReactiveHours(Convert.ToDouble(value));
-
-        #endregion
+            ReactiveEnergy.FromVoltampereReactiveHours(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToReactivePowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactivePowerExtensions.g.cs
similarity index 75%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToReactivePowerExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToReactivePowerExtensions.g.cs
index aeffb9cb2b..252e85ea51 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToReactivePowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactivePowerExtensions.g.cs
@@ -19,45 +19,28 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToReactivePower
+namespace UnitsNet.NumberExtensions.NumberToReactivePower
 {
     /// <summary>
     /// A number to ReactivePower Extensions
     /// </summary>
     public static class NumberToReactivePowerExtensions
     {
-
-        #region GigavoltampereReactive
-
         /// <inheritdoc cref="ReactivePower.FromGigavoltamperesReactive(UnitsNet.QuantityValue)" />
         public static ReactivePower GigavoltamperesReactive<T>(this T value) =>
-             ReactivePower.FromGigavoltamperesReactive(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilovoltampereReactive
+            ReactivePower.FromGigavoltamperesReactive(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ReactivePower.FromKilovoltamperesReactive(UnitsNet.QuantityValue)" />
         public static ReactivePower KilovoltamperesReactive<T>(this T value) =>
-             ReactivePower.FromKilovoltamperesReactive(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegavoltampereReactive
+            ReactivePower.FromKilovoltamperesReactive(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ReactivePower.FromMegavoltamperesReactive(UnitsNet.QuantityValue)" />
         public static ReactivePower MegavoltamperesReactive<T>(this T value) =>
-             ReactivePower.FromMegavoltamperesReactive(Convert.ToDouble(value));
-
-        #endregion
-
-        #region VoltampereReactive
+            ReactivePower.FromMegavoltamperesReactive(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ReactivePower.FromVoltamperesReactive(UnitsNet.QuantityValue)" />
         public static ReactivePower VoltamperesReactive<T>(this T value) =>
-             ReactivePower.FromVoltamperesReactive(Convert.ToDouble(value));
-
-        #endregion
+            ReactivePower.FromVoltamperesReactive(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
similarity index 74%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalAccelerationExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
index ba9ba6b474..ada07afdb2 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalAccelerationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
@@ -19,45 +19,28 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToRotationalAcceleration
+namespace UnitsNet.NumberExtensions.NumberToRotationalAcceleration
 {
     /// <summary>
     /// A number to RotationalAcceleration Extensions
     /// </summary>
     public static class NumberToRotationalAccelerationExtensions
     {
-
-        #region DegreePerSecondSquared
-
         /// <inheritdoc cref="RotationalAcceleration.FromDegreesPerSecondSquared(UnitsNet.QuantityValue)" />
         public static RotationalAcceleration DegreesPerSecondSquared<T>(this T value) =>
-             RotationalAcceleration.FromDegreesPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region RadianPerSecondSquared
+            RotationalAcceleration.FromDegreesPerSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalAcceleration.FromRadiansPerSecondSquared(UnitsNet.QuantityValue)" />
         public static RotationalAcceleration RadiansPerSecondSquared<T>(this T value) =>
-             RotationalAcceleration.FromRadiansPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
-
-        #region RevolutionPerMinutePerSecond
+            RotationalAcceleration.FromRadiansPerSecondSquared(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerMinutePerSecond(UnitsNet.QuantityValue)" />
         public static RotationalAcceleration RevolutionsPerMinutePerSecond<T>(this T value) =>
-             RotationalAcceleration.FromRevolutionsPerMinutePerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region RevolutionPerSecondSquared
+            RotationalAcceleration.FromRevolutionsPerMinutePerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerSecondSquared(UnitsNet.QuantityValue)" />
         public static RotationalAcceleration RevolutionsPerSecondSquared<T>(this T value) =>
-             RotationalAcceleration.FromRevolutionsPerSecondSquared(Convert.ToDouble(value));
-
-        #endregion
+            RotationalAcceleration.FromRevolutionsPerSecondSquared(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalSpeedExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
similarity index 67%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalSpeedExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
index 6b80a889ac..6a8ae3b173 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalSpeedExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
@@ -19,117 +19,64 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToRotationalSpeed
+namespace UnitsNet.NumberExtensions.NumberToRotationalSpeed
 {
     /// <summary>
     /// A number to RotationalSpeed Extensions
     /// </summary>
     public static class NumberToRotationalSpeedExtensions
     {
-
-        #region CentiradianPerSecond
-
         /// <inheritdoc cref="RotationalSpeed.FromCentiradiansPerSecond(UnitsNet.QuantityValue)" />
         public static RotationalSpeed CentiradiansPerSecond<T>(this T value) =>
-             RotationalSpeed.FromCentiradiansPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DeciradianPerSecond
+            RotationalSpeed.FromCentiradiansPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromDeciradiansPerSecond(UnitsNet.QuantityValue)" />
         public static RotationalSpeed DeciradiansPerSecond<T>(this T value) =>
-             RotationalSpeed.FromDeciradiansPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreePerMinute
+            RotationalSpeed.FromDeciradiansPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromDegreesPerMinute(UnitsNet.QuantityValue)" />
         public static RotationalSpeed DegreesPerMinute<T>(this T value) =>
-             RotationalSpeed.FromDegreesPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreePerSecond
+            RotationalSpeed.FromDegreesPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromDegreesPerSecond(UnitsNet.QuantityValue)" />
         public static RotationalSpeed DegreesPerSecond<T>(this T value) =>
-             RotationalSpeed.FromDegreesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrodegreePerSecond
+            RotationalSpeed.FromDegreesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromMicrodegreesPerSecond(UnitsNet.QuantityValue)" />
         public static RotationalSpeed MicrodegreesPerSecond<T>(this T value) =>
-             RotationalSpeed.FromMicrodegreesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicroradianPerSecond
+            RotationalSpeed.FromMicrodegreesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromMicroradiansPerSecond(UnitsNet.QuantityValue)" />
         public static RotationalSpeed MicroradiansPerSecond<T>(this T value) =>
-             RotationalSpeed.FromMicroradiansPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillidegreePerSecond
+            RotationalSpeed.FromMicroradiansPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromMillidegreesPerSecond(UnitsNet.QuantityValue)" />
         public static RotationalSpeed MillidegreesPerSecond<T>(this T value) =>
-             RotationalSpeed.FromMillidegreesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliradianPerSecond
+            RotationalSpeed.FromMillidegreesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromMilliradiansPerSecond(UnitsNet.QuantityValue)" />
         public static RotationalSpeed MilliradiansPerSecond<T>(this T value) =>
-             RotationalSpeed.FromMilliradiansPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanodegreePerSecond
+            RotationalSpeed.FromMilliradiansPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromNanodegreesPerSecond(UnitsNet.QuantityValue)" />
         public static RotationalSpeed NanodegreesPerSecond<T>(this T value) =>
-             RotationalSpeed.FromNanodegreesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanoradianPerSecond
+            RotationalSpeed.FromNanodegreesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromNanoradiansPerSecond(UnitsNet.QuantityValue)" />
         public static RotationalSpeed NanoradiansPerSecond<T>(this T value) =>
-             RotationalSpeed.FromNanoradiansPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region RadianPerSecond
+            RotationalSpeed.FromNanoradiansPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromRadiansPerSecond(UnitsNet.QuantityValue)" />
         public static RotationalSpeed RadiansPerSecond<T>(this T value) =>
-             RotationalSpeed.FromRadiansPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region RevolutionPerMinute
+            RotationalSpeed.FromRadiansPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(UnitsNet.QuantityValue)" />
         public static RotationalSpeed RevolutionsPerMinute<T>(this T value) =>
-             RotationalSpeed.FromRevolutionsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region RevolutionPerSecond
+            RotationalSpeed.FromRevolutionsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerSecond(UnitsNet.QuantityValue)" />
         public static RotationalSpeed RevolutionsPerSecond<T>(this T value) =>
-             RotationalSpeed.FromRevolutionsPerSecond(Convert.ToDouble(value));
-
-        #endregion
+            RotationalSpeed.FromRevolutionsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalStiffnessExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
similarity index 77%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalStiffnessExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
index 4283d240f0..4507164029 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalStiffnessExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToRotationalStiffness
+namespace UnitsNet.NumberExtensions.NumberToRotationalStiffness
 {
     /// <summary>
     /// A number to RotationalStiffness Extensions
     /// </summary>
     public static class NumberToRotationalStiffnessExtensions
     {
-
-        #region KilonewtonMeterPerRadian
-
         /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerRadian(UnitsNet.QuantityValue)" />
         public static RotationalStiffness KilonewtonMetersPerRadian<T>(this T value) =>
-             RotationalStiffness.FromKilonewtonMetersPerRadian(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeganewtonMeterPerRadian
+            RotationalStiffness.FromKilonewtonMetersPerRadian(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerRadian(UnitsNet.QuantityValue)" />
         public static RotationalStiffness MeganewtonMetersPerRadian<T>(this T value) =>
-             RotationalStiffness.FromMeganewtonMetersPerRadian(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonMeterPerRadian
+            RotationalStiffness.FromMeganewtonMetersPerRadian(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerRadian(UnitsNet.QuantityValue)" />
         public static RotationalStiffness NewtonMetersPerRadian<T>(this T value) =>
-             RotationalStiffness.FromNewtonMetersPerRadian(Convert.ToDouble(value));
-
-        #endregion
+            RotationalStiffness.FromNewtonMetersPerRadian(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalStiffnessPerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
similarity index 76%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalStiffnessPerLengthExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
index f377b5aeb9..f8577e65eb 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToRotationalStiffnessPerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToRotationalStiffnessPerLength
+namespace UnitsNet.NumberExtensions.NumberToRotationalStiffnessPerLength
 {
     /// <summary>
     /// A number to RotationalStiffnessPerLength Extensions
     /// </summary>
     public static class NumberToRotationalStiffnessPerLengthExtensions
     {
-
-        #region KilonewtonMeterPerRadianPerMeter
-
         /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
         public static RotationalStiffnessPerLength KilonewtonMetersPerRadianPerMeter<T>(this T value) =>
-             RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeganewtonMeterPerRadianPerMeter
+            RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
         public static RotationalStiffnessPerLength MeganewtonMetersPerRadianPerMeter<T>(this T value) =>
-             RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonMeterPerRadianPerMeter
+            RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
         public static RotationalStiffnessPerLength NewtonMetersPerRadianPerMeter<T>(this T value) =>
-             RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
-
-        #endregion
+            RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSolidAngleExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
similarity index 89%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSolidAngleExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
index c36bf1a0d4..264aaedf1a 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSolidAngleExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToSolidAngle
+namespace UnitsNet.NumberExtensions.NumberToSolidAngle
 {
     /// <summary>
     /// A number to SolidAngle Extensions
     /// </summary>
     public static class NumberToSolidAngleExtensions
     {
-
-        #region Steradian
-
         /// <inheritdoc cref="SolidAngle.FromSteradians(UnitsNet.QuantityValue)" />
         public static SolidAngle Steradians<T>(this T value) =>
-             SolidAngle.FromSteradians(Convert.ToDouble(value));
-
-        #endregion
+            SolidAngle.FromSteradians(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
similarity index 69%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificEnergyExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
index da8c461a92..d1db4dd87d 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
@@ -19,85 +19,48 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToSpecificEnergy
+namespace UnitsNet.NumberExtensions.NumberToSpecificEnergy
 {
     /// <summary>
     /// A number to SpecificEnergy Extensions
     /// </summary>
     public static class NumberToSpecificEnergyExtensions
     {
-
-        #region BtuPerPound
-
         /// <inheritdoc cref="SpecificEnergy.FromBtuPerPound(UnitsNet.QuantityValue)" />
         public static SpecificEnergy BtuPerPound<T>(this T value) =>
-             SpecificEnergy.FromBtuPerPound(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CaloriePerGram
+            SpecificEnergy.FromBtuPerPound(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEnergy.FromCaloriesPerGram(UnitsNet.QuantityValue)" />
         public static SpecificEnergy CaloriesPerGram<T>(this T value) =>
-             SpecificEnergy.FromCaloriesPerGram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region JoulePerKilogram
+            SpecificEnergy.FromCaloriesPerGram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEnergy.FromJoulesPerKilogram(UnitsNet.QuantityValue)" />
         public static SpecificEnergy JoulesPerKilogram<T>(this T value) =>
-             SpecificEnergy.FromJoulesPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilocaloriePerGram
+            SpecificEnergy.FromJoulesPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEnergy.FromKilocaloriesPerGram(UnitsNet.QuantityValue)" />
         public static SpecificEnergy KilocaloriesPerGram<T>(this T value) =>
-             SpecificEnergy.FromKilocaloriesPerGram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilojoulePerKilogram
+            SpecificEnergy.FromKilocaloriesPerGram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEnergy.FromKilojoulesPerKilogram(UnitsNet.QuantityValue)" />
         public static SpecificEnergy KilojoulesPerKilogram<T>(this T value) =>
-             SpecificEnergy.FromKilojoulesPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilowattHourPerKilogram
+            SpecificEnergy.FromKilojoulesPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerKilogram(UnitsNet.QuantityValue)" />
         public static SpecificEnergy KilowattHoursPerKilogram<T>(this T value) =>
-             SpecificEnergy.FromKilowattHoursPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegajoulePerKilogram
+            SpecificEnergy.FromKilowattHoursPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerKilogram(UnitsNet.QuantityValue)" />
         public static SpecificEnergy MegajoulesPerKilogram<T>(this T value) =>
-             SpecificEnergy.FromMegajoulesPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegawattHourPerKilogram
+            SpecificEnergy.FromMegajoulesPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerKilogram(UnitsNet.QuantityValue)" />
         public static SpecificEnergy MegawattHoursPerKilogram<T>(this T value) =>
-             SpecificEnergy.FromMegawattHoursPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattHourPerKilogram
+            SpecificEnergy.FromMegawattHoursPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerKilogram(UnitsNet.QuantityValue)" />
         public static SpecificEnergy WattHoursPerKilogram<T>(this T value) =>
-             SpecificEnergy.FromWattHoursPerKilogram(Convert.ToDouble(value));
-
-        #endregion
+            SpecificEnergy.FromWattHoursPerKilogram(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
similarity index 68%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificEntropyExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
index 0a398e7556..ebe1ff2e6a 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
@@ -19,85 +19,48 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToSpecificEntropy
+namespace UnitsNet.NumberExtensions.NumberToSpecificEntropy
 {
     /// <summary>
     /// A number to SpecificEntropy Extensions
     /// </summary>
     public static class NumberToSpecificEntropyExtensions
     {
-
-        #region BtuPerPoundFahrenheit
-
         /// <inheritdoc cref="SpecificEntropy.FromBtusPerPoundFahrenheit(UnitsNet.QuantityValue)" />
         public static SpecificEntropy BtusPerPoundFahrenheit<T>(this T value) =>
-             SpecificEntropy.FromBtusPerPoundFahrenheit(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CaloriePerGramKelvin
+            SpecificEntropy.FromBtusPerPoundFahrenheit(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEntropy.FromCaloriesPerGramKelvin(UnitsNet.QuantityValue)" />
         public static SpecificEntropy CaloriesPerGramKelvin<T>(this T value) =>
-             SpecificEntropy.FromCaloriesPerGramKelvin(Convert.ToDouble(value));
-
-        #endregion
-
-        #region JoulePerKilogramDegreeCelsius
+            SpecificEntropy.FromCaloriesPerGramKelvin(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
         public static SpecificEntropy JoulesPerKilogramDegreeCelsius<T>(this T value) =>
-             SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
-
-        #endregion
-
-        #region JoulePerKilogramKelvin
+            SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
         public static SpecificEntropy JoulesPerKilogramKelvin<T>(this T value) =>
-             SpecificEntropy.FromJoulesPerKilogramKelvin(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilocaloriePerGramKelvin
+            SpecificEntropy.FromJoulesPerKilogramKelvin(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEntropy.FromKilocaloriesPerGramKelvin(UnitsNet.QuantityValue)" />
         public static SpecificEntropy KilocaloriesPerGramKelvin<T>(this T value) =>
-             SpecificEntropy.FromKilocaloriesPerGramKelvin(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilojoulePerKilogramDegreeCelsius
+            SpecificEntropy.FromKilocaloriesPerGramKelvin(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
         public static SpecificEntropy KilojoulesPerKilogramDegreeCelsius<T>(this T value) =>
-             SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilojoulePerKilogramKelvin
+            SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
         public static SpecificEntropy KilojoulesPerKilogramKelvin<T>(this T value) =>
-             SpecificEntropy.FromKilojoulesPerKilogramKelvin(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegajoulePerKilogramDegreeCelsius
+            SpecificEntropy.FromKilojoulesPerKilogramKelvin(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
         public static SpecificEntropy MegajoulesPerKilogramDegreeCelsius<T>(this T value) =>
-             SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegajoulePerKilogramKelvin
+            SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
         public static SpecificEntropy MegajoulesPerKilogramKelvin<T>(this T value) =>
-             SpecificEntropy.FromMegajoulesPerKilogramKelvin(Convert.ToDouble(value));
-
-        #endregion
+            SpecificEntropy.FromMegajoulesPerKilogramKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificVolumeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
similarity index 78%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificVolumeExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
index 652342dd10..51e9ba11e1 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificVolumeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
@@ -19,37 +19,24 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToSpecificVolume
+namespace UnitsNet.NumberExtensions.NumberToSpecificVolume
 {
     /// <summary>
     /// A number to SpecificVolume Extensions
     /// </summary>
     public static class NumberToSpecificVolumeExtensions
     {
-
-        #region CubicFootPerPound
-
         /// <inheritdoc cref="SpecificVolume.FromCubicFeetPerPound(UnitsNet.QuantityValue)" />
         public static SpecificVolume CubicFeetPerPound<T>(this T value) =>
-             SpecificVolume.FromCubicFeetPerPound(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicMeterPerKilogram
+            SpecificVolume.FromCubicFeetPerPound(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificVolume.FromCubicMetersPerKilogram(UnitsNet.QuantityValue)" />
         public static SpecificVolume CubicMetersPerKilogram<T>(this T value) =>
-             SpecificVolume.FromCubicMetersPerKilogram(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillicubicMeterPerKilogram
+            SpecificVolume.FromCubicMetersPerKilogram(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificVolume.FromMillicubicMetersPerKilogram(UnitsNet.QuantityValue)" />
         public static SpecificVolume MillicubicMetersPerKilogram<T>(this T value) =>
-             SpecificVolume.FromMillicubicMetersPerKilogram(Convert.ToDouble(value));
-
-        #endregion
+            SpecificVolume.FromMillicubicMetersPerKilogram(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificWeightExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
similarity index 64%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificWeightExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
index bc6e27473d..688a4df4fc 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpecificWeightExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
@@ -19,149 +19,80 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToSpecificWeight
+namespace UnitsNet.NumberExtensions.NumberToSpecificWeight
 {
     /// <summary>
     /// A number to SpecificWeight Extensions
     /// </summary>
     public static class NumberToSpecificWeightExtensions
     {
-
-        #region KilogramForcePerCubicCentimeter
-
         /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicCentimeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight KilogramsForcePerCubicCentimeter<T>(this T value) =>
-             SpecificWeight.FromKilogramsForcePerCubicCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramForcePerCubicMeter
+            SpecificWeight.FromKilogramsForcePerCubicCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight KilogramsForcePerCubicMeter<T>(this T value) =>
-             SpecificWeight.FromKilogramsForcePerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramForcePerCubicMillimeter
+            SpecificWeight.FromKilogramsForcePerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMillimeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight KilogramsForcePerCubicMillimeter<T>(this T value) =>
-             SpecificWeight.FromKilogramsForcePerCubicMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonPerCubicCentimeter
+            SpecificWeight.FromKilogramsForcePerCubicMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicCentimeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight KilonewtonsPerCubicCentimeter<T>(this T value) =>
-             SpecificWeight.FromKilonewtonsPerCubicCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonPerCubicMeter
+            SpecificWeight.FromKilonewtonsPerCubicCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight KilonewtonsPerCubicMeter<T>(this T value) =>
-             SpecificWeight.FromKilonewtonsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonPerCubicMillimeter
+            SpecificWeight.FromKilonewtonsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMillimeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight KilonewtonsPerCubicMillimeter<T>(this T value) =>
-             SpecificWeight.FromKilonewtonsPerCubicMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundForcePerCubicFoot
+            SpecificWeight.FromKilonewtonsPerCubicMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicFoot(UnitsNet.QuantityValue)" />
         public static SpecificWeight KilopoundsForcePerCubicFoot<T>(this T value) =>
-             SpecificWeight.FromKilopoundsForcePerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundForcePerCubicInch
+            SpecificWeight.FromKilopoundsForcePerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicInch(UnitsNet.QuantityValue)" />
         public static SpecificWeight KilopoundsForcePerCubicInch<T>(this T value) =>
-             SpecificWeight.FromKilopoundsForcePerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeganewtonPerCubicMeter
+            SpecificWeight.FromKilopoundsForcePerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromMeganewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight MeganewtonsPerCubicMeter<T>(this T value) =>
-             SpecificWeight.FromMeganewtonsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonPerCubicCentimeter
+            SpecificWeight.FromMeganewtonsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicCentimeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight NewtonsPerCubicCentimeter<T>(this T value) =>
-             SpecificWeight.FromNewtonsPerCubicCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonPerCubicMeter
+            SpecificWeight.FromNewtonsPerCubicCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight NewtonsPerCubicMeter<T>(this T value) =>
-             SpecificWeight.FromNewtonsPerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonPerCubicMillimeter
+            SpecificWeight.FromNewtonsPerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMillimeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight NewtonsPerCubicMillimeter<T>(this T value) =>
-             SpecificWeight.FromNewtonsPerCubicMillimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForcePerCubicFoot
+            SpecificWeight.FromNewtonsPerCubicMillimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicFoot(UnitsNet.QuantityValue)" />
         public static SpecificWeight PoundsForcePerCubicFoot<T>(this T value) =>
-             SpecificWeight.FromPoundsForcePerCubicFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForcePerCubicInch
+            SpecificWeight.FromPoundsForcePerCubicFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicInch(UnitsNet.QuantityValue)" />
         public static SpecificWeight PoundsForcePerCubicInch<T>(this T value) =>
-             SpecificWeight.FromPoundsForcePerCubicInch(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForcePerCubicCentimeter
+            SpecificWeight.FromPoundsForcePerCubicInch(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicCentimeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight TonnesForcePerCubicCentimeter<T>(this T value) =>
-             SpecificWeight.FromTonnesForcePerCubicCentimeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForcePerCubicMeter
+            SpecificWeight.FromTonnesForcePerCubicCentimeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight TonnesForcePerCubicMeter<T>(this T value) =>
-             SpecificWeight.FromTonnesForcePerCubicMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForcePerCubicMillimeter
+            SpecificWeight.FromTonnesForcePerCubicMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMillimeter(UnitsNet.QuantityValue)" />
         public static SpecificWeight TonnesForcePerCubicMillimeter<T>(this T value) =>
-             SpecificWeight.FromTonnesForcePerCubicMillimeter(Convert.ToDouble(value));
-
-        #endregion
+            SpecificWeight.FromTonnesForcePerCubicMillimeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpeedExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
similarity index 61%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpeedExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
index bb116bfd0a..bf54c52987 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToSpeedExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
@@ -19,269 +19,140 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToSpeed
+namespace UnitsNet.NumberExtensions.NumberToSpeed
 {
     /// <summary>
     /// A number to Speed Extensions
     /// </summary>
     public static class NumberToSpeedExtensions
     {
-
-        #region CentimeterPerHour
-
         /// <inheritdoc cref="Speed.FromCentimetersPerHour(UnitsNet.QuantityValue)" />
         public static Speed CentimetersPerHour<T>(this T value) =>
-             Speed.FromCentimetersPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentimeterPerMinute
+            Speed.FromCentimetersPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromCentimetersPerMinutes(UnitsNet.QuantityValue)" />
         public static Speed CentimetersPerMinutes<T>(this T value) =>
-             Speed.FromCentimetersPerMinutes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentimeterPerSecond
+            Speed.FromCentimetersPerMinutes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromCentimetersPerSecond(UnitsNet.QuantityValue)" />
         public static Speed CentimetersPerSecond<T>(this T value) =>
-             Speed.FromCentimetersPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecimeterPerMinute
+            Speed.FromCentimetersPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromDecimetersPerMinutes(UnitsNet.QuantityValue)" />
         public static Speed DecimetersPerMinutes<T>(this T value) =>
-             Speed.FromDecimetersPerMinutes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecimeterPerSecond
+            Speed.FromDecimetersPerMinutes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromDecimetersPerSecond(UnitsNet.QuantityValue)" />
         public static Speed DecimetersPerSecond<T>(this T value) =>
-             Speed.FromDecimetersPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region FootPerHour
+            Speed.FromDecimetersPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromFeetPerHour(UnitsNet.QuantityValue)" />
         public static Speed FeetPerHour<T>(this T value) =>
-             Speed.FromFeetPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region FootPerMinute
+            Speed.FromFeetPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromFeetPerMinute(UnitsNet.QuantityValue)" />
         public static Speed FeetPerMinute<T>(this T value) =>
-             Speed.FromFeetPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region FootPerSecond
+            Speed.FromFeetPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromFeetPerSecond(UnitsNet.QuantityValue)" />
         public static Speed FeetPerSecond<T>(this T value) =>
-             Speed.FromFeetPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region InchPerHour
+            Speed.FromFeetPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromInchesPerHour(UnitsNet.QuantityValue)" />
         public static Speed InchesPerHour<T>(this T value) =>
-             Speed.FromInchesPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region InchPerMinute
+            Speed.FromInchesPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromInchesPerMinute(UnitsNet.QuantityValue)" />
         public static Speed InchesPerMinute<T>(this T value) =>
-             Speed.FromInchesPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region InchPerSecond
+            Speed.FromInchesPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromInchesPerSecond(UnitsNet.QuantityValue)" />
         public static Speed InchesPerSecond<T>(this T value) =>
-             Speed.FromInchesPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilometerPerHour
+            Speed.FromInchesPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromKilometersPerHour(UnitsNet.QuantityValue)" />
         public static Speed KilometersPerHour<T>(this T value) =>
-             Speed.FromKilometersPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilometerPerMinute
+            Speed.FromKilometersPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromKilometersPerMinutes(UnitsNet.QuantityValue)" />
         public static Speed KilometersPerMinutes<T>(this T value) =>
-             Speed.FromKilometersPerMinutes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilometerPerSecond
+            Speed.FromKilometersPerMinutes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromKilometersPerSecond(UnitsNet.QuantityValue)" />
         public static Speed KilometersPerSecond<T>(this T value) =>
-             Speed.FromKilometersPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Knot
+            Speed.FromKilometersPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromKnots(UnitsNet.QuantityValue)" />
         public static Speed Knots<T>(this T value) =>
-             Speed.FromKnots(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeterPerHour
+            Speed.FromKnots(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromMetersPerHour(UnitsNet.QuantityValue)" />
         public static Speed MetersPerHour<T>(this T value) =>
-             Speed.FromMetersPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeterPerMinute
+            Speed.FromMetersPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromMetersPerMinutes(UnitsNet.QuantityValue)" />
         public static Speed MetersPerMinutes<T>(this T value) =>
-             Speed.FromMetersPerMinutes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeterPerSecond
+            Speed.FromMetersPerMinutes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromMetersPerSecond(UnitsNet.QuantityValue)" />
         public static Speed MetersPerSecond<T>(this T value) =>
-             Speed.FromMetersPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrometerPerMinute
+            Speed.FromMetersPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromMicrometersPerMinutes(UnitsNet.QuantityValue)" />
         public static Speed MicrometersPerMinutes<T>(this T value) =>
-             Speed.FromMicrometersPerMinutes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrometerPerSecond
+            Speed.FromMicrometersPerMinutes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromMicrometersPerSecond(UnitsNet.QuantityValue)" />
         public static Speed MicrometersPerSecond<T>(this T value) =>
-             Speed.FromMicrometersPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilePerHour
+            Speed.FromMicrometersPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromMilesPerHour(UnitsNet.QuantityValue)" />
         public static Speed MilesPerHour<T>(this T value) =>
-             Speed.FromMilesPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillimeterPerHour
+            Speed.FromMilesPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromMillimetersPerHour(UnitsNet.QuantityValue)" />
         public static Speed MillimetersPerHour<T>(this T value) =>
-             Speed.FromMillimetersPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillimeterPerMinute
+            Speed.FromMillimetersPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromMillimetersPerMinutes(UnitsNet.QuantityValue)" />
         public static Speed MillimetersPerMinutes<T>(this T value) =>
-             Speed.FromMillimetersPerMinutes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillimeterPerSecond
+            Speed.FromMillimetersPerMinutes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromMillimetersPerSecond(UnitsNet.QuantityValue)" />
         public static Speed MillimetersPerSecond<T>(this T value) =>
-             Speed.FromMillimetersPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanometerPerMinute
+            Speed.FromMillimetersPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromNanometersPerMinutes(UnitsNet.QuantityValue)" />
         public static Speed NanometersPerMinutes<T>(this T value) =>
-             Speed.FromNanometersPerMinutes(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanometerPerSecond
+            Speed.FromNanometersPerMinutes(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromNanometersPerSecond(UnitsNet.QuantityValue)" />
         public static Speed NanometersPerSecond<T>(this T value) =>
-             Speed.FromNanometersPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsSurveyFootPerHour
+            Speed.FromNanometersPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromUsSurveyFeetPerHour(UnitsNet.QuantityValue)" />
         public static Speed UsSurveyFeetPerHour<T>(this T value) =>
-             Speed.FromUsSurveyFeetPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsSurveyFootPerMinute
+            Speed.FromUsSurveyFeetPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromUsSurveyFeetPerMinute(UnitsNet.QuantityValue)" />
         public static Speed UsSurveyFeetPerMinute<T>(this T value) =>
-             Speed.FromUsSurveyFeetPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsSurveyFootPerSecond
+            Speed.FromUsSurveyFeetPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromUsSurveyFeetPerSecond(UnitsNet.QuantityValue)" />
         public static Speed UsSurveyFeetPerSecond<T>(this T value) =>
-             Speed.FromUsSurveyFeetPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region YardPerHour
+            Speed.FromUsSurveyFeetPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromYardsPerHour(UnitsNet.QuantityValue)" />
         public static Speed YardsPerHour<T>(this T value) =>
-             Speed.FromYardsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region YardPerMinute
+            Speed.FromYardsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromYardsPerMinute(UnitsNet.QuantityValue)" />
         public static Speed YardsPerMinute<T>(this T value) =>
-             Speed.FromYardsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region YardPerSecond
+            Speed.FromYardsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Speed.FromYardsPerSecond(UnitsNet.QuantityValue)" />
         public static Speed YardsPerSecond<T>(this T value) =>
-             Speed.FromYardsPerSecond(Convert.ToDouble(value));
-
-        #endregion
+            Speed.FromYardsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
similarity index 68%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureChangeRateExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
index 5fa142aa6a..8011c5a166 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
@@ -19,93 +19,52 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToTemperatureChangeRate
+namespace UnitsNet.NumberExtensions.NumberToTemperatureChangeRate
 {
     /// <summary>
     /// A number to TemperatureChangeRate Extensions
     /// </summary>
     public static class NumberToTemperatureChangeRateExtensions
     {
-
-        #region CentidegreeCelsiusPerSecond
-
         /// <inheritdoc cref="TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
         public static TemperatureChangeRate CentidegreesCelsiusPerSecond<T>(this T value) =>
-             TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecadegreeCelsiusPerSecond
+            TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
         public static TemperatureChangeRate DecadegreesCelsiusPerSecond<T>(this T value) =>
-             TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecidegreeCelsiusPerSecond
+            TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
         public static TemperatureChangeRate DecidegreesCelsiusPerSecond<T>(this T value) =>
-             TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeCelsiusPerMinute
+            TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerMinute(UnitsNet.QuantityValue)" />
         public static TemperatureChangeRate DegreesCelsiusPerMinute<T>(this T value) =>
-             TemperatureChangeRate.FromDegreesCelsiusPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeCelsiusPerSecond
+            TemperatureChangeRate.FromDegreesCelsiusPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
         public static TemperatureChangeRate DegreesCelsiusPerSecond<T>(this T value) =>
-             TemperatureChangeRate.FromDegreesCelsiusPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region HectodegreeCelsiusPerSecond
+            TemperatureChangeRate.FromDegreesCelsiusPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
         public static TemperatureChangeRate HectodegreesCelsiusPerSecond<T>(this T value) =>
-             TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilodegreeCelsiusPerSecond
+            TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
         public static TemperatureChangeRate KilodegreesCelsiusPerSecond<T>(this T value) =>
-             TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrodegreeCelsiusPerSecond
+            TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
         public static TemperatureChangeRate MicrodegreesCelsiusPerSecond<T>(this T value) =>
-             TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillidegreeCelsiusPerSecond
+            TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
         public static TemperatureChangeRate MillidegreesCelsiusPerSecond<T>(this T value) =>
-             TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanodegreeCelsiusPerSecond
+            TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
         public static TemperatureChangeRate NanodegreesCelsiusPerSecond<T>(this T value) =>
-             TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(Convert.ToDouble(value));
-
-        #endregion
+            TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureDeltaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
similarity index 71%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureDeltaExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
index 091f54db63..449d3d3bdc 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureDeltaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
@@ -19,77 +19,44 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToTemperatureDelta
+namespace UnitsNet.NumberExtensions.NumberToTemperatureDelta
 {
     /// <summary>
     /// A number to TemperatureDelta Extensions
     /// </summary>
     public static class NumberToTemperatureDeltaExtensions
     {
-
-        #region DegreeCelsius
-
         /// <inheritdoc cref="TemperatureDelta.FromDegreesCelsius(UnitsNet.QuantityValue)" />
         public static TemperatureDelta DegreesCelsius<T>(this T value) =>
-             TemperatureDelta.FromDegreesCelsius(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeDelisle
+            TemperatureDelta.FromDegreesCelsius(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureDelta.FromDegreesDelisle(UnitsNet.QuantityValue)" />
         public static TemperatureDelta DegreesDelisle<T>(this T value) =>
-             TemperatureDelta.FromDegreesDelisle(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeFahrenheit
+            TemperatureDelta.FromDegreesDelisle(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureDelta.FromDegreesFahrenheit(UnitsNet.QuantityValue)" />
         public static TemperatureDelta DegreesFahrenheit<T>(this T value) =>
-             TemperatureDelta.FromDegreesFahrenheit(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeNewton
+            TemperatureDelta.FromDegreesFahrenheit(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureDelta.FromDegreesNewton(UnitsNet.QuantityValue)" />
         public static TemperatureDelta DegreesNewton<T>(this T value) =>
-             TemperatureDelta.FromDegreesNewton(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeRankine
+            TemperatureDelta.FromDegreesNewton(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureDelta.FromDegreesRankine(UnitsNet.QuantityValue)" />
         public static TemperatureDelta DegreesRankine<T>(this T value) =>
-             TemperatureDelta.FromDegreesRankine(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeReaumur
+            TemperatureDelta.FromDegreesRankine(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureDelta.FromDegreesReaumur(UnitsNet.QuantityValue)" />
         public static TemperatureDelta DegreesReaumur<T>(this T value) =>
-             TemperatureDelta.FromDegreesReaumur(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeRoemer
+            TemperatureDelta.FromDegreesReaumur(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureDelta.FromDegreesRoemer(UnitsNet.QuantityValue)" />
         public static TemperatureDelta DegreesRoemer<T>(this T value) =>
-             TemperatureDelta.FromDegreesRoemer(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kelvin
+            TemperatureDelta.FromDegreesRoemer(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TemperatureDelta.FromKelvins(UnitsNet.QuantityValue)" />
         public static TemperatureDelta Kelvins<T>(this T value) =>
-             TemperatureDelta.FromKelvins(Convert.ToDouble(value));
-
-        #endregion
+            TemperatureDelta.FromKelvins(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
similarity index 69%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
index da644bfe36..4ac4f3531c 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTemperatureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
@@ -19,85 +19,48 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToTemperature
+namespace UnitsNet.NumberExtensions.NumberToTemperature
 {
     /// <summary>
     /// A number to Temperature Extensions
     /// </summary>
     public static class NumberToTemperatureExtensions
     {
-
-        #region DegreeCelsius
-
         /// <inheritdoc cref="Temperature.FromDegreesCelsius(UnitsNet.QuantityValue)" />
         public static Temperature DegreesCelsius<T>(this T value) =>
-             Temperature.FromDegreesCelsius(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeDelisle
+            Temperature.FromDegreesCelsius(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Temperature.FromDegreesDelisle(UnitsNet.QuantityValue)" />
         public static Temperature DegreesDelisle<T>(this T value) =>
-             Temperature.FromDegreesDelisle(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeFahrenheit
+            Temperature.FromDegreesDelisle(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Temperature.FromDegreesFahrenheit(UnitsNet.QuantityValue)" />
         public static Temperature DegreesFahrenheit<T>(this T value) =>
-             Temperature.FromDegreesFahrenheit(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeNewton
+            Temperature.FromDegreesFahrenheit(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Temperature.FromDegreesNewton(UnitsNet.QuantityValue)" />
         public static Temperature DegreesNewton<T>(this T value) =>
-             Temperature.FromDegreesNewton(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeRankine
+            Temperature.FromDegreesNewton(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Temperature.FromDegreesRankine(UnitsNet.QuantityValue)" />
         public static Temperature DegreesRankine<T>(this T value) =>
-             Temperature.FromDegreesRankine(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeReaumur
+            Temperature.FromDegreesRankine(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Temperature.FromDegreesReaumur(UnitsNet.QuantityValue)" />
         public static Temperature DegreesReaumur<T>(this T value) =>
-             Temperature.FromDegreesReaumur(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DegreeRoemer
+            Temperature.FromDegreesReaumur(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Temperature.FromDegreesRoemer(UnitsNet.QuantityValue)" />
         public static Temperature DegreesRoemer<T>(this T value) =>
-             Temperature.FromDegreesRoemer(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kelvin
+            Temperature.FromDegreesRoemer(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Temperature.FromKelvins(UnitsNet.QuantityValue)" />
         public static Temperature Kelvins<T>(this T value) =>
-             Temperature.FromKelvins(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SolarTemperature
+            Temperature.FromKelvins(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Temperature.FromSolarTemperatures(UnitsNet.QuantityValue)" />
         public static Temperature SolarTemperatures<T>(this T value) =>
-             Temperature.FromSolarTemperatures(Convert.ToDouble(value));
-
-        #endregion
+            Temperature.FromSolarTemperatures(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToThermalConductivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
similarity index 81%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToThermalConductivityExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
index c353f6ddd4..d6d118a1d8 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToThermalConductivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
@@ -19,29 +19,20 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToThermalConductivity
+namespace UnitsNet.NumberExtensions.NumberToThermalConductivity
 {
     /// <summary>
     /// A number to ThermalConductivity Extensions
     /// </summary>
     public static class NumberToThermalConductivityExtensions
     {
-
-        #region BtuPerHourFootFahrenheit
-
         /// <inheritdoc cref="ThermalConductivity.FromBtusPerHourFootFahrenheit(UnitsNet.QuantityValue)" />
         public static ThermalConductivity BtusPerHourFootFahrenheit<T>(this T value) =>
-             ThermalConductivity.FromBtusPerHourFootFahrenheit(Convert.ToDouble(value));
-
-        #endregion
-
-        #region WattPerMeterKelvin
+            ThermalConductivity.FromBtusPerHourFootFahrenheit(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ThermalConductivity.FromWattsPerMeterKelvin(UnitsNet.QuantityValue)" />
         public static ThermalConductivity WattsPerMeterKelvin<T>(this T value) =>
-             ThermalConductivity.FromWattsPerMeterKelvin(Convert.ToDouble(value));
-
-        #endregion
+            ThermalConductivity.FromWattsPerMeterKelvin(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToThermalResistanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
similarity index 72%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToThermalResistanceExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
index d1bf9ea6f7..e294debde8 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToThermalResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
@@ -19,53 +19,32 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToThermalResistance
+namespace UnitsNet.NumberExtensions.NumberToThermalResistance
 {
     /// <summary>
     /// A number to ThermalResistance Extensions
     /// </summary>
     public static class NumberToThermalResistanceExtensions
     {
-
-        #region HourSquareFeetDegreeFahrenheitPerBtu
-
         /// <inheritdoc cref="ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(UnitsNet.QuantityValue)" />
         public static ThermalResistance HourSquareFeetDegreesFahrenheitPerBtu<T>(this T value) =>
-             ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareCentimeterHourDegreeCelsiusPerKilocalorie
+            ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(UnitsNet.QuantityValue)" />
         public static ThermalResistance SquareCentimeterHourDegreesCelsiusPerKilocalorie<T>(this T value) =>
-             ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareCentimeterKelvinPerWatt
+            ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ThermalResistance.FromSquareCentimeterKelvinsPerWatt(UnitsNet.QuantityValue)" />
         public static ThermalResistance SquareCentimeterKelvinsPerWatt<T>(this T value) =>
-             ThermalResistance.FromSquareCentimeterKelvinsPerWatt(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareMeterDegreeCelsiusPerWatt
+            ThermalResistance.FromSquareCentimeterKelvinsPerWatt(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(UnitsNet.QuantityValue)" />
         public static ThermalResistance SquareMeterDegreesCelsiusPerWatt<T>(this T value) =>
-             ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(Convert.ToDouble(value));
-
-        #endregion
-
-        #region SquareMeterKelvinPerKilowatt
+            ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(Convert.ToDouble(value));
 
         /// <inheritdoc cref="ThermalResistance.FromSquareMeterKelvinsPerKilowatt(UnitsNet.QuantityValue)" />
         public static ThermalResistance SquareMeterKelvinsPerKilowatt<T>(this T value) =>
-             ThermalResistance.FromSquareMeterKelvinsPerKilowatt(Convert.ToDouble(value));
-
-        #endregion
+            ThermalResistance.FromSquareMeterKelvinsPerKilowatt(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTorqueExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
similarity index 63%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTorqueExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
index 1b7684978b..3fb3a39746 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTorqueExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
@@ -19,181 +19,96 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToTorque
+namespace UnitsNet.NumberExtensions.NumberToTorque
 {
     /// <summary>
     /// A number to Torque Extensions
     /// </summary>
     public static class NumberToTorqueExtensions
     {
-
-        #region KilogramForceCentimeter
-
         /// <inheritdoc cref="Torque.FromKilogramForceCentimeters(UnitsNet.QuantityValue)" />
         public static Torque KilogramForceCentimeters<T>(this T value) =>
-             Torque.FromKilogramForceCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramForceMeter
+            Torque.FromKilogramForceCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromKilogramForceMeters(UnitsNet.QuantityValue)" />
         public static Torque KilogramForceMeters<T>(this T value) =>
-             Torque.FromKilogramForceMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramForceMillimeter
+            Torque.FromKilogramForceMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromKilogramForceMillimeters(UnitsNet.QuantityValue)" />
         public static Torque KilogramForceMillimeters<T>(this T value) =>
-             Torque.FromKilogramForceMillimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonCentimeter
+            Torque.FromKilogramForceMillimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromKilonewtonCentimeters(UnitsNet.QuantityValue)" />
         public static Torque KilonewtonCentimeters<T>(this T value) =>
-             Torque.FromKilonewtonCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonMeter
+            Torque.FromKilonewtonCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromKilonewtonMeters(UnitsNet.QuantityValue)" />
         public static Torque KilonewtonMeters<T>(this T value) =>
-             Torque.FromKilonewtonMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonMillimeter
+            Torque.FromKilonewtonMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromKilonewtonMillimeters(UnitsNet.QuantityValue)" />
         public static Torque KilonewtonMillimeters<T>(this T value) =>
-             Torque.FromKilonewtonMillimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundForceFoot
+            Torque.FromKilonewtonMillimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromKilopoundForceFeet(UnitsNet.QuantityValue)" />
         public static Torque KilopoundForceFeet<T>(this T value) =>
-             Torque.FromKilopoundForceFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundForceInch
+            Torque.FromKilopoundForceFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromKilopoundForceInches(UnitsNet.QuantityValue)" />
         public static Torque KilopoundForceInches<T>(this T value) =>
-             Torque.FromKilopoundForceInches(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeganewtonCentimeter
+            Torque.FromKilopoundForceInches(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromMeganewtonCentimeters(UnitsNet.QuantityValue)" />
         public static Torque MeganewtonCentimeters<T>(this T value) =>
-             Torque.FromMeganewtonCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeganewtonMeter
+            Torque.FromMeganewtonCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromMeganewtonMeters(UnitsNet.QuantityValue)" />
         public static Torque MeganewtonMeters<T>(this T value) =>
-             Torque.FromMeganewtonMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeganewtonMillimeter
+            Torque.FromMeganewtonMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromMeganewtonMillimeters(UnitsNet.QuantityValue)" />
         public static Torque MeganewtonMillimeters<T>(this T value) =>
-             Torque.FromMeganewtonMillimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegapoundForceFoot
+            Torque.FromMeganewtonMillimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromMegapoundForceFeet(UnitsNet.QuantityValue)" />
         public static Torque MegapoundForceFeet<T>(this T value) =>
-             Torque.FromMegapoundForceFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegapoundForceInch
+            Torque.FromMegapoundForceFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromMegapoundForceInches(UnitsNet.QuantityValue)" />
         public static Torque MegapoundForceInches<T>(this T value) =>
-             Torque.FromMegapoundForceInches(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonCentimeter
+            Torque.FromMegapoundForceInches(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromNewtonCentimeters(UnitsNet.QuantityValue)" />
         public static Torque NewtonCentimeters<T>(this T value) =>
-             Torque.FromNewtonCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonMeter
+            Torque.FromNewtonCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromNewtonMeters(UnitsNet.QuantityValue)" />
         public static Torque NewtonMeters<T>(this T value) =>
-             Torque.FromNewtonMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonMillimeter
+            Torque.FromNewtonMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromNewtonMillimeters(UnitsNet.QuantityValue)" />
         public static Torque NewtonMillimeters<T>(this T value) =>
-             Torque.FromNewtonMillimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForceFoot
+            Torque.FromNewtonMillimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromPoundForceFeet(UnitsNet.QuantityValue)" />
         public static Torque PoundForceFeet<T>(this T value) =>
-             Torque.FromPoundForceFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForceInch
+            Torque.FromPoundForceFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromPoundForceInches(UnitsNet.QuantityValue)" />
         public static Torque PoundForceInches<T>(this T value) =>
-             Torque.FromPoundForceInches(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForceCentimeter
+            Torque.FromPoundForceInches(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromTonneForceCentimeters(UnitsNet.QuantityValue)" />
         public static Torque TonneForceCentimeters<T>(this T value) =>
-             Torque.FromTonneForceCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForceMeter
+            Torque.FromTonneForceCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromTonneForceMeters(UnitsNet.QuantityValue)" />
         public static Torque TonneForceMeters<T>(this T value) =>
-             Torque.FromTonneForceMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForceMillimeter
+            Torque.FromTonneForceMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Torque.FromTonneForceMillimeters(UnitsNet.QuantityValue)" />
         public static Torque TonneForceMillimeters<T>(this T value) =>
-             Torque.FromTonneForceMillimeters(Convert.ToDouble(value));
-
-        #endregion
+            Torque.FromTonneForceMillimeters(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTorquePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorquePerLengthExtensions.g.cs
similarity index 63%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTorquePerLengthExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToTorquePerLengthExtensions.g.cs
index a3d73dad93..5321fcd598 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToTorquePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorquePerLengthExtensions.g.cs
@@ -19,181 +19,96 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToTorquePerLength
+namespace UnitsNet.NumberExtensions.NumberToTorquePerLength
 {
     /// <summary>
     /// A number to TorquePerLength Extensions
     /// </summary>
     public static class NumberToTorquePerLengthExtensions
     {
-
-        #region KilogramForceCentimeterPerMeter
-
         /// <inheritdoc cref="TorquePerLength.FromKilogramForceCentimetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength KilogramForceCentimetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromKilogramForceCentimetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramForceMeterPerMeter
+            TorquePerLength.FromKilogramForceCentimetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromKilogramForceMetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength KilogramForceMetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromKilogramForceMetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilogramForceMillimeterPerMeter
+            TorquePerLength.FromKilogramForceMetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromKilogramForceMillimetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength KilogramForceMillimetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromKilogramForceMillimetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonCentimeterPerMeter
+            TorquePerLength.FromKilogramForceMillimetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromKilonewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength KilonewtonCentimetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromKilonewtonCentimetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonMeterPerMeter
+            TorquePerLength.FromKilonewtonCentimetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromKilonewtonMetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength KilonewtonMetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromKilonewtonMetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilonewtonMillimeterPerMeter
+            TorquePerLength.FromKilonewtonMetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromKilonewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength KilonewtonMillimetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromKilonewtonMillimetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundForceFootPerFoot
+            TorquePerLength.FromKilonewtonMillimetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromKilopoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
         public static TorquePerLength KilopoundForceFeetPerFoot<T>(this T value) =>
-             TorquePerLength.FromKilopoundForceFeetPerFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilopoundForceInchPerFoot
+            TorquePerLength.FromKilopoundForceFeetPerFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromKilopoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
         public static TorquePerLength KilopoundForceInchesPerFoot<T>(this T value) =>
-             TorquePerLength.FromKilopoundForceInchesPerFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeganewtonCentimeterPerMeter
+            TorquePerLength.FromKilopoundForceInchesPerFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromMeganewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength MeganewtonCentimetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromMeganewtonCentimetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeganewtonMeterPerMeter
+            TorquePerLength.FromMeganewtonCentimetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromMeganewtonMetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength MeganewtonMetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromMeganewtonMetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MeganewtonMillimeterPerMeter
+            TorquePerLength.FromMeganewtonMetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromMeganewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength MeganewtonMillimetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromMeganewtonMillimetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegapoundForceFootPerFoot
+            TorquePerLength.FromMeganewtonMillimetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromMegapoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
         public static TorquePerLength MegapoundForceFeetPerFoot<T>(this T value) =>
-             TorquePerLength.FromMegapoundForceFeetPerFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegapoundForceInchPerFoot
+            TorquePerLength.FromMegapoundForceFeetPerFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromMegapoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
         public static TorquePerLength MegapoundForceInchesPerFoot<T>(this T value) =>
-             TorquePerLength.FromMegapoundForceInchesPerFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonCentimeterPerMeter
+            TorquePerLength.FromMegapoundForceInchesPerFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromNewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength NewtonCentimetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromNewtonCentimetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonMeterPerMeter
+            TorquePerLength.FromNewtonCentimetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromNewtonMetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength NewtonMetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromNewtonMetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NewtonMillimeterPerMeter
+            TorquePerLength.FromNewtonMetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromNewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength NewtonMillimetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromNewtonMillimetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForceFootPerFoot
+            TorquePerLength.FromNewtonMillimetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromPoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
         public static TorquePerLength PoundForceFeetPerFoot<T>(this T value) =>
-             TorquePerLength.FromPoundForceFeetPerFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PoundForceInchPerFoot
+            TorquePerLength.FromPoundForceFeetPerFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromPoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
         public static TorquePerLength PoundForceInchesPerFoot<T>(this T value) =>
-             TorquePerLength.FromPoundForceInchesPerFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForceCentimeterPerMeter
+            TorquePerLength.FromPoundForceInchesPerFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromTonneForceCentimetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength TonneForceCentimetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromTonneForceCentimetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForceMeterPerMeter
+            TorquePerLength.FromTonneForceCentimetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromTonneForceMetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength TonneForceMetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromTonneForceMetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region TonneForceMillimeterPerMeter
+            TorquePerLength.FromTonneForceMetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="TorquePerLength.FromTonneForceMillimetersPerMeter(UnitsNet.QuantityValue)" />
         public static TorquePerLength TonneForceMillimetersPerMeter<T>(this T value) =>
-             TorquePerLength.FromTonneForceMillimetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
+            TorquePerLength.FromTonneForceMillimetersPerMeter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVitaminAExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
similarity index 88%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVitaminAExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
index ce905e2455..1117e22710 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVitaminAExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
@@ -19,21 +19,16 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToVitaminA
+namespace UnitsNet.NumberExtensions.NumberToVitaminA
 {
     /// <summary>
     /// A number to VitaminA Extensions
     /// </summary>
     public static class NumberToVitaminAExtensions
     {
-
-        #region InternationalUnit
-
         /// <inheritdoc cref="VitaminA.FromInternationalUnits(UnitsNet.QuantityValue)" />
         public static VitaminA InternationalUnits<T>(this T value) =>
-             VitaminA.FromInternationalUnits(Convert.ToDouble(value));
-
-        #endregion
+            VitaminA.FromInternationalUnits(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
similarity index 65%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeConcentrationExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
index b848c421c8..019ebc8d62 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeConcentrationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
@@ -19,173 +19,92 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToVolumeConcentration
+namespace UnitsNet.NumberExtensions.NumberToVolumeConcentration
 {
     /// <summary>
     /// A number to VolumeConcentration Extensions
     /// </summary>
     public static class NumberToVolumeConcentrationExtensions
     {
-
-        #region CentilitersPerLiter
-
         /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerLiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration CentilitersPerLiter<T>(this T value) =>
-             VolumeConcentration.FromCentilitersPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentilitersPerMililiter
+            VolumeConcentration.FromCentilitersPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerMililiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration CentilitersPerMililiter<T>(this T value) =>
-             VolumeConcentration.FromCentilitersPerMililiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecilitersPerLiter
+            VolumeConcentration.FromCentilitersPerMililiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerLiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration DecilitersPerLiter<T>(this T value) =>
-             VolumeConcentration.FromDecilitersPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecilitersPerMililiter
+            VolumeConcentration.FromDecilitersPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerMililiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration DecilitersPerMililiter<T>(this T value) =>
-             VolumeConcentration.FromDecilitersPerMililiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DecimalFraction
+            VolumeConcentration.FromDecilitersPerMililiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromDecimalFractions(UnitsNet.QuantityValue)" />
         public static VolumeConcentration DecimalFractions<T>(this T value) =>
-             VolumeConcentration.FromDecimalFractions(Convert.ToDouble(value));
-
-        #endregion
-
-        #region LitersPerLiter
+            VolumeConcentration.FromDecimalFractions(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromLitersPerLiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration LitersPerLiter<T>(this T value) =>
-             VolumeConcentration.FromLitersPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region LitersPerMililiter
+            VolumeConcentration.FromLitersPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromLitersPerMililiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration LitersPerMililiter<T>(this T value) =>
-             VolumeConcentration.FromLitersPerMililiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrolitersPerLiter
+            VolumeConcentration.FromLitersPerMililiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerLiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration MicrolitersPerLiter<T>(this T value) =>
-             VolumeConcentration.FromMicrolitersPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicrolitersPerMililiter
+            VolumeConcentration.FromMicrolitersPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerMililiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration MicrolitersPerMililiter<T>(this T value) =>
-             VolumeConcentration.FromMicrolitersPerMililiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillilitersPerLiter
+            VolumeConcentration.FromMicrolitersPerMililiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerLiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration MillilitersPerLiter<T>(this T value) =>
-             VolumeConcentration.FromMillilitersPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillilitersPerMililiter
+            VolumeConcentration.FromMillilitersPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerMililiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration MillilitersPerMililiter<T>(this T value) =>
-             VolumeConcentration.FromMillilitersPerMililiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanolitersPerLiter
+            VolumeConcentration.FromMillilitersPerMililiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerLiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration NanolitersPerLiter<T>(this T value) =>
-             VolumeConcentration.FromNanolitersPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanolitersPerMililiter
+            VolumeConcentration.FromNanolitersPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerMililiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration NanolitersPerMililiter<T>(this T value) =>
-             VolumeConcentration.FromNanolitersPerMililiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerBillion
+            VolumeConcentration.FromNanolitersPerMililiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromPartsPerBillion(UnitsNet.QuantityValue)" />
         public static VolumeConcentration PartsPerBillion<T>(this T value) =>
-             VolumeConcentration.FromPartsPerBillion(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerMillion
+            VolumeConcentration.FromPartsPerBillion(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromPartsPerMillion(UnitsNet.QuantityValue)" />
         public static VolumeConcentration PartsPerMillion<T>(this T value) =>
-             VolumeConcentration.FromPartsPerMillion(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerThousand
+            VolumeConcentration.FromPartsPerMillion(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromPartsPerThousand(UnitsNet.QuantityValue)" />
         public static VolumeConcentration PartsPerThousand<T>(this T value) =>
-             VolumeConcentration.FromPartsPerThousand(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PartPerTrillion
+            VolumeConcentration.FromPartsPerThousand(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
         public static VolumeConcentration PartsPerTrillion<T>(this T value) =>
-             VolumeConcentration.FromPartsPerTrillion(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Percent
+            VolumeConcentration.FromPartsPerTrillion(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromPercent(UnitsNet.QuantityValue)" />
         public static VolumeConcentration Percent<T>(this T value) =>
-             VolumeConcentration.FromPercent(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicolitersPerLiter
+            VolumeConcentration.FromPercent(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerLiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration PicolitersPerLiter<T>(this T value) =>
-             VolumeConcentration.FromPicolitersPerLiter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region PicolitersPerMililiter
+            VolumeConcentration.FromPicolitersPerLiter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerMililiter(UnitsNet.QuantityValue)" />
         public static VolumeConcentration PicolitersPerMililiter<T>(this T value) =>
-             VolumeConcentration.FromPicolitersPerMililiter(Convert.ToDouble(value));
-
-        #endregion
+            VolumeConcentration.FromPicolitersPerMililiter(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
similarity index 60%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
index 4aca579766..b037633869 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
@@ -19,389 +19,200 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToVolume
+namespace UnitsNet.NumberExtensions.NumberToVolume
 {
     /// <summary>
     /// A number to Volume Extensions
     /// </summary>
     public static class NumberToVolumeExtensions
     {
-
-        #region AcreFoot
-
         /// <inheritdoc cref="Volume.FromAcreFeet(UnitsNet.QuantityValue)" />
         public static Volume AcreFeet<T>(this T value) =>
-             Volume.FromAcreFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region AuTablespoon
+            Volume.FromAcreFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromAuTablespoons(UnitsNet.QuantityValue)" />
         public static Volume AuTablespoons<T>(this T value) =>
-             Volume.FromAuTablespoons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Centiliter
+            Volume.FromAuTablespoons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCentiliters(UnitsNet.QuantityValue)" />
         public static Volume Centiliters<T>(this T value) =>
-             Volume.FromCentiliters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicCentimeter
+            Volume.FromCentiliters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCubicCentimeters(UnitsNet.QuantityValue)" />
         public static Volume CubicCentimeters<T>(this T value) =>
-             Volume.FromCubicCentimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicDecimeter
+            Volume.FromCubicCentimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCubicDecimeters(UnitsNet.QuantityValue)" />
         public static Volume CubicDecimeters<T>(this T value) =>
-             Volume.FromCubicDecimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicFoot
+            Volume.FromCubicDecimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCubicFeet(UnitsNet.QuantityValue)" />
         public static Volume CubicFeet<T>(this T value) =>
-             Volume.FromCubicFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicHectometer
+            Volume.FromCubicFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCubicHectometers(UnitsNet.QuantityValue)" />
         public static Volume CubicHectometers<T>(this T value) =>
-             Volume.FromCubicHectometers(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicInch
+            Volume.FromCubicHectometers(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCubicInches(UnitsNet.QuantityValue)" />
         public static Volume CubicInches<T>(this T value) =>
-             Volume.FromCubicInches(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicKilometer
+            Volume.FromCubicInches(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCubicKilometers(UnitsNet.QuantityValue)" />
         public static Volume CubicKilometers<T>(this T value) =>
-             Volume.FromCubicKilometers(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicMeter
+            Volume.FromCubicKilometers(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCubicMeters(UnitsNet.QuantityValue)" />
         public static Volume CubicMeters<T>(this T value) =>
-             Volume.FromCubicMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicMicrometer
+            Volume.FromCubicMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCubicMicrometers(UnitsNet.QuantityValue)" />
         public static Volume CubicMicrometers<T>(this T value) =>
-             Volume.FromCubicMicrometers(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicMile
+            Volume.FromCubicMicrometers(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCubicMiles(UnitsNet.QuantityValue)" />
         public static Volume CubicMiles<T>(this T value) =>
-             Volume.FromCubicMiles(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicMillimeter
+            Volume.FromCubicMiles(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCubicMillimeters(UnitsNet.QuantityValue)" />
         public static Volume CubicMillimeters<T>(this T value) =>
-             Volume.FromCubicMillimeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicYard
+            Volume.FromCubicMillimeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromCubicYards(UnitsNet.QuantityValue)" />
         public static Volume CubicYards<T>(this T value) =>
-             Volume.FromCubicYards(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Deciliter
+            Volume.FromCubicYards(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromDeciliters(UnitsNet.QuantityValue)" />
         public static Volume Deciliters<T>(this T value) =>
-             Volume.FromDeciliters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region HectocubicFoot
+            Volume.FromDeciliters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromHectocubicFeet(UnitsNet.QuantityValue)" />
         public static Volume HectocubicFeet<T>(this T value) =>
-             Volume.FromHectocubicFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region HectocubicMeter
+            Volume.FromHectocubicFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromHectocubicMeters(UnitsNet.QuantityValue)" />
         public static Volume HectocubicMeters<T>(this T value) =>
-             Volume.FromHectocubicMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Hectoliter
+            Volume.FromHectocubicMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromHectoliters(UnitsNet.QuantityValue)" />
         public static Volume Hectoliters<T>(this T value) =>
-             Volume.FromHectoliters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ImperialBeerBarrel
+            Volume.FromHectoliters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromImperialBeerBarrels(UnitsNet.QuantityValue)" />
         public static Volume ImperialBeerBarrels<T>(this T value) =>
-             Volume.FromImperialBeerBarrels(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ImperialGallon
+            Volume.FromImperialBeerBarrels(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromImperialGallons(UnitsNet.QuantityValue)" />
         public static Volume ImperialGallons<T>(this T value) =>
-             Volume.FromImperialGallons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ImperialOunce
+            Volume.FromImperialGallons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromImperialOunces(UnitsNet.QuantityValue)" />
         public static Volume ImperialOunces<T>(this T value) =>
-             Volume.FromImperialOunces(Convert.ToDouble(value));
-
-        #endregion
-
-        #region ImperialPint
+            Volume.FromImperialOunces(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromImperialPints(UnitsNet.QuantityValue)" />
         public static Volume ImperialPints<T>(this T value) =>
-             Volume.FromImperialPints(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilocubicFoot
+            Volume.FromImperialPints(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromKilocubicFeet(UnitsNet.QuantityValue)" />
         public static Volume KilocubicFeet<T>(this T value) =>
-             Volume.FromKilocubicFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilocubicMeter
+            Volume.FromKilocubicFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromKilocubicMeters(UnitsNet.QuantityValue)" />
         public static Volume KilocubicMeters<T>(this T value) =>
-             Volume.FromKilocubicMeters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KiloimperialGallon
+            Volume.FromKilocubicMeters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromKiloimperialGallons(UnitsNet.QuantityValue)" />
         public static Volume KiloimperialGallons<T>(this T value) =>
-             Volume.FromKiloimperialGallons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Kiloliter
+            Volume.FromKiloimperialGallons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromKiloliters(UnitsNet.QuantityValue)" />
         public static Volume Kiloliters<T>(this T value) =>
-             Volume.FromKiloliters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilousGallon
+            Volume.FromKiloliters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromKilousGallons(UnitsNet.QuantityValue)" />
         public static Volume KilousGallons<T>(this T value) =>
-             Volume.FromKilousGallons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Liter
+            Volume.FromKilousGallons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromLiters(UnitsNet.QuantityValue)" />
         public static Volume Liters<T>(this T value) =>
-             Volume.FromLiters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegacubicFoot
+            Volume.FromLiters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromMegacubicFeet(UnitsNet.QuantityValue)" />
         public static Volume MegacubicFeet<T>(this T value) =>
-             Volume.FromMegacubicFeet(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegaimperialGallon
+            Volume.FromMegacubicFeet(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromMegaimperialGallons(UnitsNet.QuantityValue)" />
         public static Volume MegaimperialGallons<T>(this T value) =>
-             Volume.FromMegaimperialGallons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Megaliter
+            Volume.FromMegaimperialGallons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromMegaliters(UnitsNet.QuantityValue)" />
         public static Volume Megaliters<T>(this T value) =>
-             Volume.FromMegaliters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegausGallon
+            Volume.FromMegaliters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromMegausGallons(UnitsNet.QuantityValue)" />
         public static Volume MegausGallons<T>(this T value) =>
-             Volume.FromMegausGallons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MetricCup
+            Volume.FromMegausGallons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromMetricCups(UnitsNet.QuantityValue)" />
         public static Volume MetricCups<T>(this T value) =>
-             Volume.FromMetricCups(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MetricTeaspoon
+            Volume.FromMetricCups(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromMetricTeaspoons(UnitsNet.QuantityValue)" />
         public static Volume MetricTeaspoons<T>(this T value) =>
-             Volume.FromMetricTeaspoons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Microliter
+            Volume.FromMetricTeaspoons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromMicroliters(UnitsNet.QuantityValue)" />
         public static Volume Microliters<T>(this T value) =>
-             Volume.FromMicroliters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region Milliliter
+            Volume.FromMicroliters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromMilliliters(UnitsNet.QuantityValue)" />
         public static Volume Milliliters<T>(this T value) =>
-             Volume.FromMilliliters(Convert.ToDouble(value));
-
-        #endregion
-
-        #region OilBarrel
+            Volume.FromMilliliters(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromOilBarrels(UnitsNet.QuantityValue)" />
         public static Volume OilBarrels<T>(this T value) =>
-             Volume.FromOilBarrels(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UkTablespoon
+            Volume.FromOilBarrels(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromUkTablespoons(UnitsNet.QuantityValue)" />
         public static Volume UkTablespoons<T>(this T value) =>
-             Volume.FromUkTablespoons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsBeerBarrel
+            Volume.FromUkTablespoons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromUsBeerBarrels(UnitsNet.QuantityValue)" />
         public static Volume UsBeerBarrels<T>(this T value) =>
-             Volume.FromUsBeerBarrels(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsCustomaryCup
+            Volume.FromUsBeerBarrels(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromUsCustomaryCups(UnitsNet.QuantityValue)" />
         public static Volume UsCustomaryCups<T>(this T value) =>
-             Volume.FromUsCustomaryCups(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsGallon
+            Volume.FromUsCustomaryCups(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromUsGallons(UnitsNet.QuantityValue)" />
         public static Volume UsGallons<T>(this T value) =>
-             Volume.FromUsGallons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsLegalCup
+            Volume.FromUsGallons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromUsLegalCups(UnitsNet.QuantityValue)" />
         public static Volume UsLegalCups<T>(this T value) =>
-             Volume.FromUsLegalCups(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsOunce
+            Volume.FromUsLegalCups(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromUsOunces(UnitsNet.QuantityValue)" />
         public static Volume UsOunces<T>(this T value) =>
-             Volume.FromUsOunces(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsPint
+            Volume.FromUsOunces(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromUsPints(UnitsNet.QuantityValue)" />
         public static Volume UsPints<T>(this T value) =>
-             Volume.FromUsPints(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsQuart
+            Volume.FromUsPints(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromUsQuarts(UnitsNet.QuantityValue)" />
         public static Volume UsQuarts<T>(this T value) =>
-             Volume.FromUsQuarts(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsTablespoon
+            Volume.FromUsQuarts(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromUsTablespoons(UnitsNet.QuantityValue)" />
         public static Volume UsTablespoons<T>(this T value) =>
-             Volume.FromUsTablespoons(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsTeaspoon
+            Volume.FromUsTablespoons(Convert.ToDouble(value));
 
         /// <inheritdoc cref="Volume.FromUsTeaspoons(UnitsNet.QuantityValue)" />
         public static Volume UsTeaspoons<T>(this T value) =>
-             Volume.FromUsTeaspoons(Convert.ToDouble(value));
-
-        #endregion
+            Volume.FromUsTeaspoons(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
similarity index 61%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeFlowExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
index 8c243707ad..7adb12f751 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumeFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
@@ -19,405 +19,208 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToVolumeFlow
+namespace UnitsNet.NumberExtensions.NumberToVolumeFlow
 {
     /// <summary>
     /// A number to VolumeFlow Extensions
     /// </summary>
     public static class NumberToVolumeFlowExtensions
     {
-
-        #region AcreFootPerDay
-
         /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow AcreFeetPerDay<T>(this T value) =>
-             VolumeFlow.FromAcreFeetPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region AcreFootPerHour
+            VolumeFlow.FromAcreFeetPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerHour(UnitsNet.QuantityValue)" />
         public static VolumeFlow AcreFeetPerHour<T>(this T value) =>
-             VolumeFlow.FromAcreFeetPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region AcreFootPerMinute
+            VolumeFlow.FromAcreFeetPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow AcreFeetPerMinute<T>(this T value) =>
-             VolumeFlow.FromAcreFeetPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region AcreFootPerSecond
+            VolumeFlow.FromAcreFeetPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerSecond(UnitsNet.QuantityValue)" />
         public static VolumeFlow AcreFeetPerSecond<T>(this T value) =>
-             VolumeFlow.FromAcreFeetPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentiliterPerDay
+            VolumeFlow.FromAcreFeetPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCentilitersPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow CentilitersPerDay<T>(this T value) =>
-             VolumeFlow.FromCentilitersPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CentiliterPerMinute
+            VolumeFlow.FromCentilitersPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCentilitersPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow CentilitersPerMinute<T>(this T value) =>
-             VolumeFlow.FromCentilitersPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicDecimeterPerMinute
+            VolumeFlow.FromCentilitersPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicDecimetersPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicDecimetersPerMinute<T>(this T value) =>
-             VolumeFlow.FromCubicDecimetersPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicFootPerHour
+            VolumeFlow.FromCubicDecimetersPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerHour(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicFeetPerHour<T>(this T value) =>
-             VolumeFlow.FromCubicFeetPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicFootPerMinute
+            VolumeFlow.FromCubicFeetPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicFeetPerMinute<T>(this T value) =>
-             VolumeFlow.FromCubicFeetPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicFootPerSecond
+            VolumeFlow.FromCubicFeetPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerSecond(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicFeetPerSecond<T>(this T value) =>
-             VolumeFlow.FromCubicFeetPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicMeterPerDay
+            VolumeFlow.FromCubicFeetPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicMetersPerDay<T>(this T value) =>
-             VolumeFlow.FromCubicMetersPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicMeterPerHour
+            VolumeFlow.FromCubicMetersPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerHour(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicMetersPerHour<T>(this T value) =>
-             VolumeFlow.FromCubicMetersPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicMeterPerMinute
+            VolumeFlow.FromCubicMetersPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicMetersPerMinute<T>(this T value) =>
-             VolumeFlow.FromCubicMetersPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicMeterPerSecond
+            VolumeFlow.FromCubicMetersPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerSecond(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicMetersPerSecond<T>(this T value) =>
-             VolumeFlow.FromCubicMetersPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicMillimeterPerSecond
+            VolumeFlow.FromCubicMetersPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicMillimetersPerSecond(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicMillimetersPerSecond<T>(this T value) =>
-             VolumeFlow.FromCubicMillimetersPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicYardPerDay
+            VolumeFlow.FromCubicMillimetersPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicYardsPerDay<T>(this T value) =>
-             VolumeFlow.FromCubicYardsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicYardPerHour
+            VolumeFlow.FromCubicYardsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerHour(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicYardsPerHour<T>(this T value) =>
-             VolumeFlow.FromCubicYardsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicYardPerMinute
+            VolumeFlow.FromCubicYardsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicYardsPerMinute<T>(this T value) =>
-             VolumeFlow.FromCubicYardsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicYardPerSecond
+            VolumeFlow.FromCubicYardsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerSecond(UnitsNet.QuantityValue)" />
         public static VolumeFlow CubicYardsPerSecond<T>(this T value) =>
-             VolumeFlow.FromCubicYardsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DeciliterPerDay
+            VolumeFlow.FromCubicYardsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromDecilitersPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow DecilitersPerDay<T>(this T value) =>
-             VolumeFlow.FromDecilitersPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region DeciliterPerMinute
+            VolumeFlow.FromDecilitersPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromDecilitersPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow DecilitersPerMinute<T>(this T value) =>
-             VolumeFlow.FromDecilitersPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KiloliterPerDay
+            VolumeFlow.FromDecilitersPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromKilolitersPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow KilolitersPerDay<T>(this T value) =>
-             VolumeFlow.FromKilolitersPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KiloliterPerMinute
+            VolumeFlow.FromKilolitersPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromKilolitersPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow KilolitersPerMinute<T>(this T value) =>
-             VolumeFlow.FromKilolitersPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region KilousGallonPerMinute
+            VolumeFlow.FromKilolitersPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromKilousGallonsPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow KilousGallonsPerMinute<T>(this T value) =>
-             VolumeFlow.FromKilousGallonsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region LiterPerDay
+            VolumeFlow.FromKilousGallonsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromLitersPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow LitersPerDay<T>(this T value) =>
-             VolumeFlow.FromLitersPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region LiterPerHour
+            VolumeFlow.FromLitersPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromLitersPerHour(UnitsNet.QuantityValue)" />
         public static VolumeFlow LitersPerHour<T>(this T value) =>
-             VolumeFlow.FromLitersPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region LiterPerMinute
+            VolumeFlow.FromLitersPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromLitersPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow LitersPerMinute<T>(this T value) =>
-             VolumeFlow.FromLitersPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region LiterPerSecond
+            VolumeFlow.FromLitersPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromLitersPerSecond(UnitsNet.QuantityValue)" />
         public static VolumeFlow LitersPerSecond<T>(this T value) =>
-             VolumeFlow.FromLitersPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegaliterPerDay
+            VolumeFlow.FromLitersPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromMegalitersPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow MegalitersPerDay<T>(this T value) =>
-             VolumeFlow.FromMegalitersPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MegaukGallonPerSecond
+            VolumeFlow.FromMegalitersPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerSecond(UnitsNet.QuantityValue)" />
         public static VolumeFlow MegaukGallonsPerSecond<T>(this T value) =>
-             VolumeFlow.FromMegaukGallonsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicroliterPerDay
+            VolumeFlow.FromMegaukGallonsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow MicrolitersPerDay<T>(this T value) =>
-             VolumeFlow.FromMicrolitersPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MicroliterPerMinute
+            VolumeFlow.FromMicrolitersPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow MicrolitersPerMinute<T>(this T value) =>
-             VolumeFlow.FromMicrolitersPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliliterPerDay
+            VolumeFlow.FromMicrolitersPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromMillilitersPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow MillilitersPerDay<T>(this T value) =>
-             VolumeFlow.FromMillilitersPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MilliliterPerMinute
+            VolumeFlow.FromMillilitersPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromMillilitersPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow MillilitersPerMinute<T>(this T value) =>
-             VolumeFlow.FromMillilitersPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region MillionUsGallonsPerDay
+            VolumeFlow.FromMillilitersPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromMillionUsGallonsPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow MillionUsGallonsPerDay<T>(this T value) =>
-             VolumeFlow.FromMillionUsGallonsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanoliterPerDay
+            VolumeFlow.FromMillionUsGallonsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromNanolitersPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow NanolitersPerDay<T>(this T value) =>
-             VolumeFlow.FromNanolitersPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region NanoliterPerMinute
+            VolumeFlow.FromNanolitersPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromNanolitersPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow NanolitersPerMinute<T>(this T value) =>
-             VolumeFlow.FromNanolitersPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region OilBarrelPerDay
+            VolumeFlow.FromNanolitersPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow OilBarrelsPerDay<T>(this T value) =>
-             VolumeFlow.FromOilBarrelsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region OilBarrelPerHour
+            VolumeFlow.FromOilBarrelsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerHour(UnitsNet.QuantityValue)" />
         public static VolumeFlow OilBarrelsPerHour<T>(this T value) =>
-             VolumeFlow.FromOilBarrelsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region OilBarrelPerMinute
+            VolumeFlow.FromOilBarrelsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow OilBarrelsPerMinute<T>(this T value) =>
-             VolumeFlow.FromOilBarrelsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region OilBarrelPerSecond
+            VolumeFlow.FromOilBarrelsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerSecond(UnitsNet.QuantityValue)" />
         public static VolumeFlow OilBarrelsPerSecond<T>(this T value) =>
-             VolumeFlow.FromOilBarrelsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UkGallonPerDay
+            VolumeFlow.FromOilBarrelsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow UkGallonsPerDay<T>(this T value) =>
-             VolumeFlow.FromUkGallonsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UkGallonPerHour
+            VolumeFlow.FromUkGallonsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerHour(UnitsNet.QuantityValue)" />
         public static VolumeFlow UkGallonsPerHour<T>(this T value) =>
-             VolumeFlow.FromUkGallonsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UkGallonPerMinute
+            VolumeFlow.FromUkGallonsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow UkGallonsPerMinute<T>(this T value) =>
-             VolumeFlow.FromUkGallonsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UkGallonPerSecond
+            VolumeFlow.FromUkGallonsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerSecond(UnitsNet.QuantityValue)" />
         public static VolumeFlow UkGallonsPerSecond<T>(this T value) =>
-             VolumeFlow.FromUkGallonsPerSecond(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsGallonPerDay
+            VolumeFlow.FromUkGallonsPerSecond(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerDay(UnitsNet.QuantityValue)" />
         public static VolumeFlow UsGallonsPerDay<T>(this T value) =>
-             VolumeFlow.FromUsGallonsPerDay(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsGallonPerHour
+            VolumeFlow.FromUsGallonsPerDay(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerHour(UnitsNet.QuantityValue)" />
         public static VolumeFlow UsGallonsPerHour<T>(this T value) =>
-             VolumeFlow.FromUsGallonsPerHour(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsGallonPerMinute
+            VolumeFlow.FromUsGallonsPerHour(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerMinute(UnitsNet.QuantityValue)" />
         public static VolumeFlow UsGallonsPerMinute<T>(this T value) =>
-             VolumeFlow.FromUsGallonsPerMinute(Convert.ToDouble(value));
-
-        #endregion
-
-        #region UsGallonPerSecond
+            VolumeFlow.FromUsGallonsPerMinute(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerSecond(UnitsNet.QuantityValue)" />
         public static VolumeFlow UsGallonsPerSecond<T>(this T value) =>
-             VolumeFlow.FromUsGallonsPerSecond(Convert.ToDouble(value));
-
-        #endregion
+            VolumeFlow.FromUsGallonsPerSecond(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
similarity index 73%
rename from UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumePerLengthExtensions.g.cs
rename to UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
index 4d673864c9..7895e58e9a 100644
--- a/UnitsNet.Extensions/GeneratedCode/NumberToExtensions/NumberToVolumePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
@@ -19,53 +19,32 @@
 
 using System;
                         
-namespace UnitsNet.Extensions.NumberToVolumePerLength
+namespace UnitsNet.NumberExtensions.NumberToVolumePerLength
 {
     /// <summary>
     /// A number to VolumePerLength Extensions
     /// </summary>
     public static class NumberToVolumePerLengthExtensions
     {
-
-        #region CubicMeterPerMeter
-
         /// <inheritdoc cref="VolumePerLength.FromCubicMetersPerMeter(UnitsNet.QuantityValue)" />
         public static VolumePerLength CubicMetersPerMeter<T>(this T value) =>
-             VolumePerLength.FromCubicMetersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicYardPerFoot
+            VolumePerLength.FromCubicMetersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerFoot(UnitsNet.QuantityValue)" />
         public static VolumePerLength CubicYardsPerFoot<T>(this T value) =>
-             VolumePerLength.FromCubicYardsPerFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region CubicYardPerUsSurveyFoot
+            VolumePerLength.FromCubicYardsPerFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerUsSurveyFoot(UnitsNet.QuantityValue)" />
         public static VolumePerLength CubicYardsPerUsSurveyFoot<T>(this T value) =>
-             VolumePerLength.FromCubicYardsPerUsSurveyFoot(Convert.ToDouble(value));
-
-        #endregion
-
-        #region LiterPerMeter
+            VolumePerLength.FromCubicYardsPerUsSurveyFoot(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumePerLength.FromLitersPerMeter(UnitsNet.QuantityValue)" />
         public static VolumePerLength LitersPerMeter<T>(this T value) =>
-             VolumePerLength.FromLitersPerMeter(Convert.ToDouble(value));
-
-        #endregion
-
-        #region OilBarrelPerFoot
+            VolumePerLength.FromLitersPerMeter(Convert.ToDouble(value));
 
         /// <inheritdoc cref="VolumePerLength.FromOilBarrelsPerFoot(UnitsNet.QuantityValue)" />
         public static VolumePerLength OilBarrelsPerFoot<T>(this T value) =>
-             VolumePerLength.FromOilBarrelsPerFoot(Convert.ToDouble(value));
-
-        #endregion
+            VolumePerLength.FromOilBarrelsPerFoot(Convert.ToDouble(value));
 
     }
 }
diff --git a/UnitsNet.Extensions/UnitsNet.Extensions.csproj b/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
similarity index 78%
rename from UnitsNet.Extensions/UnitsNet.Extensions.csproj
rename to UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
index 8e6790ccdf..3cd9fa3e80 100644
--- a/UnitsNet.Extensions/UnitsNet.Extensions.csproj
+++ b/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
@@ -1,11 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <!-- NuGet properties -->
   <PropertyGroup>
-    <PackageId>UnitsNet.Extensions</PackageId>
-    <Version>1.0.0</Version>
+    <PackageId>UnitsNet.NumberExtensions</PackageId>
+    <Version>4.43.0</Version>
     <Authors>Andreas Gullberg Larsen</Authors>
-    <Title>Units.NET Extensions</Title>
-    <Description>A extension library for Units.NET.</Description>
+    <Title>Units.NET NumberExtensions</Title>
+    <Description>Adds extension methods to number types to more easily create quantities, such as 5.Meters() instead of Length.FromMeters(5).</Description>
     <Copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</Copyright>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <RepositoryUrl>https://github.com/angularsen/UnitsNet</RepositoryUrl>
@@ -13,11 +13,11 @@
     <PackageProjectUrl>https://github.com/angularsen/UnitsNet</PackageProjectUrl>
     <PackageLicenseExpression>MIT-0</PackageLicenseExpression>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
-    <PackageTags>UnitsNet Extensions NumberToExtensions NumberToUnitsExtensions NumberToUnits convert conversion parse</PackageTags>
+    <PackageTags>UnitsNet Extensions NumberToExtensions NumberToUnitsExtensions NumberExtensions NumberToUnits convert conversion parse</PackageTags>
   </PropertyGroup>
 
   <PropertyGroup>
-    <AssemblyVersion>1.0.0.0</AssemblyVersion>
+    <AssemblyVersion>4.0.0.0</AssemblyVersion>
     <LangVersion>latest</LangVersion>
     <RootNamespace>UnitsNet</RootNamespace>
     <TargetFrameworks>netstandard2.0;net40</TargetFrameworks>
diff --git a/UnitsNet.sln b/UnitsNet.sln
index 5a031f6198..5d2636654c 100644
--- a/UnitsNet.sln
+++ b/UnitsNet.sln
@@ -17,9 +17,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitsNet.Benchmark", "Units
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CodeGen", "CodeGen\CodeGen.csproj", "{078E3D44-4F60-46B3-9099-91A7CBF0B213}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitsNet.Extensions", "UnitsNet.Extensions\UnitsNet.Extensions.csproj", "{41763DBA-0F2D-40D2-853C-2CBF719C7208}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitsNet.NumberExtensions", "UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj", "{41763DBA-0F2D-40D2-853C-2CBF719C7208}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitsNet.Extensions.Tests", "UnitsNet.Extensions.Tests\UnitsNet.Extensions.Tests.csproj", "{32DC928D-5E5E-4BD4-AEF4-D46705E46126}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitsNet.NumberExtensions.Tests", "UnitsNet.NumberExtensions.Tests\UnitsNet.NumberExtensions.Tests.csproj", "{B4996AF5-9A8B-481A-9018-EC7F5B1605FF}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -59,10 +59,10 @@ Global
 		{41763DBA-0F2D-40D2-853C-2CBF719C7208}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{41763DBA-0F2D-40D2-853C-2CBF719C7208}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{41763DBA-0F2D-40D2-853C-2CBF719C7208}.Release|Any CPU.Build.0 = Release|Any CPU
-		{32DC928D-5E5E-4BD4-AEF4-D46705E46126}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{32DC928D-5E5E-4BD4-AEF4-D46705E46126}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{32DC928D-5E5E-4BD4-AEF4-D46705E46126}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{32DC928D-5E5E-4BD4-AEF4-D46705E46126}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B4996AF5-9A8B-481A-9018-EC7F5B1605FF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B4996AF5-9A8B-481A-9018-EC7F5B1605FF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B4996AF5-9A8B-481A-9018-EC7F5B1605FF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B4996AF5-9A8B-481A-9018-EC7F5B1605FF}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

From d3c173d05494ec6544c9f7803a29b27450dba243 Mon Sep 17 00:00:00 2001
From: Lu Li <luli0401@gmail.com>
Date: Mon, 3 Feb 2020 10:56:54 -0700
Subject: [PATCH 13/15] Update the verion number for NumberExtensions project,

---
 UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj b/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
index 3cd9fa3e80..b5f7a889e1 100644
--- a/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
+++ b/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
@@ -2,7 +2,7 @@
   <!-- NuGet properties -->
   <PropertyGroup>
     <PackageId>UnitsNet.NumberExtensions</PackageId>
-    <Version>4.43.0</Version>
+    <Version>4.44.0</Version>
     <Authors>Andreas Gullberg Larsen</Authors>
     <Title>Units.NET NumberExtensions</Title>
     <Description>Adds extension methods to number types to more easily create quantities, such as 5.Meters() instead of Length.FromMeters(5).</Description>

From 15e4d8d23f7db9c0e4f0163f751ca8c48767c239 Mon Sep 17 00:00:00 2001
From: Lu Li <luli0401@gmail.com>
Date: Mon, 3 Feb 2020 12:16:45 -0700
Subject: [PATCH 14/15] Fix the NuGet package name, and add new test project to
 the build process.

---
 Build/build-functions.psm1 | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Build/build-functions.psm1 b/Build/build-functions.psm1
index cfd11bdd31..b4521037e3 100644
--- a/Build/build-functions.psm1
+++ b/Build/build-functions.psm1
@@ -60,6 +60,7 @@ function Start-Build([boolean] $IncludeWindowsRuntimeComponent = $false) {
 function Start-Tests {
   $projectPaths = @(
     "UnitsNet.Tests\UnitsNet.Tests.csproj",
+    "UnitsNet.NumberExtensions.Tests\UnitsNet.NumberExtensions.Tests.csproj",
     "UnitsNet.Serialization.JsonNet.Tests\UnitsNet.Serialization.JsonNet.Tests.csproj",
     "UnitsNet.Serialization.JsonNet.CompatibilityTests\UnitsNet.Serialization.JsonNet.CompatibilityTests.csproj"
     )
@@ -98,7 +99,7 @@ function Start-PackNugets {
   $projectPaths = @(
     "UnitsNet\UnitsNet.csproj",
     "UnitsNet.Serialization.JsonNet\UnitsNet.Serialization.JsonNet.csproj",
-    "UnitsNet.Extensions\UnitsNet.Extensions.csproj"
+    "UnitsNet.NumberExtensions\UnitsNet.NumberExtensions.csproj"
     )
 
   write-host -foreground blue "Pack nugets...`n---"

From 862a84f03be54ba020edf1b0bee384733d56eebb Mon Sep 17 00:00:00 2001
From: Lu Li <luli0401@gmail.com>
Date: Thu, 6 Feb 2020 10:11:54 -0700
Subject: [PATCH 15/15] Add more Authors to the NumberExtensions project.

---
 UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj b/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
index b5f7a889e1..56a3ba8ed7 100644
--- a/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
+++ b/UnitsNet.NumberExtensions/UnitsNet.NumberExtensions.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <PackageId>UnitsNet.NumberExtensions</PackageId>
     <Version>4.44.0</Version>
-    <Authors>Andreas Gullberg Larsen</Authors>
+    <Authors>Andreas Gullberg Larsen, Lu Li, Jon Suda</Authors>
     <Title>Units.NET NumberExtensions</Title>
     <Description>Adds extension methods to number types to more easily create quantities, such as 5.Meters() instead of Length.FromMeters(5).</Description>
     <Copyright>Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com).</Copyright>